src/runtime/SalomeComponent.cxx

   1 #include "RuntimeSALOME.hxx"
   2 #include "SalomeComponent.hxx"
   3 #include "SalomeContainer.hxx"
   4 #include "CORBANode.hxx"
   5
   6 #ifdef SALOME_KERNEL
   7 #include "SALOME_NamingService.hxx"
   8 #include "SALOME_LifeCycleCORBA.hxx"
   9 #endif
  10
  11 #include <omniORB4/CORBA.h>
  12 #include <iostream>
  13 #include <sstream>
  14
  15 using namespace YACS::ENGINE;
  16 using namespace std;
  17
  18 const char SalomeComponent::KIND[]="Salome";
  19
  20 //! SalomeComponent constructor
  21 SalomeComponent::SalomeComponent(const std::string& name): ComponentInstance(name)
  22 {
  23   _objComponent=CORBA::Object::_nil();
  24 }
  25
  26 //! SalomeComponent copy constructor
  27 SalomeComponent::SalomeComponent(const SalomeComponent& other):ComponentInstance(other)
  28 {
  29   _objComponent=CORBA::Object::_nil();
  30 }
  31
  32 SalomeComponent::~SalomeComponent()
  33 {
  34 }
  35
  36 std::string SalomeComponent::getKind() const
  37 {
  38   return KIND;
  39 }
  40
  41 //! Unload the component
  42 void SalomeComponent::unload()
  43 {
  44   //Not implemented
  45   std::cerr << "SalomeComponent::unload : not implemented " << std::endl;
  46 }
  47
  48 //! Is the component instance already loaded ?
  49 bool SalomeComponent::isLoaded()
  50 {
  51   if(CORBA::is_nil(_objComponent))
  52     return false;
  53   else
  54     return true;
  55 }
  56
  57 #ifdef SALOME_KERNEL
  58 //! Load the component
  59 void SalomeComponent::load()
  60 {
  61   if(_container)
  62     {
  63       SalomeContainer *containerC=(SalomeContainer *)_container;
  64       containerC->lock();//To be sure
  65       if(!_container->isAlreadyStarted())
  66         {
  67           try
  68             {
  69               _container->start();
  70             }
  71           catch(Exception& e)
  72             {
  73               containerC->unLock();
  74               throw e;
  75             }
  76         }
  77       containerC->unLock();
  78       containerC->lock();//To be sure
  79       const char* componentName=_compoName.c_str();
  80       //char *val2=CORBA::string_dup("");
  81       // does not work with python components
  82       // does not make a strict load but a find or load component
  83       //   _objComponent=containerC->_trueCont->load_impl(componentName,val2);
  84       bool isLoadable = containerC->_trueCont->load_component_Library(componentName);
  85       if (isLoadable)
  86         if (containerC->isAPaCOContainer()) {
  87           std::string compo_paco_name(componentName);
  88           compo_paco_name = compo_paco_name + "@PARALLEL@";
  89           char * c_paco_name = CORBA::string_dup(compo_paco_name.c_str());
  90           _objComponent=containerC->_trueCont->create_component_instance(c_paco_name, 0);
  91         }
  92         else
  93           _objComponent=containerC->_trueCont->create_component_instance(componentName, 0);
  94
  95       if(CORBA::is_nil(_objComponent))
  96         {
  97           containerC->unLock();
  98           std::string text="Error while trying to create a new component: component '"+ _compoName;
  99           text=text+"' is not installed or it's a wrong name";
 100           throw Exception(text);
 101         }
 102       containerC->unLock();
 103       return;
 104     }
 105   //throw Exception("SalomeComponent::load : no container specified !!! To be implemented in executor to allocate default a Container in case of presenceOfDefaultContainer.");
 106   //This component has no specified container : use default container policy
 107   SALOME_NamingService ns(getSALOMERuntime()->getOrb());
 108   SALOME_LifeCycleCORBA LCC(&ns);
 109   Engines::MachineParameters params;
 110   LCC.preSet(params);
 111   params.hostname="localhost";
 112   params.container_name ="FactoryServer";
 113   _objComponent=LCC.LoadComponent(params,_compoName.c_str());
 114 }
 115 #else
 116 void SalomeComponent::load()
 117 {
 118   throw Exception("YACS has been built without SALOME support");
 119 }
 120 #endif
 121
 122 //! Create a ServiceNode with this component instance and no input or output port
 123 /*!
 124  *   \param name : node name
 125  *   \return       a new SalomeNode node
 126  */
 127 ServiceNode* SalomeComponent::createNode(const std::string& name)
 128 {
 129    SalomeNode* node=new SalomeNode(name);
 130    node->setComponent(this);
 131    return node;
 132 }
 133
 134 //! Clone the component instance
 135 ComponentInstance* SalomeComponent::clone() const
 136 {
 137   if(_isAttachedOnCloning)
 138     {
 139       incrRef();
 140       return (ComponentInstance*) (this);
 141     }
 142   else
 143     return new SalomeComponent(*this);
 144 }
 145
 146 std::string SalomeComponent::getFileRepr() const
 147 {
 148   ostringstream stream;
 149   stream << "<component>" << getCompoName() << "</component>";
 150   return stream.str();
 151 }
 152
 153 void SalomeComponent::setContainer(Container *cont)
 154 {
 155   if (cont == _container) return;
 156
 157   if(cont)
 158     cont->checkCapabilityToDealWith(this);
 159
 160   if(_container)
 161     _container->decrRef();
 162   _container=cont;
 163   if(_container)
 164   {
 165     _container->incrRef();
 166     ((SalomeContainer*)_container)->addComponentName(_compoName);
 167   }
 168 }
 169