src/engine/ServiceNode.cxx

   1 // Copyright (C) 2006-2012  CEA/DEN, EDF R&D
   2 //
   3 // This library is free software; you can redistribute it and/or
   4 // modify it under the terms of the GNU Lesser General Public
   5 // License as published by the Free Software Foundation; either
   6 // version 2.1 of the License.
   7 //
   8 // This library is distributed in the hope that it will be useful,
   9 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  10 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  11 // Lesser General Public License for more details.
  12 //
  13 // You should have received a copy of the GNU Lesser General Public
  14 // License along with this library; if not, write to the Free Software
  15 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  16 //
  17 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  18 //
  19
  20 #include "ServiceNode.hxx"
  21 #include "Visitor.hxx"
  22 #include "ComponentInstance.hxx"
  23 #include "ComposedNode.hxx"
  24 #include "Runtime.hxx"
  25 #include <iostream>
  26 #include <cassert>
  27
  28 //#define _DEVDEBUG_
  29 #include "YacsTrace.hxx"
  30
  31 using namespace YACS::ENGINE;
  32
  33 /*! \class YACS::ENGINE::ServiceNode
  34  *  \brief Class for calculation node associated with a component service
  35  *
  36  * \ingroup Nodes
  37  *
  38  * \see InlineNode
  39  * \see ElementaryNode
  40  */
  41
  42 const char ServiceNode::KIND[]="";
  43
  44 //! Return the service node kind
  45 /*!
  46  * A runtime can provide several implementations of a service node.
  47  * Each implementation has a different kind. A ComponentInstance can be
  48  * associated to a ServiceNode with the same kind.
  49  */
  50 std::string ServiceNode::getKind() const
  51 {
  52   return KIND;
  53 }
  54
  55 ServiceNode::ServiceNode(const std::string& name):ElementaryNode(name),_component(0)
  56 {
  57 }
  58
  59 ServiceNode::ServiceNode(const ServiceNode& other, ComposedNode *father)
  60            :ElementaryNode(other,father),_method(other._method),_component(0)
  61 {
  62 }
  63
  64 void ServiceNode::performDuplicationOfPlacement(const Node& other)
  65 {
  66   const ServiceNode &otherC=*(dynamic_cast<const ServiceNode *>(&other));
  67   //if other has no component don't clone: this will not have one
  68   if(otherC._component)
  69     _component=otherC._component->clone();
  70 }
  71
  72 ServiceNode::~ServiceNode()
  73 {
  74   if(_component)
  75     _component->decrRef();
  76 }
  77
  78 //! Load the component associated to the node
  79 void ServiceNode::load()
  80 {
  81   if(_component)
  82     {
  83       if(!_component->isLoaded())
  84         {
  85           try
  86             {
  87               _component->load();
  88             }
  89           catch(Exception& e)
  90             {
  91               _errorDetails=e.what();
  92               throw e;
  93             }
  94         }
  95     }
  96   else
  97     {
  98       std::string what("ServiceNode::load : a load operation requested on ServiceNode called \"");
  99       what+=_name; what+="\" with no component specified.";
 100       _errorDetails=what;
 101       throw Exception(what);
 102     }
 103 }
 104
 105 void ServiceNode::accept(Visitor *visitor)
 106 {
 107   visitor->visitServiceNode(this);
 108 }
 109
 110 //! Return the associated component instance
 111 ComponentInstance *ServiceNode::getComponent()
 112 {
 113   return _component;
 114 }
 115
 116 //! Return the associated container
 117 Container *ServiceNode::getContainer()
 118 {
 119   if(_component)return _component->getContainer();
 120   return 0;
 121 }
 122
 123 //! By definition of ServiceNode class.
 124 bool ServiceNode::isDeployable() const
 125 {
 126   return true;
 127 }
 128
 129 //! Associate an existing component instance to this service node \b AND check the consistency regarding the deployment from root node point of view.
 130 void ServiceNode::setComponent(ComponentInstance* compo) throw(YACS::Exception)
 131 {
 132   DEBTRACE("ServiceNode::setComponent " << compo);
 133   if(compo)
 134     {
 135       DEBTRACE(compo->getInstanceName());
 136       if(compo->getKind() != this->getKind())
 137         {
 138           //Not allowed
 139           std::string what("ServiceNode::setComponent : component instance kind not allowed ");
 140           throw Exception(what);
 141         }
 142     }
 143
 144   ComponentInstance* oldcompo=_component;
 145   std::string oldref=_ref;
 146
 147   _component=compo;
 148   _ref=compo->getCompoName();
 149   DEBTRACE(_component->getInstanceName());
 150   if(_component)
 151     {
 152       if(_father)
 153         try
 154           {
 155             getRootNode()->checkDeploymentTree(false);
 156           }
 157         catch(Exception& e)
 158           {
 159             // Impossible to associate compo to this node. Keep the old component instance and throws exception
 160             _component=oldcompo;
 161             _ref=oldref;
 162             throw e;
 163           }
 164       _component->incrRef();
 165     }
 166
 167   if(oldcompo)
 168     oldcompo->decrRef();
 169 }
 170
 171 //! Associate a new component instance to this service node
 172 /*!
 173  * A new component instance with type name ref is created (from runtime
 174  * factory createComponentInstance) and associated to the node.
 175  *
 176  */
 177 void ServiceNode::setRef(const std::string& ref)
 178 {
 179   _ref = ref;
 180   if(_component)
 181     {
 182       //The node is already associated with a component instance
 183       _component->decrRef();
 184       //Don't forget to unassociate
 185     }
 186   _component= getRuntime()->createComponentInstance(ref,getKind());
 187   YASSERT(_component);
 188 }
 189
 190 std::string ServiceNode::getRef()
 191 {
 192   return _ref;
 193 }