Save/Load manages HPContainers.

diff --git a/src/engine/Container.cxx b/src/engine/Container.cxx
index bac46ee42312d3433264bd25a31b5bd57be8c37e..d922a9deb97ac94d09d07d78a97144803988c9d0 100644 (file)
--- a/src/engine/Container.cxx
+++ b/src/engine/Container.cxx
@@ -28,6 +28,8 @@
 using namespace std;
 using namespace YACS::ENGINE;
 
+const char Container::KIND_ENTRY[]="container_kind";
+
 Container::Container():_isAttachedOnCloning(false),_proc(0)
 {
 }

diff --git a/src/engine/Container.hxx b/src/engine/Container.hxx
index 1d74f63de8fb63d0c5c2ab2986bef808bf878272..4dc8b354958e0820ff521d88b5bab90cc21c4f49 100644 (file)
--- a/src/engine/Container.hxx
+++ b/src/engine/Container.hxx
@@ -46,6 +46,7 @@ namespace YACS
       virtual ~Container();
 #endif
     public:
+      virtual std::string getKind() const = 0;
       //Execution only methods
       virtual std::string getDiscreminantStrOfThis(const Task *askingNode) const;
       virtual bool isAlreadyStarted(const Task *askingNode) const = 0;
@@ -76,6 +77,7 @@ namespace YACS
       void setProc(Proc* proc) { _proc = proc; }
       Proc* getProc() { return _proc; }
       virtual void shutdown(int level) = 0;
+      static const char KIND_ENTRY[];
     protected:
       std::string _name;
       mutable bool _isAttachedOnCloning;

diff --git a/src/engine/HomogeneousPoolContainer.cxx b/src/engine/HomogeneousPoolContainer.cxx
index 39c3a45c7b433ac665a29f782fb653ee355cf011..f79ee6af4a414c99ead63a1176a36a56c2b542e5 100644 (file)
--- a/src/engine/HomogeneousPoolContainer.cxx
+++ b/src/engine/HomogeneousPoolContainer.cxx
@@ -22,6 +22,8 @@
 
 using namespace YACS::ENGINE;
 
