Fix memory corruption and refactor some points.

diff --git a/src/bases/CMakeLists.txt b/src/bases/CMakeLists.txt
index 95bb14f9f97d7889bc0f6fc8d37bfedaf1d529c5..a2f3b380c953c14a4482d3ba004e907f0171ec92 100644 (file)
--- a/src/bases/CMakeLists.txt
+++ b/src/bases/CMakeLists.txt
@@ -44,6 +44,7 @@ SET(YACSBases_HEADERS
   DynLibLoader.hxx
   DynLibLoaderWin.hxx
   Exception.hxx
+  AutoRefCnt.hxx
   Mutex.hxx
   MutexPT.hxx
   Semaphore.hxx

diff --git a/src/engine/Bloc.cxx b/src/engine/Bloc.cxx
index 422e3947099d20254774fec16953c5ee051f032c..b12217dfb02b919e2637203f5cced5bc8e102a35 100644 (file)
--- a/src/engine/Bloc.cxx
+++ b/src/engine/Bloc.cxx
@@ -229,10 +229,6 @@ Node *Bloc::getChildByShortName(const std::string& name) const throw(YACS::Excep
   throw Exception(what);
 }
 
-void Bloc::selectRunnableTasks(std::vector<Task *>& tasks)
-{
-}
-
 bool Bloc::areAllSubNodesDone() const
 {
   for(list<Node *>::const_iterator iter=_setOfNode.begin();iter!=_setOfNode.end();iter++)

diff --git a/src/engine/Bloc.hxx b/src/engine/Bloc.hxx
index dce0ee4853d8a2958531d929f7b9a9993fe59a34..98f2e0fc0b6f9d6920fe16c4b105216d452a9c12 100644 (file)
--- a/src/engine/Bloc.hxx
+++ b/src/engine/Bloc.hxx
@@ -52,7 +52,6 @@ namespace YACS
       std::list<Node *> getChildren() const { return _setOfNode; }
       std::list<Node *> edGetDirectDescendants() const { return _setOfNode; }
       Node *getChildByShortName(const std::string& name) const throw(Exception);
-      void selectRunnableTasks(std::vector<Task *>& tasks);
       virtual void writeDot(std::ostream &os) const;
       void accept(Visitor *visitor);
       template<bool direction>

diff --git a/src/engine/ComponentInstance.cxx b/src/engine/ComponentInstance.cxx
index ff83a2e58b54ce946b7035a00fc41a304097e781..c8f8457243fa5f90c1d1d6c44a19c07dea2a1b4a 100644 (file)
--- a/src/engine/ComponentInstance.cxx
+++ b/src/engine/ComponentInstance.cxx
@@ -49,9 +49,9 @@ int ComponentInstance::_total = 0;
 
 const char ComponentInstance::NULL_FILE_REPR[]="No repr specified for ComponentInstance";
 
-void ComponentInstance::setContainer(Container *cont)
+bool ComponentInstance::setContainer(Container *cont)
 {
-  if (cont == _container) return;
+  if (cont == _container) return false;
   
   if(cont)
     cont->checkCapabilityToDealWith(this);
@@ -60,6 +60,7 @@ void ComponentInstance::setContainer(Container *cont)
   _container=cont;
   if(_container)
     _container->incrRef();
+  return true;
 }
 
 ComponentInstance::ComponentInstance(const std::string& name):_compoName(name),_isAttachedOnCloning(false),_container(0),_anonymous(true)

diff --git a/src/engine/ComponentInstance.hxx b/src/engine/ComponentInstance.hxx
index f76ff3019551168a23192908f861fc6b7909fcb2..8f593af6250d5ec2de2ed4b7eb2b308231c32b71 100644 (file)
--- a/src/engine/ComponentInstance.hxx
+++ b/src/engine/ComponentInstance.hxx
@@ -48,7 +48,7 @@ namespace YACS
       virtual void setAnonymous(bool anon) { _anonymous = anon; };
       virtual bool isAnonymous() { return _anonymous; };
       int getNumId() const { return _numId; }
-      virtual void setContainer(Container *cont);
+      virtual bool setContainer(Container *cont);
       Container *getContainer() const { return _container; }
 //! Load the component instance
       virtual void load(Task *askingNode) = 0;

diff --git a/src/engine/Container.hxx b/src/engine/Container.hxx
index 1a7c2aed254220dab3ba40b5b3c0ea9b0f0e7f22..6c8b8ed173bf6c7992b5fa20a4b75e132ade6f4e 100644 (file)
--- a/src/engine/Container.hxx
+++ b/src/engine/Container.hxx
@@ -65,6 +65,7 @@ namespace YACS
       virtual void setProperty(const std::string& name,const std::string& value) = 0;
       virtual std::string getProperty(const std::string& name) const = 0;
       virtual void clearProperties() = 0;
+      virtual void addComponentName(const std::string& name) = 0;
       virtual std::map<std::string,std::string> getProperties() const = 0;
       virtual std::map<std::string,std::string> getResourceProperties(const std::string& name) const = 0;
       virtual void setProperties(const std::map<std::string,std::string>& properties);

diff --git a/src/engine/Loop.cxx b/src/engine/Loop.cxx
index bf56f7789275a23effced0fdc1f072547a5f430c..0ea4a1c1c5b779839da5f5f1373c526f4aa7d4fe 100644 (file)
--- a/src/engine/Loop.cxx
+++ b/src/engine/Loop.cxx
@@ -392,10 +392,6 @@ void Loop::edRemoveChild(Node *node) throw(YACS::Exception)
   modified();
 }
 
-void Loop::selectRunnableTasks(std::vector<Task *>& tasks)
-{
-}
-
 std::list<Node *> Loop::edGetDirectDescendants() const
 {
   list<Node *> ret;

diff --git a/src/engine/Loop.hxx b/src/engine/Loop.hxx
index 395cca0a43fd5c2168ec6b9892a9fc518fd2e77e..f5558552e59a95d109d8879a855c9ac96d54ecee 100644 (file)
--- a/src/engine/Loop.hxx
+++ b/src/engine/Loop.hxx
@@ -169,7 +169,6 @@ namespace YACS
       void getReadyTasks(std::vector<Task *>& tasks);
       void edRemoveChild(Node *node) throw(Exception);
       bool isRepeatedUnpredictablySeveralTimes() const { return true; }
-      void selectRunnableTasks(std::vector<Task *>& tasks);
       std::list<Node *> edGetDirectDescendants() const;
       std::list<InputPort *> getSetOfInputPort() const;
       int getNumberOfInputPorts() const;

diff --git a/src/engine/StaticDefinedComposedNode.cxx b/src/engine/StaticDefinedComposedNode.cxx
index b460cfd4e578edee650028210477fad151820108..504b5cd79e0ec5b7808d606c1d58989eeddfd598 100644 (file)
--- a/src/engine/StaticDefinedComposedNode.cxx
+++ b/src/engine/StaticDefinedComposedNode.cxx
@@ -48,6 +48,10 @@ void StaticDefinedComposedNode::forceMultiplicity(unsigned value)
   //no sense for this class
 }
 
+void StaticDefinedComposedNode::selectRunnableTasks(std::vector<Task *>& tasks)
+{
+}
+
 void StaticDefinedComposedNode::checkControlDependancy(OutPort *start, InPort *end, bool cross,
                                                        std::map < ComposedNode *,  std::list < OutPort * >, SortHierarc >& fw,
                                                        std::vector<OutPort *>& fwCross,

diff --git a/src/engine/StaticDefinedComposedNode.hxx b/src/engine/StaticDefinedComposedNode.hxx
index 03c8ac512dbcaa1034d6ed368777b7e13dc739d8..f1b0100e60a5f869fee08ac5ddcd608289c4076b 100644 (file)
--- a/src/engine/StaticDefinedComposedNode.hxx
+++ b/src/engine/StaticDefinedComposedNode.hxx
@@ -40,6 +40,7 @@ namespace YACS
       bool isPlacementPredictableB4Run() const;
       bool isMultiplicitySpecified(unsigned& value) const;
       void forceMultiplicity(unsigned value);
+      void selectRunnableTasks(std::vector<Task *>& tasks);
     protected:
       void checkControlDependancy(OutPort *start, InPort *end, bool cross,
                                   std::map < ComposedNode *,  std::list < OutPort * >, SortHierarc >& fw,

diff --git a/src/engine/Switch.cxx b/src/engine/Switch.cxx
index 93323cafddfc802ecc84d4b3bdb08cd47e45260c..947473706575d82b4c3bc363ae891ad37778b119 100644 (file)
--- a/src/engine/Switch.cxx
+++ b/src/engine/Switch.cxx
@@ -386,10 +386,6 @@ void Switch::getReadyTasks(std::vector<Task *>& tasks)
     }
 }
 
-void Switch::selectRunnableTasks(std::vector<Task *>& tasks)
-{
-}
-
 list<Node *> Switch::edGetDirectDescendants() const
 {
   list<Node *> ret;

diff --git a/src/engine/Switch.hxx b/src/engine/Switch.hxx
index bc4b7460e8b7ccbb69f8704ed5f4ca51998c3149..5d0ccb7175c455644b8939808ca95d279e8fc4b2 100644 (file)
--- a/src/engine/Switch.hxx
+++ b/src/engine/Switch.hxx
@@ -111,7 +111,6 @@ namespace YACS
       virtual bool edAddChild(Node *DISOWNnode) throw(Exception);
       int getMaxCase();
       void getReadyTasks(std::vector<Task *>& tasks);
-      void selectRunnableTasks(std::vector<Task *>& tasks);
       std::list<Node *> edGetDirectDescendants() const;
       InputPort *edGetConditionPort() { return &_condition; }
       void writeDot(std::ostream &os) const;

diff --git a/src/engine/Test/ContainerTest.hxx b/src/engine/Test/ContainerTest.hxx
index bfd49a872754c6576d0b4a20394ed7822a178851..d530fb5a3679721d1aa354423f4b6ff143ad3848 100644 (file)
--- a/src/engine/Test/ContainerTest.hxx
+++ b/src/engine/Test/ContainerTest.hxx
@@ -40,6 +40,7 @@ namespace YACS
       void lock() { }
       void unLock() { }
       void clearProperties() { }
+      void addComponentName(const std::string& name) { }
       void shutdown(int level) { }
       void setProperty(const std::string& name,const std::string& value) { }
       std::string getProperty(const std::string& name) const { }
@@ -71,6 +72,7 @@ namespace YACS
       void lock() { }
       void unLock() { }
       void clearProperties() { }
+      void addComponentName(const std::string& name) { }
       void shutdown(int level) { }
       void setProperty(const std::string& name,const std::string& value) { }
       std::string getProperty(const std::string& name) const { }

diff --git a/src/runtime/CppContainer.hxx b/src/runtime/CppContainer.hxx
index 03ee0eb8e5dcf25f38a6985604864ade2490861e..0f338f3eace731020a2018c5fed7e035b45b9621 100644 (file)
--- a/src/runtime/CppContainer.hxx
+++ b/src/runtime/CppContainer.hxx
@@ -127,6 +127,7 @@ namespace YACS
       void setProperty(const std::string& name,const std::string& value) { }
       std::string getProperty(const std::string& name) const { return std::string(); }
       void clearProperties() { }
+      void addComponentName(const std::string& name) { }
       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>(); }
       //

diff --git a/src/runtime/SalomeComponent.cxx b/src/runtime/SalomeComponent.cxx
index 2a53981c55951668ab5b4f6f75a77a0f4c4de3a9..b991f38469f4a97bc81ad4847aae1c6782aa809b 100644 (file)
--- a/src/runtime/SalomeComponent.cxx
+++ b/src/runtime/SalomeComponent.cxx
@@ -133,21 +133,16 @@ std::string SalomeComponent::getFileRepr() const
   return stream.str();
 }
 
-void SalomeComponent::setContainer(Container *cont)
+bool SalomeComponent::setContainer(Container *cont)
 {
-  if (cont == _container) return;
-
-  if(cont)
-    cont->checkCapabilityToDealWith(this);
-
-  if(_container)
-    _container->decrRef();
-  _container=cont;
-  if(_container)
-  {
-    _container->incrRef();
-    ((SalomeContainer*)_container)->addComponentName(_compoName);
-  }
+  if(ComponentInstance::setContainer(cont))
+    {
+      if(_container)
+        _container->addComponentName(_compoName);
+      return true;
+    }
+  else
+    return false;
 }
 
 void SalomeComponent::shutdown(int level)

diff --git a/src/runtime/SalomeComponent.hxx b/src/runtime/SalomeComponent.hxx
index 743b5afcb1748558fb49542d819c0032d9670230..267cd07be32cd6b89c2e1540cf68faaacc954581 100644 (file)
--- a/src/runtime/SalomeComponent.hxx
+++ b/src/runtime/SalomeComponent.hxx
@@ -41,7 +41,7 @@ namespace YACS
       virtual void load(Task *askingNode);
       virtual void unload(Task *askingNode);
       virtual bool isLoaded(Task *askingNode) const;
-      virtual void setContainer(Container *cont);
+      virtual bool setContainer(Container *cont);
       virtual ServiceNode* createNode(const std::string& name);
       virtual ComponentInstance* clone() const;
       virtual std::string getFileRepr() const;