+const char HomogeneousPoolContainer::SIZE_OF_POOL_KEY[]="SizeOfPool";
+
 void HomogeneousPoolContainer::attachOnCloning() const
 {
   _isAttachedOnCloning=true;

diff --git a/src/engine/HomogeneousPoolContainer.hxx b/src/engine/HomogeneousPoolContainer.hxx
index c7869300891a39c60b59cf25459484f911b4a071..aabc4ca77d88046a01a67bd55132c828f6ee1cf2 100644 (file)
--- a/src/engine/HomogeneousPoolContainer.hxx
+++ b/src/engine/HomogeneousPoolContainer.hxx
@@ -42,9 +42,11 @@ namespace YACS
       bool isAttachedOnCloning() const;
       //
       virtual void setSizeOfPool(int sz) = 0;
+      virtual int getSizeOfPool() const = 0;
       virtual std::size_t getNumberOfFreePlace() const = 0;
       virtual void allocateFor(const std::vector<const Task *>& nodes) = 0;
       virtual void release(const Task *node) = 0;
+      static const char SIZE_OF_POOL_KEY[];
     protected:
       HomogeneousPoolContainer();
 #ifndef SWIG

diff --git a/src/engine/Proc.cxx b/src/engine/Proc.cxx
index 46185cc7fb883f8652bd35e571037c300856d176..c168305be4f96840b73ed2d2312c5dd5c8050855 100644 (file)
--- a/src/engine/Proc.cxx
+++ b/src/engine/Proc.cxx
@@ -443,7 +443,7 @@ void Proc::modified()
 /*!
  * \param xmlSchemaFile: the file name
  */
-void Proc::saveSchema(std::string xmlSchemaFile)
+void Proc::saveSchema(const std::string& xmlSchemaFile)
 {
   VisitorSaveSchema vss(this);
   vss.openFileSchema(xmlSchemaFile);
@@ -455,7 +455,7 @@ void Proc::saveSchema(std::string xmlSchemaFile)
 /*!
  * \param xmlStateFile: the file name
  */
-void Proc::saveState(std::string xmlStateFile)
+void Proc::saveState(const std::string& xmlStateFile)
 {
   VisitorSaveState vst(this);
   vst.openFileDump(xmlStateFile);
@@ -469,9 +469,9 @@ void Proc::saveState(std::string xmlStateFile)
  * \param kind: the container kind (depends on runtime)
  * \return the created Container
  */
-Container* Proc::createContainer(const std::string& name,const std::string& kind)
+Container *Proc::createContainer(const std::string& name, const std::string& kind)
 {
-  Container* co=  getRuntime()->createContainer(kind);
+  Container *co(getRuntime()->createContainer(kind));
   co->setName(name);
   if(containerMap.count(name)!=0)
     containerMap[name]->decrRef();

diff --git a/src/engine/Proc.hxx b/src/engine/Proc.hxx
index fe44ed6300b9ed04c6efd965e7534b7b63cec2b7..05a90029b442ddfe8d8c1eca006591d615c6a859 100644 (file)
--- a/src/engine/Proc.hxx
+++ b/src/engine/Proc.hxx
@@ -40,7 +40,7 @@ namespace YACS
     class ComponentInstance;
     class Logger;
 
-    class YACSLIBENGINE_EXPORT Proc: public Bloc
+    class YACSLIBENGINE_EXPORT Proc : public Bloc
     {
     public:
       Proc(const std::string& name);
@@ -51,10 +51,10 @@ namespace YACS
       virtual TypeCode *createSequenceTc (const std::string& id, const std::string& name, 
                                          TypeCode *content);
       virtual TypeCode *createStructTc (const std::string& id, const std::string& name);
-      virtual TypeCode* getTypeCode(const std::string& name);
+      virtual TypeCode *getTypeCode(const std::string& name);
       virtual void setTypeCode(const std::string& name,TypeCode *t);
-      virtual Container* createContainer(const std::string& name,const std::string& kind="");
-      virtual ComponentInstance* createComponentInstance(const std::string& componame, 
+      virtual Container *createContainer(const std::string& name, const std::string& kind="");
+      virtual ComponentInstance *createComponentInstance(const std::string& componame,
                                                          const std::string& name="",
                                                          const std::string& kind="");
       virtual void addComponentInstance(ComponentInstance* inst, const std::string& name="",bool resetCtr=false);
@@ -62,7 +62,7 @@ namespace YACS
       virtual void removeContainer(Container* cont);
       virtual void accept(Visitor *visitor);
       virtual Proc *getProc();
-      virtual const Proc * getProc() const;
+      virtual const Proc *getProc() const;
 
       YACS::StatesForNode getNodeState(int numId);
       std::string getNodeProgress(int numId);
@@ -95,8 +95,8 @@ namespace YACS
       virtual bool getEdition(){return _edition;}
       virtual void setEdition(bool edition);
       virtual void modified();
-      virtual void saveSchema(std::string xmlSchemaFile);
-      virtual void saveState(std::string xmlStateFile);
+      virtual void saveSchema(const std::string& xmlSchemaFile);
+      virtual void saveState(const std::string& xmlStateFile);
     protected:
       bool _edition;
       int _compoinstctr;

diff --git a/src/engine/Test/ContainerTest.cxx b/src/engine/Test/ContainerTest.cxx
index f1450843e9dddf00d6726311ab6c063d30a4af5e..638b9055eed5b3419be4777b00fef01fe3c470eb 100644 (file)
--- a/src/engine/Test/ContainerTest.cxx
+++ b/src/engine/Test/ContainerTest.cxx
@@ -37,6 +37,11 @@ ContainerTest::ContainerTest():_alreadyStarted(false),_myCounter(_counter++)
 {
 }
 
+std::string ContainerTest::getKind() const
+{
+  return std::string();
+}
+
 std::string ContainerTest::getPlacementInfo() const
 {
   ostringstream stream;
@@ -87,6 +92,11 @@ ContainerTest2::ContainerTest2():_alreadyStarted(false),_myCounter(_counter++)
 {
 }
 
+std::string ContainerTest2::getKind() const
+{
+  return std::string();
+}
+
 bool ContainerTest2::isAlreadyStarted(const Task *askingNode) const
 {
   return _alreadyStarted;

diff --git a/src/engine/Test/ContainerTest.hxx b/src/engine/Test/ContainerTest.hxx
index d530fb5a3679721d1aa354423f4b6ff143ad3848..405127d60b62a7f38a41ac6e403da343b964471b 100644 (file)
--- a/src/engine/Test/ContainerTest.hxx
+++ b/src/engine/Test/ContainerTest.hxx
@@ -30,6 +30,7 @@ namespace YACS
     {
     public:
       ContainerTest();
+      std::string getKind() const;
       std::string getPlacementInfo() const;
       // implementation of compulsary methods
       bool isAlreadyStarted(const Task *askingNode) const;
@@ -63,6 +64,7 @@ namespace YACS
     {
     public:
       ContainerTest2();
+      std::string getKind() const;
       // implementation of compulsary methods
       bool isAlreadyStarted(const Task *askingNode) const;
       void start(const Task *askingNode) throw(Exception);

diff --git a/src/engine/VisitorSaveSchema.cxx b/src/engine/VisitorSaveSchema.cxx
index cc6cd1c1a04543d131405d71ea9da4d8845ea1fd..2b6f2ceb8d099936d9e1acbee9191a41f6013cbd 100644 (file)
--- a/src/engine/VisitorSaveSchema.cxx
+++ b/src/engine/VisitorSaveSchema.cxx
@@ -699,6 +699,7 @@ void VisitorSaveSchema::writeContainers(Proc *proc)
     {
       string name = it->first;
       _out << indent(depth) << "<container name=\"" << name << "\">" << endl;
+      _out << indent(depth+1) << "<property name=\"" << Container::KIND_ENTRY << "\" value=\"" << it->second->getKind() << "\"/>" << endl;
       map<string, string> properties = (it->second)->getProperties();
       map<string, string>::iterator itm;
       for(itm = properties.begin(); itm != properties.end(); ++itm)

diff --git a/src/engine/VisitorSaveState.cxx b/src/engine/VisitorSaveState.cxx
index cd1197ac595641454500fba42e193b13999e32f4..ca6b594afaa749ec6379e34640debdd63f6194a0 100644 (file)
--- a/src/engine/VisitorSaveState.cxx
+++ b/src/engine/VisitorSaveState.cxx
@@ -72,7 +72,7 @@ VisitorSaveState::~VisitorSaveState()
     }
 }
 
-void VisitorSaveState::openFileDump(std::string xmlDump) throw(YACS::Exception)
+void VisitorSaveState::openFileDump(const std::string& xmlDump) throw(YACS::Exception)
 {
   _out.open(xmlDump.c_str(), ios::out);
   if (!_out)

diff --git a/src/engine/VisitorSaveState.hxx b/src/engine/VisitorSaveState.hxx
index b1e10b1871ac63fd1ed57b2b6f79c81e8a3bdee6..13f2431510b355160d3acbd5a834dfc3d05b0cc5 100644 (file)
--- a/src/engine/VisitorSaveState.hxx
+++ b/src/engine/VisitorSaveState.hxx
@@ -37,7 +37,7 @@ namespace YACS
     public:
       VisitorSaveState(ComposedNode *root);
       virtual ~VisitorSaveState();
-      void openFileDump(std::string xmlDump) throw(Exception);
+      void openFileDump(const std::string& xmlDump) throw(Exception);
       void closeFileDump();
       virtual void visitBloc(Bloc *node);
       virtual void visitElementaryNode(ElementaryNode *node);

diff --git a/src/runtime/CppContainer.cxx b/src/runtime/CppContainer.cxx
index 18a330d9b0d2487868b3160c1345eae5316f350e..4366724d2a0e0eeca46f6fc8f549d102540d50ec 100644 (file)
--- a/src/runtime/CppContainer.cxx
+++ b/src/runtime/CppContainer.cxx
@@ -37,6 +37,8 @@
 
 using namespace YACS::ENGINE;
 
+char CppContainer::KIND[]="Cpp";
+
 //#define _DEVDEBUG_
 #include "YacsTrace.hxx"
 
@@ -73,6 +75,11 @@ void CppContainer::unLock()
   _mutex.unLock();
 }
 
+std::string CppContainer::getKind() const
+{
+  return KIND;
+}
+
 bool CppContainer::isAlreadyStarted(const Task *askingNode) const
 {
   return NULL != _trueCont;

diff --git a/src/runtime/CppContainer.hxx b/src/runtime/CppContainer.hxx
index 0f338f3eace731020a2018c5fed7e035b45b9621..3a75d6396670628aa0c3323fd033c18f591cfa36 100644 (file)
--- a/src/runtime/CppContainer.hxx
+++ b/src/runtime/CppContainer.hxx
@@ -107,6 +107,7 @@ namespace YACS
     public:
       CppContainer();
       virtual ~CppContainer();
+      std::string getKind() const;
       bool isAlreadyStarted(const Task *askingNode) const;
       void start(const Task *askingNode) throw (YACS::Exception);
       void shutdown(int level);
@@ -131,6 +132,8 @@ namespace YACS
       std::map<std::string,std::string> getProperties() const { return std::map<std::string,std::string>(); }
       std::map<std::string,std::string> getResourceProperties(const std::string& name) const { return std::map<std::string,std::string>(); }
       //
+    public:
+      static char KIND[];
     protected:
       YACS::BASES::Mutex _mutex;
       LocalContainer * _trueCont;

diff --git a/src/runtime/RuntimeSALOME.cxx b/src/runtime/RuntimeSALOME.cxx
index f3f43e2cbfeb69292868db0b2d06adc90afc7c50..58e5e8e504cc69a5066ac71237fdc590d02c295c 100644 (file)
--- a/src/runtime/RuntimeSALOME.cxx
+++ b/src/runtime/RuntimeSALOME.cxx
@@ -597,11 +597,11 @@ ComponentInstance* RuntimeSALOME::createComponentInstance(const std::string& nam
 
 Container *RuntimeSALOME::createContainer(const std::string& kind)
 {
-  if(kind == "" || kind == SalomeComponent::KIND)
+  if(kind == "" || kind == SalomeContainer::KIND)
     return new SalomeContainer;
   if(kind==SalomeHPContainer::KIND)
     return new SalomeHPContainer;
-  else if (kind == CppComponent::KIND)
+  else if (kind == CppContainer::KIND)
     return new CppContainer;
   std::string msg="Container kind ("+kind+") unknown";
   throw Exception(msg);

diff --git a/src/runtime/SalomeContainer.cxx b/src/runtime/SalomeContainer.cxx
index 1f12874098524f7922daf9755de712c5c1b3d7f9..08f851c41654648a2edabb3d6bc4055b2f9f215c 100644 (file)
--- a/src/runtime/SalomeContainer.cxx
+++ b/src/runtime/SalomeContainer.cxx
@@ -52,6 +52,8 @@
 using namespace YACS::ENGINE;
 using namespace std;
 
+const char SalomeContainer::KIND[]="Salome";
+
 SalomeContainer::SalomeContainer():_launchModeType(new SalomeContainerMonoHelper),_shutdownLevel(999)
 {
 }
@@ -87,6 +89,11 @@ void SalomeContainer::unLock()
   _mutex.unLock();
 }
 
+std::string SalomeContainer::getKind() const
+{
+  return KIND;
+}
+
 Container *SalomeContainer::clone() const
 {
   if(_isAttachedOnCloning)

diff --git a/src/runtime/SalomeContainer.hxx b/src/runtime/SalomeContainer.hxx
index 4910dcb519fe6ad5a0753bf15068b310e60b055f..7fdc9be48e39eddbb4542d76842268f2992149d1 100644 (file)
--- a/src/runtime/SalomeContainer.hxx
+++ b/src/runtime/SalomeContainer.hxx
@@ -48,6 +48,7 @@ namespace YACS
       void lock();
       //! For thread safety for concurrent load operation on same Container.
       void unLock();
+      std::string getKind() const;
       bool isAlreadyStarted(const Task *askingNode) const;
       Engines::Container_ptr getContainerPtr(const Task *askingNode) const;
       void start(const Task *askingNode) throw (Exception);
@@ -66,6 +67,7 @@ namespace YACS
       // Helper methods
       std::map<std::string,std::string> getResourceProperties(const std::string& name) const;
       std::map<std::string,std::string> getProperties() const;
+      static const char KIND[];
     protected:
 #ifndef SWIG
       virtual ~SalomeContainer();

diff --git a/src/runtime/SalomeHPContainer.cxx b/src/runtime/SalomeHPContainer.cxx
index 1add756cdab3e19a1910cc2ec96c28a51e751d3f..ae65b11e39ddd8895481fb323ede36af7786ef71 100644 (file)
--- a/src/runtime/SalomeHPContainer.cxx
+++ b/src/runtime/SalomeHPContainer.cxx
@@ -41,6 +41,11 @@ void SalomeHPContainer::setSizeOfPool(int sz)
   _launchModeType.resize(sz);
 }
 
+int SalomeHPContainer::getSizeOfPool() const
+{
+  return _launchModeType.size();
+}
+
 std::size_t SalomeHPContainer::getNumberOfFreePlace() const
 {
   return _launchModeType.getNumberOfFreePlace();
@@ -70,6 +75,11 @@ void SalomeHPContainer::unLock()
   _mutex.unLock();
 }
 
+std::string SalomeHPContainer::getKind() const
+{
+  return KIND;
+}
+
 std::string SalomeHPContainer::getDiscreminantStrOfThis(const Task *askingNode) const
 {
   YACS::BASES::AutoCppPtr<SalomeContainerTmpForHP> tmpCont(SalomeContainerTmpForHP::BuildFrom(this,askingNode));
@@ -128,12 +138,26 @@ Container *SalomeHPContainer::cloneAlways() const
 
 void SalomeHPContainer::setProperty(const std::string& name,const std::string& value)
 {
-  _sct.setProperty(name,value);
+  if(name==SIZE_OF_POOL_KEY)
+    {
+      std::istringstream iss(value);
+      int val(0);
+      iss >> val;
+      setSizeOfPool(val);
+    }
+  else
+    _sct.setProperty(name,value);
 }
 
 std::string SalomeHPContainer::getProperty(const std::string& name) const
 {
-  return _sct.getProperty(name);
+  if(name==SIZE_OF_POOL_KEY)
+    {
+      std::ostringstream oss; oss << getSizeOfPool();
+      return oss.str();
+    }
+  else
+    return _sct.getProperty(name);
 }
 
 void SalomeHPContainer::clearProperties()
@@ -148,7 +172,10 @@ void SalomeHPContainer::addComponentName(const std::string& name)
 
 std::map<std::string,std::string> SalomeHPContainer::getProperties() const
 {
-  return _sct.getProperties();
+  std::map<std::string,std::string> ret(_sct.getProperties());
+  std::ostringstream oss; oss << getSizeOfPool();
+  ret[SIZE_OF_POOL_KEY]=oss.str();
+  return ret;
 }
 
 std::map<std::string,std::string> SalomeHPContainer::getResourceProperties(const std::string& name) const

diff --git a/src/runtime/SalomeHPContainer.hxx b/src/runtime/SalomeHPContainer.hxx
index 879dff414a5bc4d7a520bec939c382ff7143d6b1..eba0d45e6823542896eb83faf41a0c73219d94ff 100644 (file)
--- a/src/runtime/SalomeHPContainer.hxx
+++ b/src/runtime/SalomeHPContainer.hxx
@@ -47,6 +47,7 @@ namespace YACS
       SalomeHPContainer(const SalomeHPContainer& other);
       //HP specific part
       void setSizeOfPool(int sz);
+      int getSizeOfPool() const;
       std::size_t getNumberOfFreePlace() const;
       void allocateFor(const std::vector<const Task *>& nodes);
       void release(const Task *node);
@@ -55,6 +56,7 @@ namespace YACS
       //! For thread safety for concurrent load operation on same Container.
       void unLock();
       //
+      std::string getKind() const;
       std::string getDiscreminantStrOfThis(const Task *askingNode) const;
       bool isAlreadyStarted(const Task *askingNode) const;
       void start(const Task *askingNode) throw(Exception);

diff --git a/src/yacsloader/procParsers.hxx b/src/yacsloader/procParsers.hxx
index 8384fbb4c1dab80e4a7ccadb5ada83cf462a069b..cc02ff46aa7150364b906a82276ceab511d755bd 100644 (file)
--- a/src/yacsloader/procParsers.hxx
+++ b/src/yacsloader/procParsers.hxx
@@ -53,11 +53,13 @@ struct proctypeParser: bloctypeParser<T>
     {
       for (int i = 0; attr[i]; i += 2) 
         {
-          if(std::string(attr[i]) == "state")this->state(attr[i+1]);
-          if(std::string(attr[i]) == "name")name(attr[i+1]);
+          if(std::string(attr[i]) == "state")
+            this->state(attr[i+1]);
+          if(std::string(attr[i]) == "name")
+            name(attr[i+1]);
         }
     }
-  virtual void pre ()
+  virtual void pre()
     {
         std::string name("proc");
         currentProc=theRuntime->createProc(name);
@@ -65,34 +67,34 @@ struct proctypeParser: bloctypeParser<T>
         currentProc->names.push_back("");
     }
 
-  virtual void name (const std::string& name)
+  virtual void name(const std::string& name)
     {
       currentProc->setName(name);
     }
 
-  virtual void type (const mytype& t)
+  virtual void type(const mytype& t)
     {
         DEBTRACE( "type_set" );
         YACS::ENGINE::TypeCode* tt=currentProc->createType(t._name,t._kind);
         tt->decrRef();
     }
-  virtual void sequence (ENGINE::TypeCode* const& t)
+  virtual void sequence(ENGINE::TypeCode* const& t)
     {
         DEBTRACE( "sequence_set" );
         t->decrRef();
     }
-  virtual void objref (ENGINE::TypeCode* const& t)
+  virtual void objref(ENGINE::TypeCode* const& t)
     {
         DEBTRACE( "objref_set" );
         t->decrRef();
     }
-  virtual void struct_ (ENGINE::TypeCode* const& t)
+  virtual void struct_(ENGINE::TypeCode* const& t)
     {
         DEBTRACE( "struct_set" );
         t->decrRef();
     }
 
-  virtual void componentinstance (const mycomponentinstance& t)
+  virtual void componentinstance(const mycomponentinstance& t)
     {
       DEBTRACE( "componentinstance: " << t._name );
       YACS::ENGINE::ComponentInstance* inst=currentProc->createComponentInstance(t._component,t._name,t._kind);
@@ -128,7 +130,7 @@ struct proctypeParser: bloctypeParser<T>
       inst->decrRef();
     }
 
-  virtual void container (const mycontainer& t)
+  virtual void container(const mycontainer& t)
     {
       DEBTRACE( "container_set: " << t._name )             
       std::vector<machine>::const_iterator iter;
@@ -143,16 +145,20 @@ struct proctypeParser: bloctypeParser<T>
         }
       else
         {
-          YACS::ENGINE::Container* cont=currentProc->createContainer(t._name);
           // Set all properties for this container
-          std::map<std::string, std::string>::const_iterator pt;
+          std::string kindOfContainer;
+          std::map<std::string, std::string>::const_iterator pt(t._props.find(std::string(ENGINE::Container::KIND_ENTRY)));
+          if(pt!=t._props.end())
+            kindOfContainer=pt->second;
+          YACS::ENGINE::Container *cont(currentProc->createContainer(t._name,kindOfContainer));
           for(pt=t._props.begin();pt!=t._props.end();pt++)
-            cont->setProperty((*pt).first,(*pt).second);
+            if((*pt).second!=ENGINE::Container::KIND_ENTRY)
+              cont->setProperty((*pt).first,(*pt).second);
           cont->decrRef();
         }
     }
 
-  T post(){return this->_bloc;}
+  T post() { return this->_bloc; }
 };
 
 template <class T> proctypeParser<T> proctypeParser<T>::procParser;

diff --git a/src/yacsloader/serverParsers.hxx b/src/yacsloader/serverParsers.hxx
index 3a3cdd0014d49cf4539af27f963b7ee5b1316fc4..11b65a1abedf278350f8ee17b1afce11407e5300 100644 (file)
--- a/src/yacsloader/serverParsers.hxx
+++ b/src/yacsloader/serverParsers.hxx
@@ -68,10 +68,18 @@ struct servertypeParser:public inlinetypeParser<T>
     {
       DEBTRACE( "server_loadcontainer: " << name )             
       this->_node=(YACS::ENGINE::ServerNode*)theRuntime->createFuncNode("DistPython",this->_name);
-      YACS::ENGINE::Container *cont=currentProc->createContainer(this->_node->getEffectiveKindOfServer());
-      cont->setName(name);
-      this->_node->setContainer(cont);
-      cont->decrRef();
+      std::map<std::string,YACS::ENGINE::Container *>::const_iterator it(currentProc->containerMap.find(name));
+      if(it!=currentProc->containerMap.end())
+        {
+          this->_node->setContainer((*it).second);
+        }
+      else
+        {
+          YACS::ENGINE::Container *cont=currentProc->createContainer(this->_node->getEffectiveKindOfServer());
+          cont->setName(name);
+          this->_node->setContainer(cont);
+          cont->decrRef();
+        }
     }
   virtual void script (const myfunc& f)
   {