diff --git a/src/runtime/SalomeHPContainer.cxx b/src/runtime/SalomeHPContainer.cxx
index 91c9f9d605389831c5cde87b14fff65c75be5693..cdc45e695d921c73ad08e1d53e9b4ddbb49cff95 100644 (file)
--- a/src/runtime/SalomeHPContainer.cxx
+++ b/src/runtime/SalomeHPContainer.cxx
@@ -70,14 +70,14 @@ void SalomeHPContainer::unLock()
 
 bool SalomeHPContainer::isAlreadyStarted(const Task *askingNode) const
 {
-  const SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
-  return helper.isAlreadyStarted(askingNode);
+  const SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTask(askingNode));
+  return helper->isAlreadyStarted(askingNode);
 }
 
 void SalomeHPContainer::start(const Task *askingNode) throw(Exception)
 {
-  SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
-  SalomeContainerTools::Start(_componentNames,&helper,_sct,_shutdownLevel,this,askingNode);
+  SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTask(askingNode));
+  SalomeContainerTools::Start(_componentNames,helper,_sct,_shutdownLevel,this,askingNode);
 }
 
 void SalomeHPContainer::shutdown(int level)
@@ -87,21 +87,21 @@ void SalomeHPContainer::shutdown(int level)
   _shutdownLevel=999;
   for(std::size_t i=0;_launchModeType.size();i++)
     {
-      SalomeContainerMonoHelper& helper(_launchModeType.at(i));
-      helper.shutdown();
+      SalomeContainerMonoHelper *helper(_launchModeType.at(i));
+      helper->shutdown();
     }
 }
 
 std::string SalomeHPContainer::getPlacementId(const Task *askingNode) const
 {
-  const SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
-  return SalomeContainerTools::GetPlacementId(&helper,this,askingNode);
+  const SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTask(askingNode));
+  return SalomeContainerTools::GetPlacementId(helper,this,askingNode);
 }
 
 std::string SalomeHPContainer::getFullPlacementId(const Task *askingNode) const
 {
-  const SalomeContainerMonoHelper& helper(_launchModeType.getHelperOfTask(askingNode));
-  return SalomeContainerTools::GetFullPlacementId(&helper,this,askingNode);
+  const SalomeContainerMonoHelper *helper(_launchModeType.getHelperOfTask(askingNode));
+  return SalomeContainerTools::GetFullPlacementId(helper,this,askingNode);
 }
 
 /*!
@@ -133,6 +133,11 @@ void SalomeHPContainer::clearProperties()
   _sct.clearProperties();
 }
 
+void SalomeHPContainer::addComponentName(const std::string& name)
+{
+  _componentNames.push_back(name);
+}
+
 std::map<std::string,std::string> SalomeHPContainer::getProperties() const
 {
   return _sct.getProperties();

diff --git a/src/runtime/SalomeHPContainer.hxx b/src/runtime/SalomeHPContainer.hxx
index 28e8f563c1500c474e289be16747ff0702988239..04457e08c22de93f834fa9d1b7548a7629a261e2 100644 (file)
--- a/src/runtime/SalomeHPContainer.hxx
+++ b/src/runtime/SalomeHPContainer.hxx
@@ -65,9 +65,12 @@ namespace YACS
       void setProperty(const std::string& name,const std::string& value);
       std::string getProperty(const std::string& name) const;
       void clearProperties();
+      void addComponentName(const std::string& name);
       std::map<std::string,std::string> getProperties() const;
       std::map<std::string,std::string> getResourceProperties(const std::string& name) const;
       void checkCapabilityToDealWith(const ComponentInstance *inst) const throw(YACS::Exception);
+      //
+      YACS::BASES::Mutex& getLocker() { return _mutex; }
     public:
       static const char KIND[];
     protected:

diff --git a/src/runtime/SalomeHPContainerTools.cxx b/src/runtime/SalomeHPContainerTools.cxx
index 59e45fd5624148471884d615426c6189b3e77236..552aa13681bc81e3320bb9779bc6183ef2bce478 100644 (file)
--- a/src/runtime/SalomeHPContainerTools.cxx
+++ b/src/runtime/SalomeHPContainerTools.cxx
@@ -26,9 +26,14 @@ using namespace YACS::ENGINE;
 
 void SalomeHPContainerVectOfHelper::resize(std::size_t sz)
 {
+  std::size_t oldSize(_launchModeType.size());
+  if(sz==oldSize)
+    return;
   checkNoCurrentWork();
   _whichOccupied.resize(sz); std::fill(_whichOccupied.begin(),_whichOccupied.end(),false);
   _launchModeType.clear(); _launchModeType.resize(sz);
+  for(std::size_t i=oldSize;i<sz;i++)
+      _launchModeType[i]=new SalomeContainerMonoHelper;
   _currentlyWorking.clear();
 }
 
@@ -64,12 +69,12 @@ void SalomeHPContainerVectOfHelper::release(const Task *node)
   _currentlyWorking.erase(it);
 }
 
-const SalomeContainerMonoHelper& SalomeHPContainerVectOfHelper::getHelperOfTask(const Task *node) const
+const SalomeContainerMonoHelper *SalomeHPContainerVectOfHelper::getHelperOfTask(const Task *node) const
 {
   return _launchModeType[locateTask(node)];
 }
 
-SalomeContainerMonoHelper& SalomeHPContainerVectOfHelper::getHelperOfTask(const Task *node)
+SalomeContainerMonoHelper *SalomeHPContainerVectOfHelper::getHelperOfTask(const Task *node)
 {
   return _launchModeType[locateTask(node)];
 }
@@ -89,8 +94,8 @@ void SalomeHPContainerVectOfHelper::checkNoCurrentWork() const
   for(std::map<const Task *,std::size_t >::const_iterator it=_currentlyWorking.begin();it!=_currentlyWorking.end();it++)
     if((*it).first)
       throw Exception("Something wrong a node is still declared to be using the ressource !");
-  for(std::vector<SalomeContainerMonoHelper>::const_iterator it=_launchModeType.begin();it!=_launchModeType.end();it++)
-    if((*it).isAlreadyStarted(0))
+  for(std::vector< YACS::BASES::AutoCppPtr<SalomeContainerMonoHelper> >::const_iterator it=_launchModeType.begin();it!=_launchModeType.end();it++)
+    if((*it)->isAlreadyStarted(0))
       throw Exception("Some of the containers have be started ! Please shutdown them before !");
 }
 

diff --git a/src/runtime/SalomeHPContainerTools.hxx b/src/runtime/SalomeHPContainerTools.hxx
index c052cbe5aaeffedc7e438254344c7d606def8fec..1a1565cb0c3f577a396dd7d8a8da5c199ed3bd66 100644 (file)
--- a/src/runtime/SalomeHPContainerTools.hxx
+++ b/src/runtime/SalomeHPContainerTools.hxx
@@ -23,6 +23,8 @@
 #include "YACSRuntimeSALOMEExport.hxx"
 #include "SalomeContainerHelper.hxx"
 
+#include "AutoRefCnt.hxx"
+
 #include <map>
 #include <vector>
 
@@ -32,7 +34,7 @@ namespace YACS
   {
     class Task;
     class SalomeComponent;
-
+    class SalomeContainerMonoHelper;
     class SalomeHPContainerVectOfHelper
     {
     public:
@@ -41,17 +43,17 @@ namespace YACS
       std::size_t getNumberOfFreePlace() const;
       void allocateFor(const std::vector<const Task *>& nodes);
       void release(const Task *node);
-      const SalomeContainerMonoHelper& at(std::size_t pos) const { checkPosInVec(pos); return _launchModeType[pos]; }
-      SalomeContainerMonoHelper& at(std::size_t pos) { checkPosInVec(pos); return _launchModeType[pos]; }
-      const SalomeContainerMonoHelper& getHelperOfTask(const Task *node) const;
-      SalomeContainerMonoHelper& getHelperOfTask(const Task *node);
+      const SalomeContainerMonoHelper *at(std::size_t pos) const { checkPosInVec(pos); return _launchModeType[pos]; }
+      SalomeContainerMonoHelper *at(std::size_t pos) { checkPosInVec(pos); return _launchModeType[pos]; }
+      const SalomeContainerMonoHelper *getHelperOfTask(const Task *node) const;
+      SalomeContainerMonoHelper *getHelperOfTask(const Task *node);
     private:
       std::size_t locateTask(const Task *node) const;
       void checkNoCurrentWork() const;
       void checkPosInVec(std::size_t pos) const;
     private:
       std::vector<bool> _whichOccupied;
-      std::vector<SalomeContainerMonoHelper> _launchModeType;
+      std::vector< BASES::AutoCppPtr<YACS::ENGINE::SalomeContainerMonoHelper> > _launchModeType;
       std::map<const Task *,std::size_t > _currentlyWorking;
     };
   }