src/GraphBase/DataFlowBase_Graph.cxx

   1 //  SUPERV GraphBase : contains fondamental classes for Services, Input Ports, Output Ports Links and Nodes.
   2 //
   3 //  Copyright (C) 2003  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org
  21 //
  22 //
  23 //
  24 //  File   : DataFlowBase_Graph.cxx
  25 //  Author : Jean Rahuel, CEA
  26 //  Module : SUPERV
  27 //  $Header:
  28
  29 using namespace std;
  30 #include "DataFlowBase_StreamGraph.hxx"
  31
  32 #include "SALOME_LifeCycleCORBA.hxx"
  33
  34 GraphBase::Graph::Graph() :
  35            DataNode() {
  36   cdebug << "GraphBase::Graph::Graph" << endl ;
  37   _GraphNodesSize = 0 ;
  38 }
  39
  40 GraphBase::Graph::Graph( CORBA::ORB_ptr ORB ,
  41                          SALOME_NamingService* ptrNamingService ,
  42                          const char *DataFlowName ,
  43                          const SUPERV::KindOfNode DataFlowkind ,
  44                          int * Graph_prof_debug ,
  45                          ofstream * Graph_fdebug ) :
  46 //                         const char * DebugFileName ) :
  47            DataNode( ORB ,ptrNamingService , DataFlowName , DataFlowkind , Graph_prof_debug , Graph_fdebug ) {
  48   _Orb = CORBA::ORB::_duplicate( ORB ) ;
  49   Set_prof_debug( Graph_prof_debug , Graph_fdebug ) ;
  50   cdebug << "GraphBase::Graph::Graph( " << DataFlowName << ") GraphNodesSize() " << GraphNodesSize() << endl ;
  51   _GraphNodesSize = 0 ;
  52 }
  53
  54 GraphBase::Graph::Graph( CORBA::ORB_ptr ORB ,
  55                          SALOME_NamingService* ptrNamingService ,
  56                          const SALOME_ModuleCatalog::Service& DataFlowService ,
  57                          const char *DataFlowComponentName ,
  58                          const char *DataFlowInterfaceName ,
  59                          const char *DataFlowName ,
  60                          const SUPERV::KindOfNode DataFlowkind ,
  61                          const SUPERV::SDate DataFlowFirstCreation ,
  62                          const SUPERV::SDate DataFlowLastModification ,
  63                          const char * DataFlowEditorRelease ,
  64                          const char * DataFlowAuthor ,
  65                          const char * DataFlowComputer ,
  66                          const char * DataFlowComment ,
  67                          int * Graph_prof_debug ,
  68                          ofstream * Graph_fdebug ) :
  69 //                         const char * DebugFileName ) :
  70            DataNode( ORB , ptrNamingService , DataFlowService ,
  71                      DataFlowName , DataFlowkind ,
  72                      DataFlowFirstCreation , DataFlowLastModification  ,
  73                      DataFlowEditorRelease , DataFlowAuthor , DataFlowComment ) {
  74   _Orb = CORBA::ORB::_duplicate( ORB ) ;
  75   _GraphNodesSize = 0 ;
  76   Set_prof_debug( Graph_prof_debug , Graph_fdebug ) ;
  77   cdebug_in << "GraphBase::Graph::Graph" << endl ;
  78   DataService( ORB , DataFlowService , Graph_prof_debug , Graph_fdebug ) ;
  79   cdebug_out << "GraphBase::Graph::Graph" << endl ;
  80 }
  81
  82 GraphBase::Graph::~Graph() {
  83   cdebug << "GraphBase::Graph::~Graph" << endl ;
  84 }
  85
  86 void GraphBase::Graph::Set_prof_debug( int * Graph_prof_debug ,
  87                                        ofstream * Graph_fdebug ) {
  88   SetDebug( _Orb , Graph_prof_debug , Graph_fdebug ) ;
  89   _Graph_prof_debug = Graph_prof_debug ;
  90   _Graph_fdebug = Graph_fdebug ;
  91 }
  92
  93 GraphBase::SNode * GraphBase::Graph::GetInfo() const {
  94   GraphBase::SNode * Info = new GraphBase::SNode ;
  95   Info->theComponentName = "" ;
  96   Info->theInterfaceName = "" ;
  97   Info->theName = Name() ;
  98   Info->theKind = Kind() ;
  99   if ( IsDataStreamNode() ) {
 100     long Timeout ;
 101     SUPERV::KindOfDataStreamTrace DataStreamTrace ;
 102     double DeltaTime ;
 103     ((GraphBase::StreamGraph * ) this)->StreamParams( Timeout , DataStreamTrace , DeltaTime ) ;
 104     Info->theTimeout = Timeout ;
 105     Info->theDataStreamTrace = DataStreamTrace ;
 106     Info->theDeltaTime = DeltaTime ;
 107   }
 108   Info->theService = *GetService() ;
 109   Info->theFirstCreation = FirstCreation() ;
 110   Info->theLastModification = LastModification() ;
 111   Info->theEditorRelease = EditorRelease() ;
 112   Info->theAuthor = Author() ;
 113   Info->theContainer = "" ;
 114   Info->theComment = Comment() ;
 115   Info->theCoords.theX = GraphBase::ComputingNode::XCoordinate() ;
 116   Info->theCoords.theY = GraphBase::ComputingNode::YCoordinate() ;
 117   return Info ;
 118 }
 119
 120 //----------------------------------------------------------------------
 121 // Function : GetNodes
 122 // Purpose  : get a nodes list
 123 //----------------------------------------------------------------------
 124 GraphBase::ListOfSNodes * GraphBase::Graph::GetNodes() const {
 125   GraphBase::ListOfSNodes * _list_nodes = new GraphBase::ListOfSNodes;
 126
 127   cdebug_in << "GraphBase::Graph::GetNodes" << endl ;
 128   // All the nodes from _InNodes are taken
 129 //  vector< InNode *> Nodes = InNodes() ;
 130
 131   _list_nodes->resize( GraphNodesSize() );
 132
 133   int igoto ;
 134   int ind ;
 135   GraphBase::ComputingNode * aCNode = NULL ;
 136   for ( igoto = 0 ; igoto < 2 ; igoto++ ) {
 137     for ( ind = 0 ; ind < GraphNodesSize() ; ind++ ) {
 138       aCNode = GraphNodes( ind ) ;
 139       if ( ( igoto == 0 && !aCNode->IsGOTONode() ) ||
 140            ( igoto == 1 && aCNode->IsGOTONode() ) ) {
 141         if ( aCNode->IsFactoryNode() ) {
 142           GraphBase::FactoryNode * aFNode = (GraphBase::FactoryNode * ) aCNode ;
 143           (*_list_nodes)[ind].theComponentName = CORBA::string_dup( aFNode->ComponentName());
 144           (*_list_nodes)[ind].theInterfaceName = CORBA::string_dup( aFNode->InterfaceName());
 145         }
 146         else {
 147           (*_list_nodes)[ind].theComponentName = CORBA::string_dup( "" );
 148           (*_list_nodes)[ind].theInterfaceName = CORBA::string_dup( "" );
 149         }
 150         (*_list_nodes)[ind].theName = CORBA::string_dup( aCNode->Name() );
 151         (*_list_nodes)[ind].theKind = aCNode->Kind();
 152         if ( aCNode->IsInLineNode() || aCNode->IsMacroNode() ) {
 153           GraphBase::InLineNode * aINode = (GraphBase::InLineNode * ) aCNode ;
 154           (*_list_nodes)[ind].theListOfFuncName.resize( 1 ) ;
 155           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aINode->PyFuncName() ) ;
 156           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 157           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aINode->PythonFunction() ;
 158         }
 159         if ( aCNode->IsGOTONode() ) {
 160           GraphBase::GOTONode * aGNode = (GraphBase::GOTONode * ) aCNode ;
 161           (*_list_nodes)[ind].theListOfFuncName.resize( 1 ) ;
 162           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aGNode->PyFuncName() ) ;
 163           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 164           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aGNode->PythonFunction() ;
 165         }
 166         if ( aCNode->IsLoopNode() ) {
 167           GraphBase::LoopNode * aLNode = (GraphBase::LoopNode * ) aCNode ;
 168           (*_list_nodes)[ind].theCoupledNode = CORBA::string_dup( aLNode->CoupledNode()->Name() ) ;
 169           (*_list_nodes)[ind].theListOfFuncName.resize( 3 ) ;
 170           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aLNode->PyFuncName() ) ;
 171           (*_list_nodes)[ind].theListOfFuncName[1] = CORBA::string_dup( aLNode->PyMoreName() ) ;
 172           (*_list_nodes)[ind].theListOfFuncName[2] = CORBA::string_dup( aLNode->PyNextName() ) ;
 173           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 3 ) ;
 174           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aLNode->PythonFunction() ;
 175           (*_list_nodes)[ind].theListOfPythonFunctions[1] = aLNode->MorePythonFunction() ;
 176           (*_list_nodes)[ind].theListOfPythonFunctions[2] = aLNode->NextPythonFunction() ;
 177         }
 178         else if ( aCNode->IsSwitchNode() ) {
 179           GraphBase::SwitchNode * aSNode = (GraphBase::SwitchNode * ) aCNode ;
 180           (*_list_nodes)[ind].theCoupledNode = CORBA::string_dup( aSNode->CoupledNode()->Name() ) ;
 181           (*_list_nodes)[ind].theListOfFuncName.resize( 1 ) ;
 182           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aSNode->PyFuncName() ) ;
 183           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 184           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aSNode->PythonFunction() ;
 185         }
 186         else if ( aCNode->IsEndLoopNode() ) {
 187           GraphBase::EndOfLoopNode * aELNode = (GraphBase::EndOfLoopNode * ) aCNode ;
 188           (*_list_nodes)[ind].theCoupledNode = CORBA::string_dup( aELNode->CoupledNode()->Name() ) ;
 189           (*_list_nodes)[ind].theListOfFuncName.resize( 1 ) ;
 190           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aELNode->PyFuncName() ) ;
 191           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 192           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aELNode->PythonFunction() ;
 193         }
 194         else if ( aCNode->IsEndSwitchNode() ) {
 195           GraphBase::EndOfSwitchNode * aESNode = (GraphBase::EndOfSwitchNode * ) aCNode ;
 196           (*_list_nodes)[ind].theCoupledNode = CORBA::string_dup( aESNode->CoupledNode()->Name() ) ;
 197           (*_list_nodes)[ind].theListOfFuncName.resize( 1 ) ;
 198           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aESNode->PyFuncName() ) ;
 199           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 200           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aESNode->PythonFunction() ;
 201         }
 202         else if ( aCNode->IsMacroNode() ) {
 203           GraphBase::Graph * aGraph = (GraphBase::Graph * ) aCNode ;
 204           (*_list_nodes)[ind].theCoupledNode = CORBA::string_dup( aGraph->CoupledNode()->Name() ) ;
 205           (*_list_nodes)[ind].theListOfFuncName.resize( 1 ) ;
 206           (*_list_nodes)[ind].theListOfFuncName[0] = CORBA::string_dup( aGraph->PyFuncName() ) ;
 207           (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 208           (*_list_nodes)[ind].theListOfPythonFunctions[0] = aGraph->PythonFunction() ;
 209         }
 210         else {
 211           (*_list_nodes)[ind].theCoupledNode = CORBA::string_dup( "" ) ;
 212         }
 213 //        (*_list_nodes)[ind].theDataStreamInArgsNumber = aCNode->DataStreamInPortsNumber() ;
 214 //        (*_list_nodes)[ind].theDataStreamOutArgsNumber = aCNode->DataStreamOutPortsNumber() ;
 215
 216         (*_list_nodes)[ind].theListOfInDataStreams.resize( aCNode->DataStreamInPortsNumber() ) ;
 217         cdebug << "GraphBase::Graph::GetNodes " << aCNode->Name() << " " << aCNode->DataStreamInPortsNumber() << " DataStreamInPortsNumber" << endl ;
 218         int iostream ;
 219         int streamind = 0 ;
 220         for ( iostream = 0 ; iostream < aCNode->GetNodeInPortsSize() ; iostream++ ) {
 221           const GraphBase::InPort * anInPort ;
 222           anInPort = aCNode->GetNodeInPort( iostream ) ;
 223           if ( anInPort->IsDataStream() ) {
 224             cdebug << "GraphBase::Graph::GetNodes In" << iostream << " " << aCNode->Name() << " " << anInPort->NodeName() << " " << anInPort->PortName()
 225                    << endl ;
 226             (*_list_nodes)[ind].theListOfInDataStreams[streamind].theDataStreamParameter.Parametertype = StringToDataStreamType( anInPort->PortType() ) ;
 227             (*_list_nodes)[ind].theListOfInDataStreams[streamind].theDataStreamParameter.Parametername = CORBA::string_dup( anInPort->PortName() ) ;
 228             (*_list_nodes)[ind].theListOfInDataStreams[streamind].theDataStreamParameter.Parameterdependency = anInPort->Dependency() ;
 229             SUPERV::KindOfSchema        aKindOfSchema ;
 230             SUPERV::KindOfInterpolation aKindOfInterpolation ;
 231             SUPERV::KindOfExtrapolation aKindOfExtrapolation ;
 232             ((GraphBase::InDataStreamPort * ) anInPort)->Params( aKindOfSchema , aKindOfInterpolation , aKindOfExtrapolation ) ;
 233             (*_list_nodes)[ind].theListOfInDataStreams[streamind].theKindOfSchema = aKindOfSchema ;
 234             (*_list_nodes)[ind].theListOfInDataStreams[streamind].theKindOfInterpolation = aKindOfInterpolation ;
 235             (*_list_nodes)[ind].theListOfInDataStreams[streamind].theKindOfExtrapolation = aKindOfExtrapolation ;
 236             cdebug << "GraphBase::Graph::GetNodes " << aCNode->Name() << " " << anInPort->NodeName() << " " << anInPort->PortName() << " "
 237                    <<  anInPort->Dependency() << " " << aKindOfSchema << " " << aKindOfInterpolation << " " << aKindOfExtrapolation << " list_nodes "
 238                    << (*_list_nodes)[ind].theListOfInDataStreams[streamind].theDataStreamParameter.Parametername << " "
 239                    << (*_list_nodes)[ind].theListOfInDataStreams[streamind].theDataStreamParameter.Parametertype << " "
 240                    << (*_list_nodes)[ind].theListOfInDataStreams[streamind].theDataStreamParameter.Parameterdependency << " "
 241                    << (*_list_nodes)[ind].theListOfInDataStreams[streamind].theKindOfSchema << " "
 242                    << (*_list_nodes)[ind].theListOfInDataStreams[streamind].theKindOfInterpolation << " "
 243                    << (*_list_nodes)[ind].theListOfInDataStreams[streamind].theKindOfExtrapolation << " " << endl ;
 244             streamind += 1 ;
 245           }
 246           else {
 247             cdebug << "GraphBase::Graph::GetNodes " << aCNode->Name() << " " << anInPort->NodeName() << " " << anInPort->PortName() << " "
 248                    << anInPort->Kind() << " IsDataStream " << anInPort->IsDataStream() << endl ;
 249           }
 250         }
 251
 252         (*_list_nodes)[ind].theListOfOutDataStreams.resize( aCNode->DataStreamOutPortsNumber() ) ;
 253         cdebug << "GraphBase::Graph::GetNodes " << aCNode->Name() << " " << aCNode->DataStreamOutPortsNumber() << " DataStreamOutPortsNumber" << endl ;
 254         streamind = 0 ;
 255         for ( iostream = 0 ; iostream < aCNode->GetNodeOutPortsSize() ; iostream++ ) {
 256           const GraphBase::OutPort * anOutPort ;
 257           anOutPort = aCNode->GetNodeOutPort( iostream ) ;
 258           if ( anOutPort->IsDataStream() ) {
 259             cdebug << "GraphBase::Graph::GetNodes Out" << iostream << " " << aCNode->Name() << " " << anOutPort->NodeName() << " " << anOutPort->PortName() << " "
 260                    << endl ;
 261             (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theDataStreamParameter.Parametertype = StringToDataStreamType( anOutPort->PortType() ) ;
 262             (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theDataStreamParameter.Parametername = CORBA::string_dup( anOutPort->PortName() ) ;
 263             (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theDataStreamParameter.Parameterdependency = anOutPort->Dependency() ;
 264             long aNumberOfValues = ((GraphBase::OutDataStreamPort * ) anOutPort)->NumberOfValues() ;
 265             (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theNumberOfValues = aNumberOfValues ;
 266             cdebug << "GraphBase::Graph::GetNodes " << aCNode->Name() << " " << anOutPort->NodeName() << " " << anOutPort->PortName() << " "
 267                    <<  anOutPort->Dependency() << " " << aNumberOfValues << " list_nodes "
 268                    << (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theDataStreamParameter.Parametername << " "
 269                    << (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theDataStreamParameter.Parametertype << " "
 270                    << (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theDataStreamParameter.Parameterdependency << " "
 271                    << (*_list_nodes)[ind].theListOfOutDataStreams[streamind].theNumberOfValues << endl ;
 272             streamind += 1 ;
 273           }
 274           else {
 275             cdebug << "GraphBase::Graph::GetNodes " << aCNode->Name() << " " << anOutPort->NodeName() << " " << anOutPort->PortName() << " "
 276                    << anOutPort->Kind() << " IsDataStream " << anOutPort->IsDataStream() << endl ;
 277           }
 278         }
 279
 280         (*_list_nodes)[ind].theService = *aCNode->GetService();
 281         cdebug << "GraphBase::Graph::GetNodes theService " << &(*_list_nodes)[ind].theService.ServiceName << endl ;
 282         unsigned int i ;
 283         for ( i = 0 ; i < (*_list_nodes)[ind].theService.ServiceinParameter.length() ; i++ ) {
 284           cdebug << "     In" << i << " " << &(*_list_nodes)[ind].theService.ServiceinParameter[i].Parametername
 285                  << " " << (*_list_nodes)[ind].theService.ServiceinParameter[i].Parametername
 286                  << " " << &(*_list_nodes)[ind].theService.ServiceinParameter[i].Parametertype
 287                  << " " << (*_list_nodes)[ind].theService.ServiceinParameter[i].Parametertype << endl ;
 288         }
 289         for ( i = 0 ; i < (*_list_nodes)[ind].theService.ServiceoutParameter.length() ; i++ ) {
 290           cdebug << "     Out" << i << " " << &(*_list_nodes)[ind].theService.ServiceoutParameter[i].Parametername
 291                  << " " << (*_list_nodes)[ind].theService.ServiceoutParameter[i].Parametername
 292                  << " " << &(*_list_nodes)[ind].theService.ServiceoutParameter[i].Parametertype
 293                  << " " << (*_list_nodes)[ind].theService.ServiceoutParameter[i].Parametertype << endl ;
 294         }
 295         for ( i = 0 ; i < (*_list_nodes)[ind].theService.ServiceinDataStreamParameter.length() ; i++ ) {
 296           cdebug << "     InDataStream" << i << " " << &(*_list_nodes)[ind].theService.ServiceinDataStreamParameter[i].Parametername
 297                  << " " << (*_list_nodes)[ind].theService.ServiceinDataStreamParameter[i].Parametername
 298                  << " " << &(*_list_nodes)[ind].theService.ServiceinDataStreamParameter[i].Parametertype
 299                  << " " << (*_list_nodes)[ind].theService.ServiceinDataStreamParameter[i].Parametertype << endl ;
 300         }
 301         for ( i = 0 ; i < (*_list_nodes)[ind].theService.ServiceoutDataStreamParameter.length() ; i++ ) {
 302           cdebug << "     OutDataStream" << i << " " << &(*_list_nodes)[ind].theService.ServiceoutDataStreamParameter[i].Parametername
 303                  << " " << (*_list_nodes)[ind].theService.ServiceoutDataStreamParameter[i].Parametername
 304                  << " " << &(*_list_nodes)[ind].theService.ServiceoutDataStreamParameter[i].Parametertype
 305                  << " " << (*_list_nodes)[ind].theService.ServiceoutDataStreamParameter[i].Parametertype << endl ;
 306         }
 307         if ( aCNode->IsOneOfInLineNodes() ) {
 308           GraphBase::InLineNode * aINode = (GraphBase::InLineNode * ) aCNode ;
 309           GraphBase::LoopNode * aLNode = NULL ;
 310           if ( aCNode->IsLoopNode() ) {
 311             aLNode = (GraphBase::LoopNode * ) aCNode ;
 312             (*_list_nodes)[ind].theListOfPythonFunctions.resize( 3 ) ;
 313             (*_list_nodes)[ind].theListOfPythonFunctions[ 0 ] = aINode->PythonFunction() ;
 314             (*_list_nodes)[ind].theListOfPythonFunctions[ 1 ] = aLNode->MorePythonFunction() ;
 315             (*_list_nodes)[ind].theListOfPythonFunctions[ 2 ] = aLNode->NextPythonFunction() ;
 316           }
 317           else if ( aCNode->IsInLineNode() || aCNode->IsGOTONode() ||
 318                     aCNode->IsSwitchNode() || aCNode->IsEndSwitchNode() ) {
 319             (*_list_nodes)[ind].theListOfPythonFunctions.resize( 1 ) ;
 320             (*_list_nodes)[ind].theListOfPythonFunctions[ 0 ] = aINode->PythonFunction() ;
 321           }
 322         }
 323         (*_list_nodes)[ind].theFirstCreation = aCNode->FirstCreation();
 324         (*_list_nodes)[ind].theLastModification = aCNode->LastModification();
 325         (*_list_nodes)[ind].theEditorRelease = CORBA::string_dup( aCNode->EditorRelease());
 326         (*_list_nodes)[ind].theAuthor = CORBA::string_dup( aCNode->Author());
 327         if ( aCNode->IsFactoryNode() ) {
 328           GraphBase::FactoryNode * aFNode = (GraphBase::FactoryNode * ) aCNode ;
 329           (*_list_nodes)[ind].theContainer = CORBA::string_dup( aFNode->Computer());
 330         }
 331         else {
 332           (*_list_nodes)[ind].theContainer = CORBA::string_dup( "" );
 333         }
 334         (*_list_nodes)[ind].theComment = CORBA::string_dup( aCNode->Comment());
 335         (*_list_nodes)[ind].theCoords.theX = aCNode->XCoordinate();
 336         (*_list_nodes)[ind].theCoords.theY = aCNode->YCoordinate();
 337 #if 0
 338         int nports = 0 ;
 339         int i ;
 340         for ( i = 0 ; i < aCNode->GetNodeInPortsSize() ; i++ ) {
 341           const GraphBase::InPort * anInPort = aCNode->GetNodeInPort( i ) ;
 342           if ( anInPort->IsBus() ) {
 343             nports += 1 ;
 344             (*_list_nodes)[ind].theListOfParameters.resize( nports ) ;
 345             (*_list_nodes)[ind].theListOfParameters[ nports-1 ].theInParameter.Parametertype = CORBA::string_dup( anInPort->PortType() ) ;
 346             (*_list_nodes)[ind].theListOfParameters[ nports-1 ].theInParameter.Parametername = CORBA::string_dup( anInPort->PortName() ) ;
 347             (*_list_nodes)[ind].theListOfParameters[ nports-1 ].theOutParameter.Parametertype = CORBA::string_dup( aCNode->GetNodeOutPort( anInPort->PortIndex() )->PortType() ) ;
 348             (*_list_nodes)[ind].theListOfParameters[ nports-1 ].theOutParameter.Parametername = CORBA::string_dup( aCNode->GetNodeOutPort( anInPort->PortIndex() )->PortName() ) ;
 349           }
 350         }
 351 #endif
 352       }
 353     }
 354   }
 355   cdebug_out << "GraphBase::Graph::GetNodes" << endl ;
 356   return _list_nodes ;
 357 }
 358
 359
 360 //----------------------------------------------------------------------
 361 // Function : GetLinks
 362 // Purpose  : get a links list
 363 //----------------------------------------------------------------------
 364 GraphBase::ListOfSLinks * GraphBase::Graph::GetLinks(bool AllLinks ) const {
 365   GraphBase::ListOfSLinks * _list_links = new GraphBase::ListOfSLinks;
 366
 367 // All the links from _LinksList are taken
 368 //  vector< InNode *> Nodes = InNodes() ;
 369
 370   int ind = 0 ;
 371   int k ;
 372   for ( k = 0 ; k < GraphNodesSize() ; k++ ) {
 373     GraphBase::ComputingNode * fromNode = GraphNodes( k ) ;
 374     int i ;
 375     for ( i = 0 ; i < fromNode->GetNodeOutPortsSize() ; i++ ) {
 376       const GraphBase::OutPort* fromPort = fromNode->GetNodeOutPort( i ) ;
 377       int j ;
 378       for ( j = 0 ; j < fromPort->InPortsSize() ; j++ ) {
 379         const GraphBase::InPort* toPort = fromPort->InPorts( j ) ;
 380         if ( toPort->IsPortConnected() ) {
 381 // Desole pour ce cast mais avec les maps difficile de faire const ...
 382           const GraphBase::ComputingNode * toNode = ((GraphBase::Graph * ) this)->GetGraphNode( toPort->NodeName() ) ;
 383           if ( !(fromPort->IsLoop() && toPort->IsLoop() ) || AllLinks ) {
 384             cdebug << "GraphBase::Graph::GetLinks " << fromNode->Name() << " ("
 385                    << fromPort->PortName() << " ) IsPortConnected" << fromPort->IsPortConnected()
 386                    << " --> " << toNode->Name() << "( " << toPort->PortName() << " ) "
 387                    << " " << fromPort->InPortsSize() << " ports" << endl ;
 388             _list_links->resize( ind+1 );
 389             (*_list_links)[ind].FromNodeName = CORBA::string_dup( fromNode->Name() );
 390             (*_list_links)[ind].FromServiceParameterName = fromPort->GetServicesParameter().Parametername;
 391             (*_list_links)[ind].ToNodeName = CORBA::string_dup( toPort->NodeName() );
 392             (*_list_links)[ind].ToServiceParameterName = toPort->GetServicesParameter().Parametername;
 393             (*_list_links)[ind].aLinkValue = *fromPort->Value() ;
 394             if ( toPort->IsEndSwitch() ) {
 395               (*_list_links)[ind++].aListOfCoords = *(fromPort->Coords()) ;
 396             }
 397             else {
 398               (*_list_links)[ind++].aListOfCoords = *(toPort->Coords()) ;
 399             }
 400           }
 401         }
 402         else {
 403           cdebug << "GraphBase::Graph::GetLinks " << fromNode->Name() << " "
 404                  << fromPort->PortName() << " ) " << fromPort->PortStatus()
 405                  << " --> " << toPort->NodeName() << "( " << toPort->PortName() << " ) "
 406                  << " " << toPort->PortStatus() << " " << fromPort->InPortsSize() << " ports ignored" << endl ;
 407         }
 408       }
 409     }
 410   }
 411
 412   return _list_links;
 413 }
 414
 415 GraphBase::ListOfSGraphs * GraphBase::Graph::GetGraphs() const {
 416   GraphBase::ListOfSGraphs * _list_graphs = new GraphBase::ListOfSGraphs;
 417
 418   return _list_graphs;
 419 }
 420
 421 GraphBase::SLink * GraphBase::Graph::GetLink( GraphBase::ComputingNode * aNode ,
 422                                               GraphBase::InPort* toPort ) {
 423   GraphBase::SLink * _link =  new GraphBase::SLink ;
 424   GraphBase::OutPort* fromPort = toPort->GetOutPort() ;
 425   _link->FromNodeName = CORBA::string_dup( fromPort->NodeName() );
 426   _link->FromServiceParameterName = fromPort->GetServicesParameter().Parametername;
 427   _link->ToNodeName = CORBA::string_dup( toPort->NodeName() );
 428   _link->ToServiceParameterName = toPort->GetServicesParameter().Parametername;
 429   CORBA::Any aSPValue = *fromPort->Value() ;
 430   _link->aLinkValue = aSPValue;
 431   _link->aListOfCoords = *(toPort->Coords()) ;
 432   return _link;
 433 }
 434 //----------------------------------------------------------------------
 435 // Function : GetDatas
 436 // Purpose  : get the datas list
 437 //----------------------------------------------------------------------
 438 GraphBase::ListOfSLinks * GraphBase::Graph::GetDatas() const {
 439   GraphBase::ListOfSLinks * _list_datalinks = new GraphBase::ListOfSLinks;
 440
 441   int ind = 0 ;
 442   const GraphBase::DataNode * aDataNode = this ;
 443   int i ;
 444   for ( i = 0 ; i < aDataNode->GetNodeInDataNodePortsSize() ; i++ ) {
 445     const GraphBase::OutPort* fromDataPort = aDataNode->GetNodeInDataNodePort( i ) ;
 446     if ( GraphMacroLevel() == 0 ) {
 447       if ( fromDataPort->IsDataConnected() ) {
 448         int j ;
 449 //We may have SharedData as input of a DataFlow : same input for one or several
 450 // input ports. Input(s) of a DataFlow match one or several output-virtual-dataport
 451         for ( j = 0 ; j < fromDataPort->InPortsSize() ; j++ ) {
 452           _list_datalinks->resize( ind+1 );
 453           (*_list_datalinks)[ind].FromNodeName = CORBA::string_dup( aDataNode->Name() );
 454           (*_list_datalinks)[ind].FromServiceParameterName = fromDataPort->GetServicesParameter().Parametername;
 455           const GraphBase::InPort* toPort = fromDataPort->InPorts( j ) ;
 456           (*_list_datalinks)[ind].ToNodeName = CORBA::string_dup( toPort->NodeName() );
 457           (*_list_datalinks)[ind].ToServiceParameterName = toPort->GetServicesParameter().Parametername;
 458           CORBA::Any aSPValue = *fromDataPort->Value() ;
 459           (*_list_datalinks)[ind].aLinkValue = aSPValue;
 460           (*_list_datalinks)[ind++].aListOfCoords = *(toPort->Coords()) ;
 461         }
 462       }
 463     }
 464   }
 465
 466 #if 0
 467 // Output(s) of a DataFlow match only one input-virtual-dataport
 468   for ( i = 0 ; i < aDataNode->GetNodeOutDataNodePortsSize() ; i++ ) {
 469     GraphBase::InPort* toDataPort = aDataNode->GetChangeNodeOutDataNodePort( i ) ;
 470     const GraphBase::OutPort* fromPort = toDataPort->GetLink() ;
 471     if ( fromPort->IsDataConnected() ) {
 472       _list_datalinks->length( ind+1 );
 473       _list_datalinks[ind].FromNodeName = CORBA::string_dup( fromPort->NodeName() );
 474       _list_datalinks[ind].FromServiceParameterName = fromPort->GetServicesParameter().Parametername;
 475       _list_datalinks[ind].ToNodeName = CORBA::string_dup( aDataNode->Name() );
 476       _list_datalinks[ind].ToServiceParameterName = toDataPort->GetServicesParameter().Parametername;
 477 //      SALOME_SuperVisionBase::ServicesParameterValue aSPValue;
 478           CORBA::Any aSPValue = *fromPort->Value() ;
 479 //      aSPValue.Value = CORBA::string_dup( fromPort->Value() );
 480 //      aSPValue.Kind = fromPort->Kind();
 481       _list_datalinks[ind].aLinkValue = aSPValue;
 482       _list_datalinks[ind++].aListOfCoords = toDataPort->Coords() ;
 483     }
 484   }
 485 #endif
 486
 487   return _list_datalinks ;
 488 }
 489
 490 bool GraphBase::Graph::AddNode( GraphBase::ComputingNode * aNode ) {
 491   cdebug_in << "GraphBase::Graph::AddNode "  << (void *) aNode << " " << aNode->Name() << " " << aNode->ServiceName() << endl;
 492   bool RetVal = false ;
 493   int index = GetGraphNodeIndex( aNode->Name() ) ;
 494   if ( index < 0 ) {
 495     cdebug << "GraphBase::Graph::AddNode " << _GraphNodesSize << " nodes + 1" << endl ;
 496     _GraphNodes.resize( _GraphNodesSize+1 ) ;
 497     _GraphNodes[ _GraphNodesSize ] = aNode ;
 498     SetGraphNodeIndex( aNode->Name() , _GraphNodesSize ) ;
 499     _GraphNodesSize += 1 ;
 500     if ( SetServiceOfMap( (GraphBase::Service * ) aNode ) ) {
 501       cdebug << "Graph::AddNode SetServiceOfMap " << aNode->ServiceName() << " in MapOfServices" << endl ;
 502     }
 503     else {
 504       cdebug << "Graph::AddNode SetServiceOfMap " << aNode->ServiceName()
 505              << " was already in MapOfServices" << endl ;
 506     }
 507
 508     RetVal = true ;
 509     int i ;
 510     cdebug << "GraphBase::Graph::AddNode " << _GraphNodesSize << " Known nodes :" << endl ;
 511     for ( i = 0 ; i < _GraphNodesSize ; i++ ) {
 512       const GraphBase::ComputingNode * aKnownNode = GetGraphNode( i ) ;
 513       if ( aKnownNode ) {
 514         cdebug << i << ". " << aKnownNode->Name() << " " << _MapOfGraphNodes[ GetGraphNode( i )->Name() ] - 1 << endl ;
 515       }
 516       else {
 517         cdebug << i << ". ERROR" << endl ;
 518       }
 519     }
 520     aNode->GraphOfNode( this ) ;
 521   }
 522   cdebug_out << "GraphBase::Graph::AddNode " << _GraphNodesSize << " Nodes. "
 523              << aNode->ServiceName() << endl;
 524   return RetVal ;
 525 }
 526
 527 bool GraphBase::Graph::ReNameNode( const char* OldNodeName ,
 528                                    const char* NewNodeName ) {
 529   cdebug_in << "GraphBase::Graph::ReNameNode (" << OldNodeName << " , " << NewNodeName << ") "
 530             << endl;
 531   int i ;
 532   bool RetVal = false ;
 533 //#if 0
 534   GraphBase::ComputingNode * anOldNode = GetChangeGraphNode( OldNodeName ) ;
 535   for ( i = 0 ; i < anOldNode->LinkedNodesSize() ; i++ ) {
 536     cdebug << "LinkedNode " << i << " " << anOldNode->LinkedNodes( i )->Name() << endl ;
 537   }
 538 //#endif
 539   if ( !strcmp( OldNodeName , NewNodeName ) ) {
 540     RetVal = true ;
 541   }
 542   else if ( strcmp( Name() , OldNodeName ) ) {
 543     int index = GetGraphNodeIndex( OldNodeName ) ;
 544     int newindex = GetGraphNodeIndex( NewNodeName ) ;
 545     if ( index >= 0 && index < _GraphNodesSize &&
 546          ( newindex < 0 || newindex > _GraphNodesSize ) ) {
 547       _GraphNodes[ index ]->Name( NewNodeName ) ;
 548       _MapOfGraphNodes.erase( OldNodeName ) ;
 549       SetGraphNodeIndex( NewNodeName , index ) ;
 550
 551       GraphBase::ComputingNode * aNode = GetChangeGraphNode( index ) ;
 552 // Update 'ToNode's Map from 'aNode'
 553       cdebug << "Graph::ReNameNode " << aNode->Name() << " LinkedNodesSize "
 554              << aNode->LinkedNodesSize() << endl ;
 555       for ( i = 0 ; i < aNode->LinkedNodesSize() ; i++ ) {
 556         GraphBase::StreamNode * ToNode = aNode->LinkedNodes( i ) ;
 557         ToNode->ReNameLinkedFromNode( OldNodeName , NewNodeName ) ;
 558       }
 559 // Update 'FomNode's Map to 'aNode'
 560 // Inports 'anInPort' of 'aNode'
 561       for ( i = aNode->GetNodeInPortsSize()-1 ; i >= 0 ; i-- ) {
 562         GraphBase::InPort * anInPort = aNode->GetChangeNodeInPort( i ) ;
 563 // OutPort 'anOutPort' linked to 'anInPort'
 564         GraphBase::OutPort * anOutPort = anInPort->GetOutPort() ;
 565         cdebug << i << ". " << aNode->Name() << " " << "GraphBase::Graph::ReNameNode of LinkedNode : from " ;
 566         if ( anOutPort ) {
 567           cdebug << anOutPort->NodeName() ;
 568         }
 569         else {
 570           cdebug << "without link" ;
 571         }
 572         cdebug << " to " << i << ". " << anInPort->PortName() << " of " << NewNodeName ;
 573         if ( !anInPort->IsNotConnected() ) {
 574           if ( anOutPort->IsDataConnected() ) {
 575             cdebug << " fromDataConnected " << anOutPort->NodeName() << endl ;
 576           }
 577           else {
 578 // Node 'FromNode' of 'anOutPort'
 579             GraphBase::ComputingNode * FromNode ;
 580             if ( strcmp( anOutPort->NodeName() , Name() ) ) {
 581               FromNode = GetChangeGraphNode( anOutPort->NodeName() ) ;
 582             }
 583             else {
 584               FromNode = this ;
 585             }
 586 // Rename in _MapOfLinkedFromNodes of 'FromNode'
 587             cdebug << " fromConnected " << anOutPort->NodeName() << endl ;
 588             if ( anInPort->IsDataStream() ) {
 589               FromNode->ReNameStreamLinkedNode( OldNodeName , NewNodeName ) ;
 590             }
 591             else {
 592               FromNode->ReNameLinkedNode( OldNodeName , NewNodeName ) ;
 593             }
 594           }
 595           char* OldNodePortName = new char[ strlen( OldNodeName ) +
 596                                             strlen( aNode->GetChangeNodeInPort( i )->PortName() ) + 3 ] ;
 597           char* NewNodePortName = new char[ strlen( NewNodeName ) +
 598                                             strlen( aNode->GetChangeNodeInPort( i )->PortName() ) + 3 ] ;
 599           strcpy( OldNodePortName , OldNodeName ) ;
 600 //          strcat( OldNodePortName , "\\" ) ;
 601           strcat( OldNodePortName , "__" ) ;
 602           strcat( OldNodePortName , aNode->GetChangeNodeInPort( i )->PortName() ) ;
 603           strcpy( NewNodePortName , NewNodeName ) ;
 604 //          strcat( NewNodePortName , "\\" ) ;
 605           strcat( NewNodePortName , "__" ) ;
 606           strcat( NewNodePortName , aNode->GetChangeNodeInPort( i )->PortName() ) ;
 607           RetVal = anOutPort->ReNameInPort( OldNodePortName , NewNodePortName ) ;
 608           delete [] OldNodePortName ;
 609           delete [] NewNodePortName ;
 610           if ( !RetVal )
 611             break ;
 612         }
 613         else {
 614           cdebug << " not connected" << endl ;
 615           RetVal = true ;
 616         }
 617       }
 618       RetVal = true ;
 619     }
 620     else {
 621       cdebug << "ERROR Node not found" << endl ;
 622     }
 623   }
 624   else {
 625     RetVal = Name( NewNodeName ) ;
 626   }
 627
 628   cdebug_out << "GraphBase::Graph::ReNameNode RetVal " << RetVal << endl;
 629   return RetVal ;
 630 }
 631
 632 bool GraphBase::Graph::RemoveNode( const char* aNodeName ) {
 633   cdebug_in << "Graph::RemoveNode (" << aNodeName << ") " << endl;
 634   int i ;
 635   bool RetVal = false ;
 636   int index = GetGraphNodeIndex( aNodeName ) ;
 637   GraphBase::ComputingNode * aNode = GetChangeGraphNode( index ) ;
 638   if ( aNode ) {
 639     cdebug << "Graph::RemoveNode " << aNode->Name() << " : " << aNode->GetNodeInPortsSize()
 640            << " InPorts " << aNode->GetNodeOutPortsSize() << " OutPorts "
 641            << aNode->LinkedNodesSize() << " LinkedNodes " << aNode->LinkedFromNodesSize()
 642            << " LinkedFromNodes IsEndSwitchNode " << aNode->IsEndSwitchNode() << endl ;
 643     for ( i = 0 ; i < aNode->LinkedNodesSize() ; i++ ) {
 644       cdebug << "         LinkedNode" << i << ". " << aNode->LinkedNodes( i ) << " "
 645              << aNode->LinkedNodes( i )->Name() << endl ;
 646     }
 647     if ( !aNode->IsEndLoopNode() ) { // The LoopNode is already deleted
 648       for ( i = 0 ; i < aNode->LinkedFromNodesSize() ; i++ ) {
 649         cdebug << "         LinkedFromNode" << i << ". " << aNode->LinkedFromNodes( i ) << " "
 650                << aNode->LinkedFromNodes( i )->Name() << endl ;
 651       }
 652     }
 653     if ( !aNode->IsEndSwitchNode() ) {
 654       if ( aNode->GetNodeInPortsSize() ) {
 655         for ( i = aNode->GetNodeInPortsSize()-1 ; i >= 0 ; i-- ) {
 656           GraphBase::InPort * anInPort = aNode->GetChangeNodeInPort( i ) ;
 657           cdebug << "InPort" << i << ". " << aNodeName << "( " << anInPort->PortName() << ") "
 658                  << anInPort->PortStatus() << " <-- " ;
 659           GraphBase::OutPort * anOutPort = anInPort->GetOutPort() ;
 660           if ( anOutPort && !( aNode->IsEndLoopNode() && anInPort->IsLoop() ) ) {
 661             cdebug << anOutPort->NodeName() << "( " << anOutPort->PortName() << ") " << anOutPort->PortStatus() ;
 662           }
 663           cdebug << endl ;
 664           if ( !anInPort->IsNotConnected() ) {
 665             RetVal = true ;
 666             if ( anOutPort->IsDataConnected() || anOutPort->IsExternConnected() ) {
 667               cdebug << "     Data/Extern" << endl ;
 668             }
 669             else {
 670               GraphBase::ComputingNode * FromNode = GetChangeGraphNode( anOutPort->NodeName() ) ;
 671               cdebug << "FromNode " << FromNode->Name() << " LinkedNodesSize "
 672                      << FromNode->LinkedNodesSize() << " and " << aNode->Name()
 673                      << " LinkedFromNodesSize " << aNode->LinkedFromNodesSize() << endl ;
 674               // asv : 04.11.04 : IsGOTO -> IsOneOfGOTO, I believe that it fixes the bug 7120.
 675 // JR 05.01.05 : IsOneOfGOTO is not ok : I shall check the bug 7120 with IsGOTONode
 676 //            if ( !FromNode->IsOneOfGOTONodes() ) {
 677 //            if ( !FromNode->IsGOTONode() ) {
 678               if ( !FromNode->IsGOTONode() &&
 679                    !( FromNode->IsEndLoopNode() && anInPort->IsLoop() ) ) {
 680                 if ( anInPort->IsDataStream() ) {
 681                   RetVal = FromNode->RemoveStreamLinkedNode( aNode ) ;
 682                 }
 683                 else {
 684                   RetVal = FromNode->RemoveLinkedNode( aNode ) ;
 685                 }
 686                 if ( !RetVal ) {
 687                   cdebug << "anOutPort->RemoveLinkedNode Error RetVal " << RetVal << endl ;
 688                   break ;
 689                 }
 690               }
 691             }
 692             RetVal = anOutPort->RemoveInPort( anInPort ) ;
 693             if ( !RetVal ) {
 694               cdebug << "anOutPort->RemoveInPort( anInPort ) Error RetVal " << RetVal << endl ;
 695               break ;
 696             }
 697           }
 698           else {
 699             RetVal = true ;
 700           }
 701         }
 702       }
 703       else {
 704         RetVal = true ;
 705       }
 706     }
 707     else {
 708 // Special case of EndSwitchNodes : each Input port must be multi-connected.
 709 // There is one link for each branch of the switch
 710 // But in GraphBase::InPort there is only one field GraphBase::OutPort *
 711 // At execution time there is no problem because only one branch of the switch
 712 // may be executed and the Executor set the right OutPort in the field
 713 // GraphBase::OutPort * of each InPort of the EndSwitchNode
 714 // But here we must remove that node EndSwitch from the LinkedNodes field of
 715 // terminal nodes of all branches.
 716 // And also in the OutPorts of that terminal nodes of branches we must remove
 717 // references to InPorts of the EndSwitchNode.
 718
 719 // Explore LinkedFromnodes of the EndSwitchNode :
 720       for ( i = aNode->LinkedFromNodesSize() - 1 ; i >= 0  ; i-- ) {
 721         GraphBase::ComputingNode * aLinkedFromNode = (GraphBase::ComputingNode * ) aNode->LinkedFromNodes( i ) ;
 722         cdebug << aLinkedFromNode->Name() << " linked to " << aNode->Name() << endl ;
 723         int j ;
 724         for ( j = aLinkedFromNode->GetNodeOutPortsSize() - 1 ; j >= 0 ; j-- ) {
 725           GraphBase::OutPort * anOutPort = aLinkedFromNode->GetChangeNodeOutPort( j ) ;
 726           cdebug << "OutPort" << j << ". Remove " << anOutPort->InPortsSize()
 727                  << " InPortsof OutPort : " << anOutPort->NodeName() << "( "
 728                  << anOutPort->PortName() << ") "
 729                  << anOutPort->PortStatus() << " :" << endl ;
 730           int k ;
 731           for ( k = anOutPort->InPortsSize() - 1 ; k >= 0  ; k-- ) {
 732             GraphBase::InPort * anInPort = anOutPort->ChangeInPorts( k ) ;
 733             if ( strcmp( anInPort->NodeName() , aNode->Name() ) == NULL ) {
 734 // InPort of the EndSwitchNode
 735               cdebug << "       to InPort" << j << ". " << anInPort->NodeName() << "( "
 736                      << anInPort->PortName() << ") "
 737                      << anInPort->PortStatus() << endl ;
 738               anInPort->RemoveOutPort() ;
 739               if ( anOutPort->IsDataStream() ) {
 740                 aLinkedFromNode->RemoveStreamLinkedNode( aNode ) ;
 741               }
 742               else {
 743 // false ==> No error for aNode->LinkedFromNode()
 744                 RetVal = aLinkedFromNode->RemoveLinkedNode( aNode , false ) ;
 745                 if ( !RetVal ) {
 746                   cdebug << "aLinkedFromNode->RemoveLinkedNode Error RetVal " << RetVal << endl ;
 747                   break ;
 748                 }
 749               }
 750 // Remove the InPort of the EndSwitchNode from that OutPort
 751               RetVal = anOutPort->RemoveInPort( anInPort ) ;
 752               if ( !RetVal ) {
 753                 cdebug << "anOutPort->RemoveInPort( anInPort ) Error RetVal " << RetVal << endl ;
 754                 break ;
 755               }
 756             }
 757           }
 758         }
 759       }
 760     }
 761
 762     if ( RetVal ) {
 763       for ( i = aNode->GetNodeOutPortsSize() - 1 ; i >= 0 ; i-- ) {
 764         GraphBase::OutPort * anOutPort = aNode->GetChangeNodeOutPort( i ) ;
 765         cdebug << "OutPort" << i << ". Remove " << anOutPort->InPortsSize()
 766                << " InPortsof OutPort : " << anOutPort->NodeName() << "( " << anOutPort->PortName() << ") "
 767                << anOutPort->PortStatus() << " :" << endl ;
 768         int j ;
 769         for ( j = anOutPort->InPortsSize() - 1 ; j >= 0  ; j-- ) {
 770           GraphBase::InPort * anInPort = anOutPort->ChangeInPorts( j ) ;
 771           cdebug << "       to InPort" << j << ". " << anInPort->NodeName() << "( " << anInPort->PortName() << ") "
 772                  << anInPort->PortStatus() << endl ;
 773           if ( !anInPort->IsExternConnected() ) {
 774             GraphBase::ComputingNode * ToNode = GetChangeGraphNode( anInPort->NodeName() ) ;
 775             RetVal = anInPort->RemoveOutPort() ;
 776             if ( !RetVal ) {
 777               cdebug << "anOutPort->RemoveOutPort Error RetVal " << RetVal << endl ;
 778               break ;
 779             }
 780             if ( ( aNode->IsGOTONode() && ToNode->IsOneOfInLineNodes() ) ||
 781                  ( aNode->IsEndLoopNode() && ToNode->IsLoopNode( ) ) ) {
 782             }
 783             else if ( anOutPort->IsDataStream() ) {
 784               RetVal = aNode->RemoveStreamLinkedNode( ToNode ) ;
 785             }
 786             else {
 787               RetVal = aNode->RemoveLinkedNode( ToNode ) ;
 788             }
 789             if ( !RetVal ) {
 790               cdebug << "anOutPort->RemoveLinkedNode Error RetVal " << RetVal << endl ;
 791               break ;
 792             }
 793             RetVal = anOutPort->RemoveInPort( anInPort ) ;
 794             if ( !RetVal ) {
 795               cdebug << "anOutPort->RemoveInPort( anInPort ) Error RetVal " << RetVal << endl ;
 796               break ;
 797             }
 798           }
 799         }
 800         if ( !RetVal ) {
 801           cdebug << "Error RetVal " << RetVal << endl ;
 802           break ;
 803         }
 804       }
 805     }
 806     cdebug << "Graph::RemoveNode " << aNode->Name() << " : " << aNode->GetNodeInPortsSize()
 807            << " InPorts " << aNode->GetNodeOutPortsSize() << " OutPorts "
 808            << aNode->LinkedNodesSize() << " LinkedNodes " << aNode->LinkedFromNodesSize()
 809            << " LinkedFromNodes " << endl ;
 810     for ( i = 0 ; i < aNode->LinkedNodesSize() ; i++ ) {
 811       cdebug << "         LinkedNode" << i << ". " << aNode->LinkedNodes( i ) << " "
 812              << aNode->LinkedNodes( i )->Name() << endl ;
 813     }
 814     for ( i = 0 ; i < aNode->LinkedFromNodesSize() ; i++ ) {
 815       cdebug << "         LinkedFromNode" << i << ". " << aNode->LinkedFromNodes( i ) << " "
 816              << aNode->LinkedFromNodes( i )->Name() << endl ;
 817     }
 818 // Delete of aNode from the Graph :
 819 // The LoopNode is needed by the delete of the EndLoopNode. So the LoopNode will be deleted
 820 // when the EndLoopNode is deleted. It is the same for SwitchNode & EndSwitchNode
 821     if ( RetVal && !aNode->IsLoopNode() && !aNode->IsSwitchNode() ) {
 822       GraphBase::InLineNode * theCoupledNode = NULL ;
 823       char * theCoupledNodeName = NULL ;
 824       int CoupledIndex = -1 ;
 825       if ( aNode->IsEndLoopNode() || aNode->IsEndSwitchNode() ) {
 826         theCoupledNode = ((GraphBase::GOTONode * ) aNode)->CoupledNode() ;
 827         theCoupledNodeName = ((GraphBase::GOTONode * ) aNode)->CoupledNodeName() ;
 828         CoupledIndex = GetGraphNodeIndex( theCoupledNode->Name() ) ;
 829       }
 830       delete aNode ;
 831       _GraphNodesSize -= 1 ;
 832       for ( i = index ; i < _GraphNodesSize ; i++ ) {
 833         _GraphNodes[ i ] = _GraphNodes[ i+1 ] ;
 834         SetGraphNodeIndex( _GraphNodes[ i ]->Name() , i ) ;
 835       }
 836       _GraphNodes.resize( _GraphNodesSize+1 ) ;
 837       _MapOfGraphNodes.erase( aNodeName ) ;
 838 // Delete of the LoopNode of that EndLoopNode or of the SwitchNode of that EndSwitchNode :
 839       if ( theCoupledNode ) {
 840         delete theCoupledNode ;
 841         _GraphNodesSize -= 1 ;
 842         for ( i = CoupledIndex ; i < _GraphNodesSize ; i++ ) {
 843           _GraphNodes[ i ] = _GraphNodes[ i+1 ] ;
 844           SetGraphNodeIndex( _GraphNodes[ i ]->Name() , i ) ;
 845         }
 846         _GraphNodes.resize( _GraphNodesSize+1 ) ;
 847         _MapOfGraphNodes.erase( theCoupledNodeName ) ;
 848       }
 849       RetVal = true ;
 850     }
 851   }
 852   else {
 853     cdebug << "Node not found ERROR " << index << endl ;
 854   }
 855
 856   cdebug_out << "GraphBase::Graph::RemoveNode " << RetVal << endl;
 857   return RetVal ;
 858 }
 859
 860 bool GraphBase::Graph::AddLink( const char* FromNodeName ,
 861                                 const char* FromServiceParameterName ,
 862                                 const char* ToNodeName ,
 863                                 const char* ToServiceParameterName ) {
 864 //                                , const CORBA::Any aValue ) {
 865   bool RetVal ;
 866 //  int index ;
 867   cdebug_in << "GraphBase::Graph::AddLink(" << FromNodeName << "("
 868             << FromServiceParameterName << ") ---> " << ToNodeName << "("
 869             << ToServiceParameterName << ") , aValue )" << endl;
 870
 871   GraphBase::ComputingNode *fromNode = GetChangeGraphNode( FromNodeName ) ;
 872   GraphBase::ComputingNode *toNode = GetChangeGraphNode( ToNodeName ) ;
 873
 874   GraphBase::OutPort *fromPort = NULL ;
 875   GraphBase::InPort *toPort = NULL ;
 876
 877   if ( fromNode ) {
 878     // asv : 29.12.04 : as I understand, replacement of "InitLoop" by "DoLoop" was
 879     // done by JR in order to keep old graphs and batch test scripts working after change
 880     // of special Loop's port name from "InitLoop" to "DoLoop".  I suppose, it is not
 881     // needed, all old graphs and tests must be changed to use "DoLoop" name for addressing
 882     // this port..  It we don't do it, ANY port with "InitLoop" name will be replaced by "DoLoop"
 883     // and it can cause unexpected bugs in future...  So I comment out the replacement code.
 884     //if ( strcmp( FromServiceParameterName , "InitLoop" ) ) {
 885 //JR 12.01.05 : Yes the test is not good ; now I test that PortName only in LoopNodes ==>
 886 //   + old graphs will runs normally (it is not possible to ask CEA to edit their graphs)
 887 //   + in old graphs "InitLoop" and "DoLoop" were reserved parameter names (but not controlled)
 888 //   + in new graphs, I have added a control at port creation of that names : they are refused
 889     if ( !(fromNode->IsLoopNode() && strcmp( FromServiceParameterName , "InitLoop" ) == 0 ) ) {
 890       fromPort = fromNode->GetChangeOutPort( FromServiceParameterName ) ;
 891     }
 892     else {
 893       fromPort = fromNode->GetChangeOutPort( "DoLoop" ) ;
 894     }
 895     if ( !fromPort ) {
 896       cdebug << "ERROR AddLink fromPort " << FromServiceParameterName << " FromNode("
 897            << FromNodeName << ") not found." << endl ;
 898     }
 899   }
 900   else {
 901     cdebug << "ERROR AddLink FromNode " << FromNodeName << " not found." << endl ;
 902   }
 903   if ( toNode ) {
 904     // see comment above
 905 //    if ( strcmp( ToServiceParameterName , "InitLoop" ) ) {
 906     if ( !(toNode->IsLoopNode() && strcmp( ToServiceParameterName , "InitLoop" ) == 0 ) ) {
 907       toPort = toNode->GetChangeInPort( ToServiceParameterName ) ;
 908     }
 909     else {
 910       toPort = toNode->GetChangeInPort( "DoLoop" ) ;
 911     }
 912     if ( !toPort ) {
 913       cdebug << "ERROR AddLink toPort " << ToServiceParameterName << " ToNode("
 914              << ToNodeName << ") not found." << endl ;
 915     }
 916   }
 917   else {
 918     cdebug << "ERROR AddLink toNode " << ToNodeName << " not found." << endl ;
 919   }
 920
 921   RetVal = AddLink( fromNode , fromPort , toNode , toPort ) ;
 922
 923   if ( RetVal ) {
 924     if ( fromPort->IsGate() && toPort->IsGate() ) {
 925       CORBA::Any aValue ;
 926       aValue <<= (long ) 1 ;
 927       fromPort->Value( aValue ) ;
 928     }
 929 //    else {
 930 //      const CORBA::Any * aDataValue = new CORBA::Any( aValue ) ;
 931 //      fromPort->Value( aDataValue ) ;
 932 //    }
 933 //    fromPort->PortStatus( DataConnected );
 934   }
 935
 936   cdebug_out << "GraphBase::Graph::AddLink " << RetVal << endl;
 937   return RetVal ;
 938 }
 939
 940 bool GraphBase::Graph::AddLink( GraphBase::ComputingNode *fromNode ,
 941                                 GraphBase::OutPort *fromPort ,
 942                                 GraphBase::ComputingNode *toNode ,
 943                                 GraphBase::InPort *toPort ) {
 944 //  bool RetVal ;
 945
 946   if ( !fromNode ) {
 947     cdebug << "ERROR AddLink fromNode not found." << endl ;
 948     return false ;
 949   }
 950   if ( !fromPort ) {
 951     cdebug << "ERROR AddLink fromPort not found." << endl ;
 952     return false ;
 953   }
 954
 955   if ( !toNode ) {
 956     cdebug << "ERROR AddLink toNode not found." << endl ;
 957     return false ;
 958   }
 959   if ( !toPort ) {
 960     cdebug << "ERROR AddLink toPort not found." << endl ;
 961     return false ;
 962   }
 963   if ( ( fromPort->IsDataStream() && !toPort->IsDataStream() ) ||
 964        ( !fromPort->IsDataStream() && toPort->IsDataStream() ) ) {
 965     cdebug << "AddLink fromPort/toPort Stream/Flow. ERROR" << endl ;
 966     return false ;
 967   }
 968   if ( fromPort->IsDataStream() && fromPort->Dependency() == SALOME_ModuleCatalog::DATASTREAM_TEMPORAL &&
 969        toPort->Dependency() == SALOME_ModuleCatalog::DATASTREAM_ITERATIVE ) {
 970     cdebug << "AddLink fromPort/toPort Stream DATASTREAM_TEMPORAL --> DATASTREAM_ITERATIVE. ERROR" << endl ;
 971     return false ;
 972   }
 973
 974   cdebug_in << "GraphBase::Graph::AddLink(" << fromNode->Name() << "("
 975             << fromPort->PortName() << " " << fromPort->PortStatus() << ") ---> " << toNode->Name() << "("
 976             << toPort->PortName() << " " << toPort->PortStatus() << ") )" << endl;
 977   if ( fromPort->IsDataConnected() || fromPort->IsExternConnected() ) {
 978     if ( !fromPort->RemoveInPort() ) { // There is only one ===> RemoveOutPort()
 979       cdebug_out << "GraphBase::Graph::AddLink(" << fromNode->Name() << "("
 980                  << fromPort->PortName() << " " << fromPort->PortStatus() << ") RemoveInPort ERROR " << endl ;
 981       return false ;
 982     }
 983   }
 984   if ( toPort->IsDataConnected() || toPort->IsExternConnected() ) {
 985     if ( !toPort->GetOutPort()->RemoveInPort() ) { // There is only one ===> RemoveOutPort()
 986       cdebug_out << "GraphBase::Graph::AddLink(" << toNode->Name() << "("
 987                  << toPort->PortName() << " " << toPort->PortStatus() << ") RemoveInPort ERROR " << endl ;
 988       return false ;
 989     }
 990   }
 991   else if ( toPort->IsPortConnected() && !toNode->IsEndSwitchNode() ) {
 992     if ( !RemoveLink( toPort->GetOutPort()->NodeName() ,
 993                       toPort->GetOutPort()->PortName() ,
 994                       toNode->Name() , toPort->PortName() ) ) {
 995       cdebug_out << "RemoveLink(AddLink) toPort->GetOutPort()->NodeName() RemoveLink Error." << endl ;
 996       return false ;
 997     }
 998   }
 999
1000   if ( !fromNode->IsDataFlowNode() && !fromNode->IsDataStreamNode() &&
1001        !toNode->IsDataFlowNode() && !toNode->IsDataStreamNode() &&
1002        toPort->GetOutPort() ) {
1003     if ( !strcmp( toPort->GetOutPort()->NodePortName() ,
1004                   fromPort->NodePortName() ) ) {
1005       cdebug << "Link already exists" << endl ;
1006       cdebug_out << "GraphBase::Graph::AddLink 1" << endl;
1007       return true ;
1008     }
1009     else if ( toPort->IsDataConnected() || toPort->IsExternConnected() ) {
1010       toPort->GetOutPort()->RemoveInPort( toPort ) ; //dbg
1011     }
1012     else if ( fromNode->IsGOTONode() ) {
1013       if ( !RemoveLink( toPort->GetOutPort()->NodeName() ,
1014                         toPort->GetOutPort()->PortName() ,
1015                         toNode->Name() , toPort->PortName() ) ) {
1016         cdebug << "RemoveLink(AddLink) Error."
1017                << endl ;
1018         cdebug_out << "GraphBase::Graph::AddLink" << endl;
1019         return false ;
1020       }
1021       if ( fromPort->InPortsSize() ) {
1022         if ( !RemoveLink( fromNode->Name() , fromPort->PortName() ,
1023                           fromPort->ChangeInPorts(0)->NodeName() ,
1024                           fromPort->ChangeInPorts(0)->PortName() ) ) {
1025           cdebug << "RemoveLink(AddLink) fromNode->IsGOTONode Error." << endl ;
1026           cdebug_out << "GraphBase::Graph::AddLink" << endl;
1027           return false ;
1028         }
1029       }
1030     }
1031     else if ( !toNode->IsEndSwitchNode() ||
1032               ( toNode->IsEndSwitchNode() && toPort->IsGate() ) ) {
1033       if ( !RemoveLink( fromNode->Name() , fromPort->PortName() ,
1034                         toNode->Name() , toPort->PortName() ) ) {
1035         cdebug << "RemoveLink(AddLink) toNode->IsEndSwitchNode Error." << endl ;
1036         cdebug_out << "GraphBase::Graph::AddLink" << endl;
1037         return false ;
1038       }
1039     }
1040   }
1041   else if ( fromNode->IsGOTONode() && fromPort->InPortsSize() ) {
1042     if ( !RemoveLink( fromNode->Name() , fromPort->PortName() ,
1043                       fromPort->ChangeInPorts(0)->NodeName() ,
1044                       fromPort->ChangeInPorts(0)->PortName() ) ) {
1045       cdebug << "RemoveLink(AddLink) fromNode->IsGOTONode Error." << endl ;
1046       cdebug_out << "GraphBase::Graph::AddLink" << endl;
1047       return false ;
1048     }
1049   }
1050   else if ( ( fromNode->IsDataFlowNode() || fromNode->IsDataStreamNode() ) &&
1051        ( toPort->IsDataConnected() || toPort->IsExternConnected() ) ) {
1052     fromPort->RemoveInPort( toPort ) ; //dbg
1053   }
1054   else if ( ( toNode->IsDataFlowNode() || toNode->IsDataStreamNode() ) &&
1055        ( fromPort->IsDataConnected() || fromPort->IsExternConnected() ) ) {
1056     fromPort->RemoveInPort() ; // There is only one
1057   }
1058
1059
1060   if ( toNode->IsEndSwitchNode() && !toPort->IsGate() ) {
1061 //    if ( !toPort->IsEndSwitch() || !fromPort->AddInPort( toPort ) ) {
1062     if ( !fromPort->AddInPort( toPort ) ) {
1063       cdebug << "toNode->IsEndSwitchNode() : !fromPort->AddInPort( toPort ) AddLink Error."
1064              << endl ;
1065       cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1066       return false ;
1067     }
1068     if ( !toPort->IsDataStream() ) {
1069       toPort->Kind( SUPERV::EndSwitchParameter ) ;
1070     }
1071   }
1072 // JR 12.01.2005 : an OutPort of a SwitchNode connected to a Gate can be connected only to Gate
1073   else if ( fromNode->IsSwitchNode() && fromPort->IsSwitch() && !toPort->IsGate() ) {
1074     cdebug << "toPort->AddLink Error( fromPort->IsSwitch() && !toPort->IsGate())." << endl ;
1075     cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1076     return false ;
1077   }
1078   else if ( !fromPort->AddInPort( toPort ) ) { // --> MapOfInports in the OutPort
1079     cdebug << "!fromPort->AddLink Error." << endl ;
1080     cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1081     return false ;
1082   }
1083
1084   if ( fromNode->IsGOTONode() && ( !fromPort->IsGate() || !toPort->IsGate() ||
1085        toNode->IsEndLoopNode() || toNode->IsEndSwitchNode() ) ) {
1086     cdebug << "toPort->AddLink Error( fromNode->IsGOTONode() && toNode->IsEndInLineNode() )." << endl ;
1087     cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1088     return false ;
1089   }
1090   else if ( !fromNode->IsSwitchNode() && fromPort->IsParam() && toPort->IsGate() ) {
1091     cdebug << "toPort->AddLink Error( fromPort->IsParam() && toPort->IsGate())." << endl ;
1092     cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1093     return false ;
1094   }
1095   else if ( !toNode->IsEndSwitchNode() && !toNode->IsEndLoopNode() ) {
1096     if ( !toPort->AddOutPort( fromPort ) ) { // --> Unique OutPort of the InPort
1097       cdebug << "toPort->AddLink Error." << endl ;
1098       cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1099       return false ;
1100     }
1101   }
1102   else {
1103     toPort->AddOutPort( fromPort ) ;
1104   }
1105
1106   if ( ( fromNode->IsGOTONode() && toNode->IsOneOfInLineNodes() ) ||
1107        ( fromNode->IsEndLoopNode() && toNode->IsLoopNode() ) ) {
1108     cdebug << "AddLink fromPort->PortStatus( PortConnected ) "
1109            << "GOTONode/EndLoopNode-->InLineNode/LoopNode/SwitchNode "
1110            << fromNode->Name() << " " << fromPort->PortName()
1111            << " InLineNode/LoopNode_ConnectedInPortsNumber "
1112            << toNode->ConnectedInPortsNumber() << endl;
1113     if ( fromNode->IsGOTONode() ) {
1114       fromPort->Kind( SUPERV::GOTOParameter ) ;
1115     }
1116     fromPort->PortStatus( PortConnected ); // GOTO - Loop
1117   }
1118   else if ( fromNode->IsDataFlowNode() || fromNode->IsDataStreamNode() ) {
1119     cdebug << "AddLink IsDataFlow/StreamNode fromPort->PortStatus( DataConnected ) : "
1120            << fromNode->Name() << " " << fromPort->PortName() << endl ;
1121     fromPort->PortStatus( ExternConnected );
1122   }
1123   else if ( toNode->IsDataFlowNode() || toNode->IsDataStreamNode() ) {
1124     cdebug << "AddLink IsDataFlow/StreamNode fromPort->PortStatus( ExternConnected ) : "
1125            << fromNode->Name() << " " << fromPort->PortName() << endl ;
1126     fromPort->PortStatus( ExternConnected ) ;
1127   }
1128   else {
1129     cdebug << "AddLink fromPort->PortStatus( PortConnected ) & fromNode->toNode "
1130            << fromNode->Name() << " " << fromPort->PortName() << " "
1131            << fromPort->Kind() << " OldPortStatus " << fromPort->PortStatus() << " -> " << toNode->Name()
1132            << " " << " " << toPort->PortName() << " " << toPort->Kind() << endl;
1133     fromPort->PortStatus( PortConnected );
1134     if ( fromPort->IsDataStream() && toPort->IsDataStream() ) {
1135       fromNode->AddStreamLinkedNode( toNode ) ;
1136     }
1137     else {
1138       fromNode->AddLinkedNode( toNode ) ;
1139     }
1140   }
1141   if ( fromNode->IsSwitchNode() ) {
1142     if ( !fromPort->IsDataStream() ) {
1143       if ( fromPort->IsInLine() && toPort->IsGate() && !toNode->IsEndSwitchNode() ) {
1144         fromPort->Kind( SUPERV::SwitchParameter ) ;
1145       }
1146       else if ( !fromPort->IsGate() && !toPort->IsGate() ){
1147         fromPort->Kind( SUPERV::InLineParameter ) ;
1148       }
1149     }
1150     if ( fromPort->IsGate() && !toNode->IsEndSwitchNode() ) {
1151       GraphBase::InLineNode * anEndSwitchNode ;
1152       anEndSwitchNode = ((GraphBase::SwitchNode * ) fromNode)->CoupledNode() ;
1153       GraphBase::InPort * anInPort = anEndSwitchNode->GetChangeNodeInGate() ;
1154       GraphBase::OutPort * anOutPort = anInPort->GetOutPort() ;
1155       if ( anOutPort && !strcmp( fromNode->Name() , anOutPort->NodeName() ) &&
1156            !strcmp( fromPort->PortName() , anOutPort->PortName() ) &&
1157            anOutPort->IsGate() ) {
1158         if ( !RemoveLink( fromNode->Name() , anOutPort->PortName() ,
1159                           anEndSwitchNode->Name() ,
1160                           anInPort->PortName() ) ) {
1161           cdebug << "AddLink Error Removelink ( Switch , Default , EndSwitch , Default )"
1162                  << endl ;
1163           cdebug_out << "GraphBase::Graph::AddLink 0" << endl;
1164           return false ;
1165         }
1166       }
1167     }
1168   }
1169 //  cdebug << fromNode->ServiceName() << " " << toNode->ServiceName() << endl ;
1170   cdebug_out << "GraphBase::Graph::AddLink 1" << endl;
1171   return true ;
1172 }
1173
1174 bool GraphBase::Graph::RemoveLink( const char* FromNodeName ,
1175                                    const char* FromServiceParameterName ,
1176                                    const char* ToNodeName ,
1177                                    const char* ToServiceParameterName ) {
1178   cdebug_in << "GraphBase::Graph::RemoveLink from " << FromNodeName << "(" << FromServiceParameterName << ")"
1179             << " to " << ToNodeName << "(" << ToServiceParameterName << ")" << endl;
1180   bool RetVal = false ;
1181   GraphBase::ComputingNode * toNode = GetChangeGraphNode( ToNodeName ) ;
1182   if ( toNode ) {
1183     GraphBase::InPort * anInPort = toNode->GetChangeInPort( ToServiceParameterName ) ;
1184     if ( anInPort && ( anInPort->IsPortConnected() ||
1185                        anInPort->IsDataConnected() ||
1186                        anInPort->IsExternConnected() ) ) {
1187 // JR 13.01.2005 : Bug if it is a link to an EndSwitchNode. The OutPort may be an other one !!!
1188       GraphBase::ComputingNode * fromNode = GetChangeGraphNode( FromNodeName ) ;
1189       GraphBase::OutPort * anOutPort = NULL ;
1190       if ( toNode->IsEndSwitchNode() ) {
1191         anOutPort = fromNode->GetChangeOutPort( FromServiceParameterName ) ;
1192         RetVal = anOutPort->RemoveInPort( anInPort ) ;
1193       }
1194       else {
1195         anOutPort = anInPort->GetOutPort() ;
1196         RetVal = anOutPort->RemoveInPort( anInPort ) ;
1197       }
1198 //      anInPort->RemoveOutPort() ; // Already done in RemoveInPort
1199 //      const char * FromNodeName = anOutPort->NodeName() ;
1200       if ( RetVal ) {
1201         if ( fromNode ) {
1202           if ( anInPort->IsDataStream() ) {
1203             fromNode->RemoveStreamLinkedNode( toNode ) ;
1204           }
1205           else {
1206             fromNode->RemoveLinkedNode( toNode ) ;
1207           }
1208         }
1209         if ( fromNode->IsSwitchNode() && !anOutPort->IsGate() && !toNode->IsEndSwitchNode() ) {
1210           anOutPort->Kind( SUPERV::InLineParameter ) ;
1211         }
1212 // JR 13.01.2005 : Bug if it is a link to an EndSwitchNode. The InPort may be linked !!!
1213         if ( toNode->IsEndSwitchNode() ) {
1214           int i ;
1215           int done = false ;
1216           for ( i = 0 ; i < toNode->LinkedFromNodesSize() ; i++ ) {
1217             GraphBase::StreamNode * fromNode = toNode->LinkedFromNodes( i ) ;
1218             int j ;
1219             for ( j = 0 ; j < fromNode->GetNodeOutPortsSize() ; j++ ) {
1220               GraphBase::OutPort * fromOutPort = fromNode->GetChangeNodeOutPort( j ) ;
1221               int k ;
1222               for ( k = 0 ; k < fromOutPort->InPortsSize() ; k++ ) {
1223                 if ( strcmp( toNode->Name() , fromOutPort->InPorts( k )->NodeName() ) == 0 ) {
1224 // Restore an OutPort in the InPort
1225                   anInPort->ChangeOutPort( fromOutPort ) ;
1226                   cdebug << "Graph::RemoveLink reestablish " << fromOutPort->NodeName() << "( "
1227                          << fromOutPort->PortName() << " ) in the InPort of EndSwitch : "
1228                          << toNode->Name() << "( " << anInPort->PortName() << " )" << endl;
1229                   done = true ;
1230                   break ;
1231                 }
1232               }
1233               if ( done ) {
1234                 break ;
1235               }
1236             }
1237             if ( done ) {
1238               break ;
1239             }
1240           }
1241         }
1242       }
1243     }
1244   }
1245   cdebug_out << "GraphBase::Graph::RemoveLink " << RetVal << endl;
1246   return RetVal ;
1247 }
1248
1249 bool GraphBase::Graph::GetLink(const char* ToNodeName ,
1250                                const char* ToServiceParameterName ,
1251                                char** FromNodeName ,
1252                                char** FromServiceParameterName ) {
1253 //  cdebug_in << "GraphBase::Graph::GetLink " << ToNodeName << "("
1254 //            << ToServiceParameterName << ")" << endl;
1255   bool RetVal = false ;
1256   GraphBase::ComputingNode * toNode = GetChangeGraphNode( ToNodeName ) ;
1257   if ( toNode ) {
1258     GraphBase::InPort * anInPort = toNode->GetChangeInPort( ToServiceParameterName ) ;
1259     if ( anInPort && !anInPort->IsNotConnected() ) {
1260       GraphBase::OutPort * anOutPort = anInPort->GetOutPort() ;
1261       *FromNodeName = my_strdup( anOutPort->NodeName() ) ;
1262       *FromServiceParameterName = my_strdup( anOutPort->PortName() ) ;
1263       RetVal = true ;
1264     }
1265     else {
1266       cdebug << "GraphBase::Graph::GetLink ERROR no InPort or NotConnected " << ToNodeName
1267              << " " << ToServiceParameterName << " " << RetVal << endl;
1268     }
1269   }
1270   else {
1271     cdebug << "GraphBase::Graph::GetLink ERROR no Node " << ToNodeName << " " << RetVal
1272            << endl;
1273   }
1274 //  cdebug_out << "GraphBase::Graph::GetLink " << RetVal << endl;
1275   return RetVal ;
1276 }
1277
1278 bool GraphBase::Graph::AddInputData( const char* ToNodeName ,
1279                                      const char* ToServiceParameterName ,
1280                                      const CORBA::Any aValue ) {
1281   bool RetVal = false ;
1282   cdebug_in << "GraphBase::Graph::AddInputData(" << ToNodeName << ","
1283             << ToServiceParameterName << " , Any " ;
1284   switch (aValue.type()->kind()) {
1285     case CORBA::tk_string:
1286       char * t;
1287       aValue >>= t;
1288       cdebug << t << " (string) " ;
1289       break;
1290     case CORBA::tk_double:
1291       double d;
1292       aValue >>= d;
1293       cdebug << d << " (double) " ;
1294       break;
1295     case CORBA::tk_long:
1296       long l;
1297       aValue >>= l;
1298       cdebug << l << " (long) " ;
1299       break;
1300     case CORBA::tk_objref:
1301       cdebug << "(object reference) " ;
1302       break;
1303     default:
1304       cdebug << "(other(tk_string(" << CORBA::tk_string << "),tk_double(" << CORBA::tk_double << "),tk_long("
1305              << CORBA::tk_long << "),tk_objref)(" << CORBA::tk_objref << ")) ERROR : " << aValue.type()->kind() ;
1306       break;
1307     }
1308   cdebug << " ) in Graph " << Name() << endl;
1309
1310   GraphBase::ComputingNode *toNode ;
1311   GraphBase::InPort *toPort ;
1312   char *aNodeName ;
1313   char *aPortName ;
1314   NodePort( ToNodeName , ToServiceParameterName , &aNodeName , &aPortName ) ;
1315   toNode = GetChangeGraphNode( aNodeName ) ;
1316   cdebug << "in Graph " << Name() << " aNodeName " << aNodeName << " aPortName " << aPortName << endl;
1317   if ( toNode ) {
1318     toPort = toNode->GetChangeInPort( aPortName ) ;
1319     if ( toPort && !toPort->IsDataConnected() ) {
1320       toPort->RemoveOutPort() ;
1321     }
1322   }
1323   else {
1324     toPort = NULL ;
1325   }
1326
1327   int i ;
1328   for ( i = 0 ; i < GetNodeOutDataNodePortsSize() ; i++ ) {
1329     cdebug << "Graph::AddInputData In" << i << " " << *GetNodeOutDataNodePort(i) << endl ;
1330   }
1331   for ( i = 0 ; i < GetNodeInDataNodePortsSize() ; i++ ) {
1332     cdebug << "Graph::AddInputData Out" << i << " " << *GetNodeInDataNodePort(i) << endl ;
1333   }
1334
1335   if ( toNode && toPort ) {
1336     GraphBase::OutPort *fromDataNodePort = NULL ;
1337     fromDataNodePort = GraphBase::DataNode::GetChangeInDataNodePort( toPort->NodePortName() ) ;
1338     if ( fromDataNodePort && fromDataNodePort->GetInPort( toPort ) ) {
1339       fromDataNodePort->RemoveInPort( toPort ) ;
1340     }
1341     cdebug << "Try AddLink " << toPort->NodePortName() << " : " << Name() << "( "
1342            << fromDataNodePort->PortName() << " ) -->" << toNode->Name() << "( "
1343            << toPort->PortName() << " )" << endl ;
1344     RetVal = AddLink( (GraphBase::ComputingNode * ) this , fromDataNodePort ,
1345                       toNode , toPort ) ;
1346     if ( RetVal ) {
1347       fromDataNodePort->Value( aValue ) ;
1348       fromDataNodePort->PortStatus( DataConnected ) ;
1349     }
1350   }
1351   else {
1352     cdebug << "ERROR Node and/or Port not found : " << aNodeName << " " << aPortName << endl ;
1353   }
1354   delete aNodeName ;
1355   delete aPortName ;
1356
1357   cdebug_out << "GraphBase::Graph::AddInputData " << RetVal << endl;
1358   return RetVal ;
1359 }
1360
1361 // Used in the Executor in order to change an Input Value and ReRun
1362 bool GraphBase::Graph::ChangeInputData( const char * ToNodeName ,
1363                                         const char * ToServiceParameterName ,
1364                                         const CORBA::Any aValue ) {
1365   bool RetVal = false ;
1366   cdebug_in << "GraphBase::Graph::ChangeInputData( '" << ToNodeName << "' , '"
1367             << ToServiceParameterName << "' , Any " ;
1368   switch (aValue.type()->kind()) {
1369     case CORBA::tk_string:
1370       char * t;
1371       aValue >>= t;
1372       cdebug << t << " (string) " ;
1373       break;
1374     case CORBA::tk_double:
1375       double d;
1376       aValue >>= d;
1377       cdebug << d << " (double) " ;
1378       break;
1379     case CORBA::tk_long:
1380       long l;
1381       aValue >>= l;
1382       cdebug << l << " (long) " ;
1383       break;
1384     case CORBA::tk_objref:
1385       cdebug << "(object reference) " ;
1386       break;
1387     default:
1388       cdebug << "(other(tk_string,tk_double,tk_long,tk_objref)) ERROR";
1389       break;
1390     }
1391   cdebug << " ) in Graph " << Name() << endl;
1392
1393   GraphBase::ComputingNode * toNode ;
1394   GraphBase::InPort * toPort = NULL ;
1395   char * aNodeName ;
1396   char * aPortName ;
1397   NodePort( ToNodeName , ToServiceParameterName , &aNodeName , &aPortName ) ;
1398   toNode = GetChangeGraphNode( aNodeName ) ;
1399   cdebug << "in Graph " << Name() << " aNodeName " << aNodeName << " aPortName " << aPortName << endl;
1400   if ( toNode ) {
1401     toPort = toNode->GetChangeInPort( aPortName ) ;
1402     if ( toPort && toPort->IsDataConnected() ) {
1403       GraphBase::OutPort * fromPort = toPort->GetOutPort();
1404       if ( fromPort ) {
1405         RetVal = true ;
1406         fromPort->Value( aValue ) ;
1407         fromPort->PortStatus( DataConnected ) ;
1408         toPort->State( SUPERV::ReadyState ) ;
1409       }
1410       else {
1411         cdebug << "ERROR ChangeInputData fromPort not found" << endl ;
1412       }
1413     }
1414     else {
1415       cdebug << "ERROR ChangeInputData toPort not found" << endl ;
1416     }
1417   }
1418   else {
1419     cdebug << "ERROR ChangeInputData Node not found : " << ToNodeName << endl ;
1420   }
1421
1422   cdebug_out << "GraphBase::Graph::ChangeInputData" << endl;
1423   return RetVal ;
1424 }
1425
1426 // To restore InputData in CreateService
1427 bool GraphBase::Graph::AddInputData( const char* ToNodeName ,
1428                                      const char* ToServiceParameterName ,
1429                                      const CORBA::Any ** aValue ) {
1430   bool RetVal = false ;
1431   cdebug_in << "GraphBase::Graph::AddInputData( " << ToNodeName << " , "
1432             << ToServiceParameterName << ", **Any " ;
1433   const CORBA::Any theValue = **aValue ;
1434   switch (theValue.type()->kind()) {
1435     case CORBA::tk_string:
1436       char * t;
1437       theValue >>= t;
1438       cdebug << t << " (string) " ;
1439       break;
1440     case CORBA::tk_double:
1441       double d;
1442       theValue >>= d;
1443       cdebug << d << " (double) " ;
1444       break;
1445     case CORBA::tk_long:
1446       long l;
1447       theValue >>= l;
1448       cdebug << l << " (long) " ;
1449       break;
1450     case CORBA::tk_objref:
1451       cdebug << "(object reference) " ;
1452       break;
1453     default:
1454       cdebug << "(other(tk_string,tk_double,tk_long,tk_objref)) ERROR";
1455       break;
1456     }
1457   cdebug << ") of Graph " << Name() << endl;
1458
1459   GraphBase::ComputingNode *toNode = GetChangeGraphNode( ToNodeName ) ;
1460
1461   if ( toNode ) {
1462     GraphBase::InPort *toPort = NULL ;
1463     GraphBase::OutPort *fromDataNodePort = NULL ;
1464     toPort = toNode->GetChangeInPort( ToServiceParameterName ) ;
1465     fromDataNodePort = GraphBase::DataNode::GetChangeInDataNodePort( toPort->NodePortName() ) ;
1466     cdebug << "Try AddLink " << Name() << "( " << fromDataNodePort << " ) -->"
1467            << toNode->Name() << "( " << toPort->PortName() << " )" << endl ;
1468     RetVal = AddLink( (GraphBase::ComputingNode * ) this , fromDataNodePort ,
1469                       toNode , toPort ) ;
1470     if ( RetVal ) {
1471       fromDataNodePort->Value( aValue ) ;
1472       fromDataNodePort->PortStatus( DataConnected ) ;
1473     }
1474   }
1475   else {
1476     cdebug << "ERROR Node not found " << ToNodeName << " ERROR. Known nodes :" << endl ;
1477     map< string , int >::iterator aMapOfGraphNodesIterator ;
1478     int i = 0 ;
1479     for ( aMapOfGraphNodesIterator = _MapOfGraphNodes.begin() ;
1480           aMapOfGraphNodesIterator != _MapOfGraphNodes.end() ; aMapOfGraphNodesIterator++ ) {
1481       cdebug << "MapOfGraphNodes " << i++ << " " << aMapOfGraphNodesIterator->first << " --> "
1482              << aMapOfGraphNodesIterator->second << endl ;
1483     }
1484   }
1485
1486   cdebug_out << "GraphBase::Graph::AddInputData " << RetVal << endl;
1487   return RetVal ;
1488 }
1489
1490 bool GraphBase::Graph::AddOutputData( const char* FromNodeName ,
1491                                       const char* FromServiceParameterName ,
1492                                       const CORBA::Any aValue ) {
1493   bool RetVal = true ;
1494   cdebug_in << "GraphBase::Graph::AddOutputData(" << FromNodeName << ","
1495             << FromServiceParameterName << ")" << endl;
1496   GraphBase::ComputingNode *fromNode = GetChangeGraphNode( FromNodeName ) ;
1497
1498   GraphBase::OutPort *anOutPort = NULL ;
1499
1500   if ( fromNode ) {
1501     anOutPort = fromNode->GetChangeOutPort( FromServiceParameterName ) ;
1502 //    toDataNodePort = GraphBase::DataNode::GetChangeOutDataNodePort( fromPort->NodePortName() ) ;
1503 //    RetVal = AddLink( fromNode , fromPort ,
1504 //                      (GraphBase::ComputingNode * ) this , toDataNodePort ) ;
1505     anOutPort->Value( aValue ) ;
1506     anOutPort->State(  SUPERV::ReadyState ) ;
1507     anOutPort->Done( true ) ;
1508     cdebug << *anOutPort ;
1509 #ifdef _DEBUG_
1510     anOutPort->StringValue( *_fdebug ) ;
1511 #endif
1512     cdebug << endl ;
1513   }
1514   else {
1515     cdebug << "ERROR Node not found" << endl ;
1516     RetVal = false ;
1517   }
1518   cdebug_out << "GraphBase::Graph::AddOutputData " << RetVal << endl;
1519   return RetVal ;
1520 }
1521
1522 map< string , GraphBase::Service * > GraphBase::Graph::MapOfServiceNames() {
1523                                            return _MapOfServiceNames ; }
1524
1525 GraphBase::Service * GraphBase::Graph::GetServiceOfMap( char * name ) {
1526   return _MapOfServiceNames[ name ] ;
1527 }
1528
1529 bool GraphBase::Graph::SetServiceOfMap( GraphBase::Service * aService ) {
1530   GraphBase::Service * theService = _MapOfServiceNames[ aService->ServiceName() ] ;
1531   if ( theService ) {
1532     cdebug << "SetServiceOfMap of " << aService->ServiceName()
1533            << " already in MapOfServiceNames : erase" << endl ;
1534     _MapOfServiceNames.erase( aService->ServiceName() ) ;
1535   }
1536   _MapOfServiceNames[ (char * ) aService->ServiceName() ] = aService ;
1537   cdebug << "SetServiceOfMap of " << aService->ServiceName() << " done" << endl ;
1538   return true ;
1539 }
1540
1541 int GraphBase::Graph::GetServiceNameNumber( SALOME_ModuleCatalog::Service aService ) {
1542   GraphBase::Service * theService = _MapOfServiceNames[ (char * ) aService.ServiceName ] ;
1543   if ( theService == NULL ) {
1544     return 1 ;
1545   }
1546   return theService->NewInstance() ;
1547 }
1548
1549 void GraphBase::Graph::SetGraphPorts() {
1550   cdebug_in << "GraphBase::Graph::SetGraphPorts fill ports of Graph" << endl;
1551   int i ;
1552   for ( i = 0 ; i < GetNodeInDataNodePortsSize() ; i++ ) {
1553     GraphBase::OutPort * anOutPort = GetChangeNodeInDataNodePort( i ) ;
1554     cdebug << "SetGraphPorts Out" << i << " " << anOutPort->PortName() << " " << anOutPort->PortType()
1555            << " " << anOutPort->Kind() << " " << anOutPort->PortStatus() << " " << anOutPort->State() << endl ;
1556     if ( !anOutPort->IsGate() ) {
1557       anOutPort->PortStatus( ExternConnected ) ;
1558     }
1559   }
1560   for ( i = 0 ; i < GetNodeOutDataNodePortsSize() ; i++ ) {
1561     GraphBase::InPort * anInPort = GetChangeNodeOutDataNodePort( i ) ;
1562     cdebug << "SetGraphPorts In" << i << " " << anInPort->PortName() << " " << anInPort->PortType()
1563            << " " << anInPort->Kind() << " " << anInPort->PortStatus() << " " << anInPort->State() << endl ;
1564     if ( !anInPort->IsGate() ) {
1565       GraphBase::OutPort * anOutPort = anInPort->GetOutPort() ;
1566       anOutPort->PortStatus( ExternConnected ) ;
1567     }
1568   }
1569   cdebug_out << "GraphBase::Graph::SetGraphPorts" << endl;
1570 }
1571
1572 bool GraphBase::Graph::CreateService() {
1573   cdebug_in << "GraphBase::Graph::CreateService " << Name() << " GraphMacroLevel : " << GraphMacroLevel() << endl;
1574   bool RetVal = true ;
1575   SALOME_ModuleCatalog::Service aService ;
1576   int i , j ;
1577   GraphBase::ComputingNode * aToNode ;
1578   int dostore ;
1579   int innbr = 0 ;
1580   int instreamnbr = 0 ;
1581   int outnbr = 0 ;
1582   int outstreamnbr = 0 ;
1583   vector< SUPERV::KindOfPort > InPortsKind ;
1584   vector< SALOME_ModuleCatalog::DataStreamDependency > InDataStreamDependency ;
1585   vector< SUPERV::KindOfSchema > InKindOfSchema ;
1586   vector< SUPERV::KindOfInterpolation > InKindOfInterpolation ;
1587   vector< SUPERV::KindOfExtrapolation > InKindOfExtrapolation ;
1588   vector< SUPERV::KindOfPort > OutPortsKind ;
1589   vector< SALOME_ModuleCatalog::DataStreamDependency > OutDataStreamDependency ;
1590   vector< long > OutNumberOfValues ;
1591 //  if ( GraphMacroLevel() == 0 ) {
1592     for ( dostore = 0 ; dostore <= 2 ; dostore++ ) {
1593       if ( dostore == 1 ) {
1594         aService.ServiceName = Name() ;
1595         aService.ServiceinParameter.length( 0 ) ;
1596         aService.ServiceinParameter.length( innbr ) ;
1597         aService.ServiceoutParameter.length( 0 ) ;
1598         aService.ServiceoutParameter.length( outnbr ) ;
1599         InPortsKind.resize( innbr ) ;
1600         InDataStreamDependency.resize( innbr ) ;
1601         InKindOfSchema.resize( innbr ) ;
1602         InKindOfInterpolation.resize( innbr ) ;
1603         InKindOfExtrapolation.resize( innbr ) ;
1604         OutPortsKind.resize( outnbr ) ;
1605         OutDataStreamDependency.resize( outnbr ) ;
1606         OutNumberOfValues.resize( outnbr ) ;
1607       }
1608       else if ( dostore == 2 ) {
1609         cdebug << "GraphBase::Graph::CreateService ->DataService innbr " << innbr
1610                << " instreamnbr " << instreamnbr << " outnbr " << outnbr
1611                << " outstreamnbr " << outstreamnbr << endl ;
1612         DataService( _Orb , aService , Graph_prof_debug() , Graph_fdebug() ) ;
1613         aService.ServiceinParameter.length( innbr + instreamnbr ) ;
1614         aService.ServiceoutParameter.length( outnbr + outstreamnbr ) ;
1615         InPortsKind.resize( innbr + instreamnbr ) ;
1616         InDataStreamDependency.resize( innbr + instreamnbr ) ;
1617         InKindOfSchema.resize( innbr + instreamnbr ) ;
1618         InKindOfInterpolation.resize( innbr + instreamnbr ) ;
1619         InKindOfExtrapolation.resize( innbr + instreamnbr ) ;
1620         OutPortsKind.resize( outnbr + outstreamnbr ) ;
1621         OutDataStreamDependency.resize( outnbr + outstreamnbr ) ;
1622         OutNumberOfValues.resize( outnbr + outstreamnbr ) ;
1623       }
1624       if ( dostore == 0 ) {
1625         innbr = 0 ;
1626         instreamnbr = 0 ;
1627         outnbr = 0 ;
1628         outstreamnbr = 0 ;
1629       }
1630       if ( dostore == 1 ) {
1631         innbr = 0 ;
1632         outnbr = 0 ;
1633       }
1634       for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1635         aToNode = GraphNodes( i ) ;
1636         for ( j = 0 ; j < aToNode->GetNodeInPortsSize() ; j++ ) {
1637           GraphBase::InPort *anInPort = aToNode->GetChangeNodeInPort(j) ;
1638           bool isfromcouplednode = false ;
1639           if ( !anInPort->IsNotConnected() ) {
1640             const char * aFromNodeName = anInPort->GetOutPort()->NodeName() ;
1641             GraphBase::ComputingNode * aFromNode = GetChangeGraphNode( aFromNodeName ) ;
1642             cdebug << "GraphBase::Graph::CreateService aFromNodeName " << aFromNodeName << " aToNode "
1643                    << aToNode->Name() << " InPort" << j << " " << anInPort->PortName() << endl ;
1644             if ( aFromNode && aFromNode->IsEndLoopNode() &&
1645                  ((GraphBase::EndOfLoopNode * ) aFromNode)->CoupledNode() == aToNode ) {
1646               isfromcouplednode = true ;
1647             }
1648           }
1649           if ( !anInPort->IsGate() && !anInPort->IsLoop() &&
1650                ( !anInPort->IsPortConnected() ||
1651                  ( anInPort->IsPortConnected() && isfromcouplednode ) ) ) {
1652             if ( dostore == 0 ) {
1653               cdebug << "CreateService " << aToNode->Name() << " Input port "
1654                      << anInPort->PortName() << " " << anInPort->Kind() << " " << anInPort->PortStatus() ;
1655               if ( anInPort->GetOutPort() ) {
1656                 cdebug << "DataConnected from " <<  *(anInPort->GetOutPort() ) ;
1657               }
1658               cdebug << endl ;
1659               if ( anInPort->IsDataStream() ) {
1660                 instreamnbr += 1 ;
1661               }
1662               else {
1663                 innbr += 1 ;
1664               }
1665             }
1666             else if ( ( dostore == 1 && !anInPort->IsDataStream() ) ||
1667                       ( dostore == 2 && anInPort->IsDataStream() ) ) {
1668               aService.ServiceinParameter[innbr].Parametertype = CORBA::string_dup( anInPort->PortType() ) ;
1669               aService.ServiceinParameter[innbr].Parametername = CORBA::string_dup( anInPort->NodePortName() ) ;
1670               InPortsKind[ innbr ] = anInPort->Kind() ;
1671               InDataStreamDependency[ innbr ] = anInPort->Dependency() ;
1672               if ( dostore == 2 && anInPort->IsDataStream() ) {
1673                 ((GraphBase::InDataStreamPort * ) anInPort)->Params( InKindOfSchema[ innbr ] ,
1674                                                                      InKindOfInterpolation[ innbr ] ,
1675                                                                      InKindOfExtrapolation[ innbr ] ) ;
1676               }
1677               cdebug << "In" << innbr << " " << aService.ServiceinParameter[ innbr ].Parametername << " "
1678                      << anInPort->Kind() << " " << anInPort->PortStatus() << endl ;
1679               innbr += 1 ;
1680             }
1681           }
1682           else if ( dostore == 0 ) {
1683             cdebug << "CreateService " << aToNode->Name() << " Input port " << anInPort->PortName()
1684                    << " " << anInPort->PortStatus() ;
1685             if ( anInPort->IsPortConnected() ) {
1686               cdebug << " is connected " ;
1687             }
1688             else {
1689               cdebug << " is NOT connected " ;
1690             }
1691             if ( anInPort->IsGate() ) {
1692               cdebug << " IsGate " ;
1693             }
1694             if ( anInPort->GetOutPort() ) {
1695               cdebug << "DataConnected from " <<  *(anInPort->GetOutPort()) ;
1696             }
1697             else {
1698               cdebug << "NOT DataConnected" ;
1699             }
1700             cdebug << endl ;
1701           }
1702         }
1703         GraphBase::ComputingNode * aFromNode = aToNode ;
1704         for ( j = 0 ; j < aFromNode->GetNodeOutPortsSize() ; j++ ) {
1705           GraphBase::OutPort *anOutPort = aFromNode->GetChangeNodeOutPort(j) ;
1706 //          cdebug << "CreateService Node " << aFromNode->Name() << ". Output port[" << j << "] ";
1707 //          if ( anOutPort ) {
1708 //            cdebug << anOutPort->PortName() << " " << anOutPort->ServicesParameterType() << endl ;
1709 //        }
1710 //          else {
1711 //            cdebug << " NULL" << endl ;
1712 //        }
1713           if ( !aFromNode->IsGOTONode() ) {
1714             if ( !anOutPort->IsGate() && ( anOutPort->IsNotConnected() || anOutPort->IsDataConnected() ) ||
1715                                            anOutPort->IsExternConnected() ) {
1716               if ( dostore == 0 ) {
1717 //                cdebug << "CreateService " << aFromNode->Name() << " Output port "
1718 //                       << anOutPort->PortName() << " " << anOutPort->PortStatus() << endl ;
1719                 if ( anOutPort->IsDataStream() ) {
1720                   outstreamnbr += 1 ;
1721                 }
1722                 else {
1723                   outnbr += 1 ;
1724                 }
1725               }
1726               else if ( ( dostore == 1 && !anOutPort->IsDataStream() ) ||
1727                         ( dostore == 2 && anOutPort->IsDataStream() ) ) {
1728                 aService.ServiceoutParameter[outnbr].Parametertype = CORBA::string_dup( anOutPort->PortType() ) ;
1729                 aService.ServiceoutParameter[outnbr].Parametername = CORBA::string_dup( anOutPort->NodePortName() ) ;
1730                 OutPortsKind[ outnbr ] = anOutPort->Kind() ;
1731                 OutDataStreamDependency[ outnbr ] = anOutPort->Dependency() ;
1732                 if ( dostore == 2 && anOutPort->IsDataStream() ) {
1733                   OutNumberOfValues[ outnbr ] = ((GraphBase::OutDataStreamPort * ) anOutPort)->NumberOfValues() ;
1734                 }
1735 //                cdebug << "Out" << outnbr << " " << aService.ServiceoutParameter[ outnbr ].Parametername << " "
1736 //                       << anOutPort->Kind() << " " << anOutPort->PortStatus() << endl ;
1737                 outnbr += 1 ;
1738               }
1739             }
1740           }
1741         }
1742       }
1743     }
1744 //  }
1745
1746 #if 0
1747   cdebug << "DataFlowNode ServiceName " << aService.ServiceName << " InPorts " << innbr
1748          << " OutPorts " << outnbr << endl ;
1749   for ( i = 0 ; i < innbr ; i++ ) {
1750     cdebug << "aService.ServiceinParameter[" << i << "].Parametertype "
1751          << aService.ServiceinParameter[i].Parametertype << " Parametername "
1752          << aService.ServiceinParameter[i].Parametername << " " << InPortsKind[ i ] << endl ;
1753     if ( InPortsKind[ i ] != SUPERV::DataStreamParameter ) {
1754       cdebug << "NodeInPort[" << i << "] " << *GetChangeNodeInPort( i ) << endl ;
1755     }
1756   }
1757   for ( i = 0 ; i < outnbr ; i++ ) {
1758     cdebug << "aService.ServiceoutParameter[" << i << "].Parametertype "
1759          << aService.ServiceoutParameter[i].Parametertype << " Parametername "
1760          << aService.ServiceoutParameter[i].Parametername << " " << OutPortsKind[ i ] << endl ;
1761     if ( OutPortsKind[ i ] != SUPERV::DataStreamParameter ) {
1762       cdebug << "NodeOutPort[" << i << "] " << *GetChangeNodeOutPort( i ) << endl ;
1763     }
1764   }
1765 #endif
1766
1767 //  DataService( _Orb , aService , InPortsKind , OutPortsKind , Graph_prof_debug() , Graph_fdebug() ) ;
1768   for ( i = 0 ; i < innbr ; i++ ) {
1769     if ( InPortsKind[ i ] == SUPERV::DataStreamParameter ) {
1770       GraphBase::InDataStreamPort * anInPort = AddInDataStreamPort( aService.ServiceinParameter[ i ].Parametername ,
1771                                                                     StringToDataStreamType( aService.ServiceinParameter[ i ].Parametertype ) ,
1772                                                                     InDataStreamDependency[ i ] ,
1773                                                                     SUPERV::DataStreamParameter ) ;
1774       anInPort->SetParams( InKindOfSchema[ i ] ,
1775                            InKindOfInterpolation[ i ] ,
1776                            InKindOfExtrapolation[ i ] ) ;
1777 // NOT A BUG : AddOutPort for an inport (Reversed service)
1778       anInPort = (GraphBase::InDataStreamPort * ) _DataFlowDataPorts->AddOutPort(
1779                                                            _Orb , NamePtr() ,
1780                                                            Kind() ,
1781                                                            aService.ServiceinParameter[ i ].Parametername ,
1782                                                            aService.ServiceinParameter[ i ].Parametertype ,
1783                                                            SUPERV::DataStreamParameter ,
1784                                                            - 1 ,
1785                                                            _Graph_prof_debug , _Graph_fdebug ) ;
1786       anInPort->Dependency( InDataStreamDependency[ i ] ) ;
1787 // Attention : revoir les reversed DataStreamPorts
1788 //      anInPort->SetParams( InKindOfSchema[ i ] ,
1789 //                           InKindOfInterpolation[ i ] ,
1790 //                           InKindOfExtrapolation[ i ] ) ;
1791       cdebug << "InStreamPort " << GetChangeNodeInPort( i )->PortName() << " " << GetChangeNodeInPort( i )->Kind() << endl ;
1792       cdebug << "ReversedInStreamPort " << _DataFlowDataPorts->GetChangeNodeOutPort( i )->PortName() << " " << _DataFlowDataPorts->GetChangeNodeOutPort( i )->Kind()
1793              << endl ;
1794     }
1795     else {
1796       GetChangeNodeInPort( i )->Kind( InPortsKind[ i ] ) ;
1797       _DataFlowDataPorts->GetChangeNodeOutPort( i )->Kind( InPortsKind[ i ] ) ;
1798       GetChangeNodeInPort( i )->Dependency( InDataStreamDependency[ i ] ) ;
1799       _DataFlowDataPorts->GetChangeNodeOutPort( i )->Dependency( InDataStreamDependency[ i ] ) ;
1800       cdebug << "InPort " << GetChangeNodeInPort( i )->PortName() << " " << GetChangeNodeInPort( i )->Kind() << endl ;
1801       cdebug << "ReversedInPort " << _DataFlowDataPorts->GetChangeNodeOutPort( i )->PortName() << " " << _DataFlowDataPorts->GetChangeNodeOutPort( i )->Kind()
1802              << endl ;
1803     }
1804   }
1805   for ( i = 0 ; i < outnbr ; i++ ) {
1806     if ( OutPortsKind[ i ] == SUPERV::DataStreamParameter ) {
1807       GraphBase::OutDataStreamPort * anOutPort = AddOutDataStreamPort( aService.ServiceoutParameter[ i ].Parametername ,
1808                                                                        StringToDataStreamType( aService.ServiceoutParameter[ i ].Parametertype ) ,
1809                                                                        OutDataStreamDependency[ i ] ,
1810                                                                        SUPERV::DataStreamParameter ) ;
1811       anOutPort->NumberOfValues( OutNumberOfValues[ i ] ) ;
1812 // NOT A BUG : AddInPort for an outport (Reversed service)
1813       anOutPort = (GraphBase::OutDataStreamPort * ) _DataFlowDataPorts->AddInPort(
1814                                                              _Orb , NamePtr() ,
1815                                                              Kind() ,
1816                                                              aService.ServiceoutParameter[ i ].Parametername ,
1817                                                              aService.ServiceoutParameter[ i ].Parametertype ,
1818                                                              SUPERV::DataStreamParameter ,
1819                                                              - 1 ,
1820                                                              _Graph_prof_debug , _Graph_fdebug ) ;
1821       anOutPort->Dependency( OutDataStreamDependency[ i ] ) ;
1822 // Attention : revoir les reversed DataStreamPorts
1823 //      anOutPort->NumberOfValues( OutNumberOfValues[ i ] ) ;
1824       cdebug << "OutStreamPort " << GetChangeNodeOutPort( i )->PortName() << " " << GetChangeNodeOutPort( i )->Kind() << endl ;
1825       cdebug << "ReversedOutStreamPort " << _DataFlowDataPorts->GetChangeNodeInPort( i )->PortName() << " " << _DataFlowDataPorts->GetChangeNodeInPort( i )->Kind()
1826              << endl ;
1827     }
1828     else {
1829       GetChangeNodeOutPort( i )->Kind( OutPortsKind[ i ] ) ;
1830       _DataFlowDataPorts->GetChangeNodeInPort( i )->Kind( OutPortsKind[ i ] ) ;
1831       GetChangeNodeOutPort( i )->Dependency( OutDataStreamDependency[ i ] ) ;
1832       _DataFlowDataPorts->GetChangeNodeInPort( i )->Dependency( OutDataStreamDependency[ i ] ) ;
1833       GetChangeNodeOutPort( i )->Dependency( OutDataStreamDependency[ i ] ) ;
1834       _DataFlowDataPorts->GetChangeNodeInPort( i )->Dependency( OutDataStreamDependency[ i ] ) ;
1835       cdebug << "OutPort " << GetChangeNodeOutPort( i )->PortName() << " " << GetChangeNodeOutPort( i )->Kind() << endl ;
1836       cdebug << "ReversedOutPort " << _DataFlowDataPorts->GetChangeNodeInPort( i )->PortName() << " " << _DataFlowDataPorts->GetChangeNodeInPort( i )->Kind()
1837              << endl ;
1838     }
1839   }
1840 // Restore input datas and links :
1841   DataStreamInPortsNumber( 0 ) ;
1842   DataStreamOutPortsNumber( 0 ) ;
1843   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1844     aToNode = GraphNodes( i ) ;
1845     DataStreamInPortsNumber( DataStreamInPortsNumber() + aToNode->DataStreamInPortsNumber() ) ;
1846     DataStreamOutPortsNumber( DataStreamOutPortsNumber() + aToNode->DataStreamOutPortsNumber() ) ;
1847     for ( j = 0 ; j < aToNode->GetNodeInPortsSize() ; j++ ) {
1848       GraphBase::InPort *anInPort = aToNode->GetChangeNodeInPort(j) ;
1849       if ( !anInPort->IsGate() && anInPort->IsDataConnected() ) {
1850         if ( !AddInputData( anInPort->NodeName() ,
1851                             anInPort->PortName() ,
1852                             anInPort->GetOutPort()->ValuePtr() ) ) {
1853           cdebug << "CreateService In" << j << " " << anInPort->NodeName() << "(" << anInPort->PortName() << ") "
1854                  << anInPort->PortStatus() << " --> AddInputData ERROR" << endl ;
1855           RetVal = false ;
1856         }
1857         else {
1858           cdebug << "CreateService In" << j << " " << anInPort->NodeName() << "(" << anInPort->PortName() << ") "
1859                  << anInPort->PortStatus() << " --> AddInputData" << endl ;
1860         }
1861       }
1862       else if ( !anInPort->IsGate() && anInPort->IsNotConnected() ) {
1863         if ( !AddLink( this , GetChangeInDataNodePort( anInPort->NodePortName() ) , aToNode , anInPort ) ) {
1864           cdebug << "CreateService In" << j << " " << anInPort->NodeName() << "(" << anInPort->PortName() << ") "
1865                  << anInPort->PortStatus() << " --> AddInLink ERROR" << endl ;
1866           RetVal = false ;
1867         }
1868         else {
1869           cdebug << "CreateService In" << j << " " << anInPort->NodeName() << "(" << anInPort->PortName() << ") "
1870                  << anInPort->PortStatus() << " --> AddInLink" << endl ;
1871         }
1872       }
1873     }
1874     for ( j = 0 ; j < aToNode->GetNodeOutPortsSize() ; j++ ) {
1875       GraphBase::OutPort *anOutPort = aToNode->GetChangeNodeOutPort(j) ;
1876       cdebug << "CreateService Out" << j << " " << anOutPort->NodeName() << "(" << anOutPort->PortName()
1877              << ") " << anOutPort->PortStatus() << " :" << endl ;
1878       if ( !anOutPort->IsGate() && anOutPort->IsNotConnected() && !aToNode->IsGOTONode() ) {
1879         GraphBase::InPort *anInPort = GetChangeOutDataNodePort( anOutPort->NodePortName() ) ;
1880         if ( !AddLink( aToNode , anOutPort , this , anInPort ) ) {
1881           cdebug << "       --> " << Name() << "(" << anInPort->PortName()
1882                  << ") " << anInPort->PortStatus() << " AddOutLink ERROR" << endl ;
1883           RetVal = false ;
1884         }
1885         else {
1886           cdebug << "       --> " << Name() << "(" << anInPort->PortName()
1887                  << ") " << anInPort->PortStatus() << " AddOutLink" << endl ;
1888         }
1889       }
1890     }
1891   }
1892
1893   cdebug_out << "GraphBase::Graph::CreateService " << RetVal << endl;
1894   return RetVal ;
1895 }
1896
1897 bool GraphBase::Graph::InLineServices() {
1898   cdebug_in << "GraphBase::Graph::InLineServices" << endl;
1899
1900   int i , j ;
1901
1902 #ifdef _DEBUG_
1903   ListPorts( *_Graph_fdebug , 0 ) ;
1904 #endif
1905
1906   GraphBase::InLineNode * aINode ;
1907   SALOME_ModuleCatalog::Service aService ;
1908   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
1909     aINode = (GraphBase::InLineNode * ) GraphNodes( i ) ;
1910     if ( aINode->IsOneOfInLineNodes() ) {
1911 //      cdebug << "GraphBase::Graph::InLineServices " << aINode->Name() << endl;
1912       aService.ServiceName = aINode->ServiceName() ;
1913       aService.ServiceinParameter.length( 0 ) ;
1914       aService.ServiceoutParameter.length( 0 ) ;
1915       aINode->DataStreamInPortsNumber( 0 ) ;
1916       aINode->DataStreamOutPortsNumber( 0 ) ;
1917       int InService = 0 ;
1918       int InStreamService = 0 ;
1919       for ( j = 0 ; j < aINode->GetNodeInPortsSize() ; j++ ) {
1920         if ( aINode->GetChangeNodeInPort(j)->IsGate() || aINode->GetChangeNodeInPort(j)->IsLoop() ) {
1921 #if 0
1922           cdebug << "GraphBase::Graph::InLineServices In" << j << " "
1923                  << aINode->GetChangeNodeInPort(j)->Kind() << " "
1924                  << aINode->GetChangeNodeInPort(j)->PortType() << " "
1925                  << aINode->GetChangeNodeInPort(j)->PortName() << " ignored "
1926                  << aINode->GetChangeNodeInPort(j)->IsGate() << " "
1927                  << aINode->GetChangeNodeInPort(j)->IsLoop() << endl;
1928 #endif
1929         }
1930         else if ( aINode->GetChangeNodeInPort(j)->IsDataStream() ) {
1931           aService.ServiceinDataStreamParameter.length( InStreamService+1 ) ;
1932           aService.ServiceinDataStreamParameter[InStreamService].Parametertype = StringToDataStreamType( aINode->GetChangeNodeInPort(j)->PortType() ) ;
1933           aService.ServiceinDataStreamParameter[InStreamService].Parametername = CORBA::string_dup( aINode->GetChangeNodeInPort(j)->PortName() ) ;
1934           aService.ServiceinDataStreamParameter[InStreamService++].Parameterdependency = aINode->GetChangeNodeInPort(j)->Dependency() ;
1935           aINode->IncrDataStreamInPorts() ;
1936 #if 0
1937           cdebug << "GraphBase::Graph::InLineServices In" << j << " "
1938                  << aINode->GetChangeNodeInPort(j)->Kind() << " "
1939                  << aINode->GetChangeNodeInPort(j)->PortType() << " "
1940                  << aINode->GetChangeNodeInPort(j)->PortName() << " "
1941                  << aINode->GetChangeNodeInPort(j)->IsGate() << " "
1942                  << aINode->GetChangeNodeInPort(j)->IsLoop() << endl;
1943 #endif
1944         }
1945         else {
1946           aService.ServiceinParameter.length( InService+1 ) ;
1947           aService.ServiceinParameter[InService].Parametertype = CORBA::string_dup( aINode->GetChangeNodeInPort(j)->PortType() ) ;
1948           aService.ServiceinParameter[InService++].Parametername = CORBA::string_dup( aINode->GetChangeNodeInPort(j)->PortName() ) ;
1949 #if 0
1950           cdebug << "GraphBase::Graph::InLineServices In" << j << " "
1951                  << aINode->GetChangeNodeInPort(j)->Kind() << " "
1952                  << aINode->GetChangeNodeInPort(j)->PortType() << " "
1953                  << aINode->GetChangeNodeInPort(j)->PortName() << " "
1954                  << aINode->GetChangeNodeInPort(j)->IsGate() << " "
1955                  << aINode->GetChangeNodeInPort(j)->IsLoop() << endl;
1956 #endif
1957         }
1958       }
1959       int OutService = 0 ;
1960       int OutStreamService = 0 ;
1961       for ( j = 0 ; j < aINode->GetNodeOutPortsSize() ; j++ ) {
1962 //        if ( aINode->GetChangeNodeOutPort(j)->IsGate() || aINode->GetChangeNodeOutPort(j)->IsLoop() || aINode->GetChangeNodeOutPort(j)->IsDataStream() ) {
1963         if ( aINode->GetChangeNodeOutPort(j)->IsGate() || aINode->GetChangeNodeOutPort(j)->IsLoop() ) {
1964 #if 0
1965           cdebug << "GraphBase::Graph::InLineServices Out" << j << " "
1966                  << aINode->GetChangeNodeOutPort(j)->Kind() << " "
1967                  << aINode->GetChangeNodeOutPort(j)->PortType() << " "
1968                  << aINode->GetChangeNodeOutPort(j)->PortName() << " ignored "
1969                  << aINode->GetChangeNodeOutPort(j)->IsGate() << " "
1970                  << aINode->GetChangeNodeOutPort(j)->IsLoop() << endl;
1971 #endif
1972         }
1973         else if ( aINode->GetChangeNodeOutPort(j)->IsDataStream() ) {
1974           aService.ServiceoutDataStreamParameter.length( OutStreamService+1 ) ;
1975           aService.ServiceoutDataStreamParameter[OutStreamService].Parametertype = StringToDataStreamType( aINode->GetChangeNodeOutPort(j)->PortType() ) ;
1976           aService.ServiceoutDataStreamParameter[OutStreamService].Parametername = CORBA::string_dup( aINode->GetChangeNodeOutPort(j)->PortName() ) ;
1977           aService.ServiceoutDataStreamParameter[OutStreamService++].Parameterdependency = aINode->GetChangeNodeOutPort(j)->Dependency() ;
1978           aINode->IncrDataStreamOutPorts() ;
1979 #if 0
1980           cdebug << "GraphBase::Graph::InLineServices Out" << j << " "
1981                  << aINode->GetChangeNodeOutPort(j)->Kind() << " "
1982                  << aINode->GetChangeNodeOutPort(j)->PortType() << " "
1983                  << aINode->GetChangeNodeOutPort(j)->PortName() << " "
1984                  << aINode->GetChangeNodeOutPort(j)->IsGate() << " "
1985                  << aINode->GetChangeNodeOutPort(j)->IsLoop() << endl;
1986 #endif
1987         }
1988         else {
1989           aService.ServiceoutParameter.length( OutService+1 ) ;
1990           aService.ServiceoutParameter[OutService].Parametertype = CORBA::string_dup( aINode->GetChangeNodeOutPort(j)->PortType() ) ;
1991           aService.ServiceoutParameter[OutService++].Parametername = CORBA::string_dup( aINode->GetChangeNodeOutPort(j)->PortName() ) ;
1992 #if 0
1993           cdebug << "GraphBase::Graph::InLineServices Out" << j << " "
1994                  << aINode->GetChangeNodeOutPort(j)->Kind() << " "
1995                  << aINode->GetChangeNodeOutPort(j)->PortType() << " "
1996                  << aINode->GetChangeNodeOutPort(j)->PortName()  << " "
1997                  << aINode->GetChangeNodeOutPort(j)->IsGate() << " "
1998                  << aINode->GetChangeNodeOutPort(j)->IsLoop() << endl;
1999 #endif
2000         }
2001       }
2002       aINode->SetService( aService ) ;
2003       if ( SetServiceOfMap( (GraphBase::Service * ) aINode ) ) {
2004 #if 0
2005         cdebug << "InLineServices SetServiceOfMap " << aINode->ServiceName() << " in MapOfServices"
2006                << " InStreamPort(" << aINode->DataStreamInPortsNumber()
2007                << ") OutStreamPort(" << aINode->DataStreamOutPortsNumber() << ")" << endl ;
2008 #endif
2009       }
2010 //      cdebug << "GraphBase::Graph::InLineServices" << *aINode->GetService() << endl;
2011     }
2012   }
2013
2014   cdebug_out << "GraphBase::Graph::InLineServices" << endl;
2015   return true ;
2016 }
2017
2018 bool GraphBase::Graph::Sort( int & SubStreamGraphsNumber ) {
2019   int i ;
2020   int j ;
2021   int NotSortedNumber = GraphNodesSize() ;
2022   bool NewSorted ;
2023   cdebug_in << "GraphBase::Graph::Sort" << endl;
2024   if ( NotSortedNumber ) {
2025     _LevelsNumber = 0 ;
2026     _ParallelExecutionNodes = false ;
2027     _Sorted.resize( GraphNodesSize() ) ;
2028     _CnxInPortsNumber.resize( GraphNodesSize() ) ;
2029     _DecrInPortsNumber.resize( GraphNodesSize() ) ;
2030     if ( _NodesNumber.size() ) {
2031       _NodesNumber.resize( 0 ) ;
2032       _SortedNodes.resize( 0 ) ;
2033     }
2034
2035 // This is a simulation of the computation of the graph :
2036 // The initial state of nodes is :
2037 // - Sorted = false : the node is not sorted
2038 // - CnxInPortsNumber = ConnectedInPortsNumber : the number of ports that wait for a value from a link
2039 // - DecrInPortsNumber = 0 : there is no value available.
2040 #if 0
2041     cdebug << "GraphBase::Graph::Sort initial values :" << endl ;
2042     for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2043       GraphBase::ComputingNode * aNode = GraphNodes( i ) ;
2044       cdebug << aNode->Name() << " --> " << aNode->LinkedNodesSize() << " LinkedNodes :" << endl ;
2045       for ( j = 0 ; j < aNode->LinkedNodesSize()  ; j++ ) {
2046         cdebug << "              " << aNode->LinkedNodes( j )->Name() << endl ;
2047       }
2048     }
2049 #endif
2050     for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2051       _Sorted[ i ] = false ;
2052       _CnxInPortsNumber[ i ] = GraphNodes( i )->ConnectedInPortsNumber() ;
2053       _DecrInPortsNumber[ i ] = 0 ;
2054 //      cdebug << "Sort Node [" << i << "] " << GraphNodes( i )->Name() << " initial count "
2055 //             << _CnxInPortsNumber[ i ] << endl ;
2056     }
2057
2058 // Nodes are linked ONLY if Ports are NOT DataStream for topological sort of node
2059 // ==============================================================================
2060     while ( NotSortedNumber ) {
2061       NewSorted = false ;
2062
2063       for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2064         cdebug << "Sort level " << _LevelsNumber << ". [" << i << "] "
2065                << GraphNodes( i )->Name() << " count "
2066                << _CnxInPortsNumber[ i ] << endl ;
2067         if ( !_Sorted[ i ] && _CnxInPortsNumber[ i ] == 0 ) {
2068 // All inputs of GraphNodes( i ) are available : "AllDataReady"
2069           if ( (int ) _NodesNumber.size() != _LevelsNumber+1 ) {
2070             _NodesNumber.resize( _LevelsNumber+1 ) ;
2071             _SortedNodes.resize( _LevelsNumber+1 ) ;
2072             _NodesNumber[ _LevelsNumber ] = -1 ;
2073           }
2074 // There is one more node at that level
2075           _NodesNumber[ _LevelsNumber ]++ ;
2076           (_SortedNodes[ _LevelsNumber ]).resize( _NodesNumber[ _LevelsNumber ]+1 ) ;
2077           (_SortedNodes[ _LevelsNumber ])[ _NodesNumber[ _LevelsNumber ] ] = GraphNodes( i ) ;
2078           _Sorted[ i ] = true ;
2079           NewSorted = true ;
2080           NotSortedNumber -= 1 ;
2081           cdebug << GraphNodes( i )->Name() << " belongs to level "
2082                  << _LevelsNumber << ". " << GraphNodes( i )->LinkedNodesSize() << " linkednodes" << endl ;
2083 // GraphNodes( i ) has the state "AllDataReady". We simulate the end of its execution :
2084 // So we loop over all nodes that have a link from that node
2085 // And we increment the number of input ports of GraphNodes( i )->LinkedNodes( j ) that this
2086 // execution will give a value in DecrInPortsNumber : "SomeDataReady"
2087           for ( j = 0 ; j < GraphNodes( i )->LinkedNodesSize() ; j++ ) {
2088 // OutputPorts of GraphNodes( i ) will satisfy
2089 //   GraphNodes( i )->LinkedInPortsNumber( j ) InPorts of
2090 //      GraphNodes( i )->LinkedNodes( j )
2091             GraphBase::StreamNode * aLinkedNode = GraphNodes( i )->LinkedNodes( j ) ;
2092             int aLinkedInPortsNumber = GraphNodes( i )->LinkedInPortsNumber( j ) ;
2093             cdebug << j << ". LinkedNode " << aLinkedNode->Name() ;
2094             if ( !aLinkedNode->IsDataFlowNode() && !aLinkedNode->IsDataStreamNode() ) {
2095               cdebug << " _DecrInPortsNumber[ "
2096                      << GetGraphNodeIndex( aLinkedNode->Name() )
2097                      << " ] = "
2098                      << _DecrInPortsNumber[ GetGraphNodeIndex( aLinkedNode->Name() ) ]
2099                      << " += " << aLinkedInPortsNumber ;
2100               _DecrInPortsNumber[ GetGraphNodeIndex( aLinkedNode->Name() ) ] += aLinkedInPortsNumber ;
2101             }
2102             cdebug << endl ;
2103           }
2104         }
2105       }
2106 // If no node was found, that FlowGraph is not valid : if we try to execute it, that FlowGraph
2107 // will wait for data(s) from node(s) not executed or not executing for ever
2108       if ( !NewSorted ) {
2109         cdebug << "Loop detected level " << _LevelsNumber << endl ;
2110         return false ; // Loop in the Graph
2111       }
2112 //      cdebug << "Bilan level " << _LevelsNumber << " : " << endl ;
2113       bool ChangeCount = false ;
2114 // We update now the number of InPorts with a link that are waiting for a value
2115       for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2116         if ( _DecrInPortsNumber[ i ] ) {
2117 //          int prevcount = _CnxInPortsNumber[ i ] ;
2118           _CnxInPortsNumber[ i ] -= _DecrInPortsNumber[ i ]  ;
2119           _DecrInPortsNumber[ i ] = 0 ;
2120           ChangeCount = true ;
2121 //          cdebug << "    " << GraphNodes( i )->Name() << " count " << prevcount
2122 //                 << " --> new count " << _CnxInPortsNumber[ i ] << endl ;
2123         }
2124       }
2125 // If there is no loop and if the number of InPorts with a link that are waiting for a value
2126 // does not change, the sort is finished. But there is also NotSortedNumber ...
2127 //      if ( !ChangeCount )
2128 //        break ;
2129       if ( NotSortedNumber ) {
2130         _LevelsNumber += 1 ;
2131       }
2132     }
2133     _ThreadsMax = 0 ;
2134     int AllSortedNodes = 0 ;
2135     _HeadNodes = _SortedNodes[ 0 ] ;
2136     _HeadNodesSize = _SortedNodes[ 0 ].size() ;
2137 // QueueNodes was used in the past in order to know if the execution of a graph is finished
2138 // But because of loop nodes that was changed. So that part of code is a "clutter"
2139 // Now a graph has finished its execution when the number of executing threads is zero
2140     _QueueNodes = _SortedNodes[ _LevelsNumber ] ;
2141     _QueueNodesSize = _SortedNodes[ _LevelsNumber ].size() ;
2142     for ( i = 0 ; i < _QueueNodesSize ; i++ ) {
2143       if ( !_QueueNodes[ i ]->IsGOTONode() ) {
2144         break ;
2145       }
2146     }
2147     if ( i == _QueueNodesSize && _LevelsNumber ) {
2148       _QueueNodes = _SortedNodes[ _LevelsNumber - 1 ] ;
2149       _QueueNodesSize = _SortedNodes[ _LevelsNumber - 1 ].size() ;
2150     }
2151 // Computation of the maximum number of threads == the maximum number of nodes of all levels
2152     for ( i = 0 ; i <= _LevelsNumber ; i++ ) {
2153       AllSortedNodes += _NodesNumber[ i ]+1 ;
2154       if ( _NodesNumber[ i ] + 1 > _ThreadsMax ) {
2155         _ThreadsMax = _NodesNumber[ i ] + 1 ;
2156       }
2157       cdebug << _NodesNumber[ i ]+1 << " Nodes of level " << i << " : "
2158              << (_SortedNodes[ i ])[ 0 ]->Name() << endl ;
2159       for ( j = 1 ; j <= _NodesNumber[ i ] ; j++ ) {
2160         _ParallelExecutionNodes = true ;
2161         cdebug << "                     " << (_SortedNodes[ i ])[ j ]->Name()
2162                << endl ;
2163       }
2164     }
2165     if ( _ParallelExecutionNodes ) {
2166 //      cdebug << "Parallel Execution Nodes detected." << endl ;
2167     }
2168     else {
2169 //      cdebug << "No Parallel Execution Nodes detected." << endl ;
2170     }
2171     if ( AllSortedNodes != GraphNodesSize() ) {
2172       cdebug << "Loop detected level " << _LevelsNumber << endl ;
2173       return false ; // Loop in the Graph
2174     }
2175
2176     for ( i= 0 ; i <= _NodesNumber[ 0 ] ; i++ ) {
2177       (_SortedNodes[ 0 ])[ i ]->HeadNode( true ) ;
2178     }
2179
2180 // Give a subgraph/substreamgraph number > 0 to HeadNodes (level 0)
2181 // There is no substreamgraph for nodes without StreamPorts
2182     for ( j = 0 ; j <= _NodesNumber[ 0 ] ; j++ ) {
2183       (_SortedNodes[ 0 ])[ j ]->Level( 0 ) ;
2184       (_SortedNodes[ 0 ])[ j ]->SortedIndex( j ) ;
2185       (_SortedNodes[ 0 ])[ j ]->SubGraph( j + 1 ) ;
2186       if ( (_SortedNodes[ 0 ])[ j ]->HasDataStream() ) {
2187         (_SortedNodes[ 0 ])[ j ]->SubStreamGraph( j + 1 ) ;
2188       }
2189       else {
2190         (_SortedNodes[ 0 ])[ j ]->SubStreamGraph( -1 ) ;
2191       }
2192     }
2193
2194 // Give a subgraph/substreamgraph number = 0 to all other nodes :
2195 // the SubGraph of that nodes is unknown
2196 // There is no substreamgraph for nodes without StreamPorts
2197     for ( i = 1 ; i <= _LevelsNumber ; i++ ) {
2198       for ( j = 0 ; j <= _NodesNumber[ i ] ; j++ ) {
2199         (_SortedNodes[ i ])[ j ]->Level( i ) ;
2200         (_SortedNodes[ i ])[ j ]->SortedIndex( j ) ;
2201         (_SortedNodes[ i ])[ j ]->SubGraph( 0 ) ;
2202         if ( (_SortedNodes[ i ])[ j ]->HasDataStream() ) {
2203           (_SortedNodes[ i ])[ j ]->SubStreamGraph( 0 ) ;
2204         }
2205         else {
2206           (_SortedNodes[ i ])[ j ]->SubStreamGraph( -1 ) ;
2207         }
2208       }
2209     }
2210
2211 // Computation of independent SubGraphs which have NO link between them
2212     cdebug << endl << "Computation of SubGraphs" << endl ;
2213     bool Graphs = true ;
2214     while ( Graphs ) {
2215       for ( i = 0 ; i <= _LevelsNumber ; i++ ) {
2216         cdebug << endl << "LevelsNumber " << _LevelsNumber << " " << _NodesNumber[ i ]
2217                << " Nodes :" << endl ;
2218         for ( j = 0 ; j <= _NodesNumber[ i ] ; j++ ) {
2219           GraphBase::ComputingNode * aNode = (_SortedNodes[ i ])[ j ] ;
2220           cdebug << "    " << aNode->Name() << " SubGraph " << aNode->SubGraph() << endl ;
2221           int k ;
2222           for ( k = 0 ; k < aNode->LinkedNodesSize() ; k++ ) {
2223           if ( aNode->LinkedNodes( k )->SubGraph() ) {
2224               if ( aNode->LinkedNodes( k )->SubGraph() != aNode->SubGraph() ) {
2225 //                   && aNode->LinkedNodes( k )->Level() == aNode->Level()+1 ) {
2226 //            aNode->SubGraph( aNode->LinkedNodes( k )->SubGraph() ) ;
2227                 int OldSub = aNode->SubGraph() ;
2228                 int NewSub = aNode->LinkedNodes( k )->SubGraph() ;
2229               cdebug << "        " << aNode->Name() << " changed SubGraph "
2230                        << aNode->LinkedNodes( k )->SubGraph() << endl ;
2231                 int l ;
2232                 for ( l = 0 ; l <= _LevelsNumber ; l++ ) {
2233                   int m ;
2234                   for ( m = 0 ; m <= _NodesNumber[ l ] ; m++ ) {
2235                     if ( (_SortedNodes[ l ])[ m ]->SubGraph() == OldSub ) {
2236                       GraphBase::ComputingNode * aSubNode = (_SortedNodes[ l ])[ m ] ;
2237                       aSubNode->SubGraph( NewSub ) ;
2238                 }
2239                 }
2240               }
2241                 Graphs = false ;
2242                 break ;
2243             }
2244               else {
2245                 cdebug << "        Linked " << aNode->LinkedNodes( k )->Name()
2246                        << " same SubGraph " << aNode->LinkedNodes( k )->SubGraph() << endl ;
2247             }
2248           }
2249             else {
2250               cdebug << "        LinkedNode " << aNode->LinkedNodes( k )->Name()
2251                      << " initial SubGraph " << aNode->SubGraph() << endl ;
2252               aNode->LinkedNodes( k )->SubGraph( aNode->SubGraph() ) ;
2253           }
2254         }
2255           if ( !Graphs ) {
2256             break ;
2257           }
2258         }
2259         if ( !Graphs ) {
2260           break ;
2261         }
2262       }
2263       if ( Graphs ) {
2264         cdebug << endl << "SubGraphs result : " << endl ;
2265         break ;
2266       }
2267       cdebug << endl << "One more time" << endl ;
2268       Graphs = true ;
2269     }
2270 // Make a sequential renumbering of SubGraphs :
2271     _SubGraphsNumber = 0 ;
2272     int CurrGraphsNumber = 0;
2273     int k ;
2274     for ( k = 0 ; k <= _NodesNumber[ 0 ] ; k++ ) {
2275       if ( (_SortedNodes[ 0 ])[ k ]->SubGraph() > CurrGraphsNumber ) {
2276         CurrGraphsNumber = (_SortedNodes[ 0 ])[ k ]->SubGraph() ;
2277         _SubGraphsNumber += 1 ;
2278         for ( i = 0 ; i <= _LevelsNumber ; i++ ) {
2279           for ( j = 0 ; j <= _NodesNumber[ i ] ; j++ ) {
2280             if ( (_SortedNodes[ i ])[ j ]->SubGraph() == CurrGraphsNumber ) {
2281               (_SortedNodes[ i ])[ j ]->SubGraph( _SubGraphsNumber ) ;
2282               cdebug << "SubGraphsNumber " << _SubGraphsNumber << " " << " Level "
2283                      << i << " : " << (_SortedNodes[ i ])[ j ]->Name()
2284                      << endl ;
2285             }
2286           }
2287         }
2288       }
2289     }
2290
2291 //    cdebug << endl << "Computation of SubStreamGraphs" << endl ;
2292     for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2293       GraphBase::ComputingNode * aNode = GraphNodes( i ) ;
2294       if ( aNode->SubStreamGraph() < 0 ) {
2295 //      cdebug << "Graph " << aNode->Name() << " has NO streamport" << endl ;
2296       }
2297       else {
2298 //        cdebug << aNode->Name() << " SubGraph " << aNode->SubGraph() << " --> "
2299 //               << aNode->LinkedStreamNodesSize() << " LinkedStreamNodes :" << endl ;
2300         for ( j = 0 ; j < aNode->LinkedStreamNodesSize()  ; j++ ) {
2301 //          cdebug << "              " << aNode->LinkedStreamNodes( j )->Name() << endl ;
2302         }
2303       }
2304     }
2305
2306 // Computation of independent SubStreamGraphs which have NO StreamLink between them
2307     SubStreamGraphsNumber = 0 ;
2308     int ilevel ;
2309     for ( ilevel = 0 ; ilevel <= _LevelsNumber ; ilevel++ ) {
2310 // Loop for _NodesNumber[ ilevel ] nodes of the level ilevel
2311       int jnode ;
2312       for ( jnode = 0 ; jnode <= _NodesNumber[ ilevel ] ; jnode++ ) {
2313         GraphBase::ComputingNode * aNode = (_SortedNodes[ ilevel ])[ jnode ] ;
2314         if ( aNode->SubStreamGraph() < 0 ) {
2315 //        cdebug << "Graph " << aNode->SubStreamGraph() << " " << aNode->Name()
2316 //                 << " has NO streamport" << endl ;
2317         }
2318         else {
2319           int CurStreamGraphsNumber ;
2320           if ( aNode->SubStreamGraph() > 0 ) {
2321 //          cdebug << "SubStreamGraph " << aNode->SubStreamGraph() << " " << aNode->Name()
2322 //                   << " has streamport LinkedStreamNodesSize already in a SubStreamGraph" << endl ;
2323             CurStreamGraphsNumber = aNode->SubStreamGraph() ;
2324           }
2325           else {
2326             CurStreamGraphsNumber = SubStreamGraphsNumber+1 ;
2327           }
2328           int RetVal = 0 ;
2329           while ( RetVal != CurStreamGraphsNumber ) {
2330             RetVal = CurStreamGraphsNumber ;
2331             aNode->SetSubStreamGraph( CurStreamGraphsNumber , RetVal ) ;
2332             if ( RetVal != CurStreamGraphsNumber ) {
2333               for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2334                 GraphBase::ComputingNode * aNode = GraphNodes( i ) ;
2335                 if ( aNode->SubStreamGraph() == CurStreamGraphsNumber ) {
2336                   aNode->SubStreamGraph( RetVal ) ;
2337                 }
2338               }
2339               CurStreamGraphsNumber = RetVal ;
2340               RetVal = 0 ;
2341             }
2342             if ( CurStreamGraphsNumber > SubStreamGraphsNumber ) {
2343               SubStreamGraphsNumber = CurStreamGraphsNumber ;
2344             }
2345           }
2346         }
2347       }
2348     }
2349 // Make a sequential renumbering of SubGraphs :
2350 //    cdebug << endl << "Last SubStreamGraphsNumber : " << SubStreamGraphsNumber << endl ;
2351     int CurrStreamGraphsNumber = 0 ;
2352     int count = 0 ;
2353     for ( CurrStreamGraphsNumber = 0 ; CurrStreamGraphsNumber <= SubStreamGraphsNumber ; CurrStreamGraphsNumber++ ) {
2354       bool SearchCurrStreamGraphsNumber = true ;
2355       for ( k = 0 ; k <= _LevelsNumber && SearchCurrStreamGraphsNumber ; k++ ) {
2356         int l ;
2357         for ( l = 0 ; l <= _NodesNumber[ k ] && SearchCurrStreamGraphsNumber ; l++ ) {
2358           if ( (_SortedNodes[ k ])[ l ]->SubStreamGraph() == CurrStreamGraphsNumber ) {
2359             SearchCurrStreamGraphsNumber = false ;
2360             count = count + 1 ;
2361             if ( CurrStreamGraphsNumber != count ) {
2362 //              cdebug << "CurrStreamGraphsNumber " << CurrStreamGraphsNumber << " count " << count
2363 //                     << " Level " << k << " n " << l << endl ;
2364               for ( i = k ; i <= _LevelsNumber ; i++ ) {
2365                 for ( j = 0 ; j <= _NodesNumber[ i ] ; j++ ) {
2366                   if ( (_SortedNodes[ i ])[ j ]->SubStreamGraph() == CurrStreamGraphsNumber ) {
2367                     (_SortedNodes[ i ])[ j ]->SubStreamGraph( count ) ;
2368 //                    cdebug << "SubStreamGraphsNumber " << CurrStreamGraphsNumber << " --> " << count << " "
2369 //                           << " Level " << i << " : " << (_SortedNodes[ i ])[ j ]->Name() << endl ;
2370                   }
2371                   else if ( (_SortedNodes[ i ])[ j ]->SubStreamGraph() > 0 ) {
2372 //                    cdebug << "SubStreamGraphsNumber " << (_SortedNodes[ i ])[ j ]->SubStreamGraph()
2373 //                           << " != " << CurrStreamGraphsNumber << " Level " << i << " : "
2374 //                           << (_SortedNodes[ i ])[ j ]->Name() << endl ;
2375                   }
2376                 }
2377               }
2378             }
2379           }
2380         }
2381       }
2382     }
2383     SubStreamGraphsNumber = count ;
2384 //    cdebug << endl << "SubStreamGraphs result : " << SubStreamGraphsNumber << " SubStreamGraphs" << endl ;
2385 //    int CurrStreamGraphsNumber ;
2386 //    for ( CurrStreamGraphsNumber = 1 ; CurrStreamGraphsNumber <= SubStreamGraphsNumber  ; CurrStreamGraphsNumber++ ) {
2387 //      for ( ilevel = 0 ; ilevel <= _LevelsNumber ; ilevel++ ) {
2388 //        for ( k = 0 ; k <= _NodesNumber[ ilevel ] ; k++ ) {
2389 //          if ( (_SortedNodes[ ilevel ])[ k ]->SubStreamGraph() == CurrStreamGraphsNumber ) {
2390 //            cdebug << "SubStreamGraphsNumber " << CurrStreamGraphsNumber << " : "
2391 //                   << (_SortedNodes[ ilevel ])[ k ]->Name() << endl ;
2392 //        }
2393 //      }
2394 //      }
2395 //    }
2396   }
2397
2398 #ifdef _DEBUG_
2399   ListPorts( *_Graph_fdebug , 0 ) ;
2400 #endif
2401
2402   cdebug_out << "GraphBase::Graph::Sort" << endl;
2403   return true ;
2404 }
2405
2406 bool GraphBase::Graph::ValidLoops() const {
2407   cdebug_in << "GraphBase::Graph::ValidLoops" << endl;
2408
2409   int i ;
2410   GraphBase::ComputingNode * aNode ;
2411   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2412     aNode = GraphNodes( i ) ;
2413     if ( aNode->IsLoopNode() ) {
2414       GraphBase::LoopNode * aLoopNode = (GraphBase::LoopNode * ) aNode ;
2415       GraphBase::EndOfLoopNode * anEndLoopNode ;
2416       anEndLoopNode = (GraphBase::EndOfLoopNode * ) aLoopNode->CoupledNode() ;
2417       if ( !aLoopNode->CheckLoop( aLoopNode , anEndLoopNode ) ) {
2418         cdebug_out << "GraphBase::Graph::ValidLoops false aLoopNode " << aLoopNode->Name()
2419                    << endl;
2420         return false ;
2421       }
2422       else if ( !anEndLoopNode->CheckEndLoop( aLoopNode , anEndLoopNode ) ) {
2423         cdebug_out << "GraphBase::Graph::ValidLoops false anEndLoopNode " << anEndLoopNode->Name()
2424                    << endl;
2425         return false ;
2426       }
2427     }
2428   }
2429   cdebug_out << "GraphBase::Graph::ValidLoops true" << endl;
2430   return true ;
2431 }
2432
2433 // Controle de la coherence des noeuds de calcul
2434 // Enregistrement dans la liste des noeuds "tete" de graphe
2435
2436 bool GraphBase::Graph::ComputingNodes() const {
2437   bool RetVal = true ;
2438   cdebug << "GraphExecutor::GraphControl::ComputingNodes ()" << endl;
2439
2440 //  list<GraphEditor::Node *> aComputingNodesList = _G->ComputingNodesList() ;
2441 //  list<GraphEditor::Node *>::iterator aNode = aComputingNodesList.begin();
2442 //  GraphEditor::Port *  iP;
2443
2444 //  for (aNode = _G->ComputingNodesList().begin(); aNode !=_G->ComputingNodesList().end(); aNode++) {
2445 //  while ( aNode != aComputingNodesList.end() ) {
2446   int i ;
2447   GraphBase::ComputingNode * aNode ;
2448   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2449     aNode = GraphNodes( i ) ;
2450     // Tous les ports d'entree de tous les noeuds de calcul sont bien connectes
2451     // Enregistrement eventuel dans la liste des noeuds "tete" de graphe
2452 //    if ((*aNode)->GetNodeInPortsSize() == 0)
2453 //      _headNodes.push_front(*aNode);
2454     int j ;
2455     for ( j = 1 ; j < aNode->GetNodeInPortsSize() ; j++ ) {
2456       const GraphBase::InPort *iP = aNode->GetNodeInPort(j);
2457       if ( iP->IsNotConnected() ){
2458 //      cdebug << "Le port d'entree " << iP->PortName()
2459 //               << " du noeud de calcul " << aNode->Name() << " du graphe  "
2460 //               << Name() << " n'est pas connecte "<< endl;
2461         RetVal = false ;
2462       };
2463
2464     };
2465
2466     // Tous les noeuds de calcul ont au moins un port de sortie connecte
2467     bool oneOutPortConnected = false;
2468     for ( j = 1 ; j < aNode->GetNodeOutPortsSize() ; j++) {
2469       const GraphBase::OutPort *iP = aNode->GetNodeOutPort(j);
2470       if ( iP->IsPortConnected() || iP->IsDataConnected() ){
2471         oneOutPortConnected = true ;
2472 //      break;
2473       }
2474       else {
2475 //      cdebug << "Le port de sortie " << iP->PortName()
2476 //               << " du noeud de calcul " << aNode->Name() << " du graphe  "
2477 //               << Name() << " n'est pas connecte "<< endl;
2478         RetVal = false ;
2479       }
2480     };
2481     if (!oneOutPortConnected) {
2482 //      cdebug << "Le noeud de calcul " << aNode->Name() << " du graphe  "
2483 //               << Name() << " n'a aucun port de sortie connecte "<< endl;
2484 //      _computingError.push_front(2);
2485     }
2486   };
2487 //  return _computingError.size () ;
2488   return RetVal ;
2489 }
2490
2491 bool GraphBase::Graph::LinkLoopNodes(bool & NewLink ) {
2492   bool RetVal = true ;
2493   NewLink = false ;
2494   int i , j ;
2495   cdebug_in << "GraphBase::Graph::LinkLoopNodes()" << endl;
2496   for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2497     GraphBase::ComputingNode * aNode = GraphNodes( i ) ;
2498     if ( aNode->IsLoopNode() ) {
2499       GraphBase::LoopNode * aLoopNode = (GraphBase::LoopNode * ) aNode ;
2500       for ( j = 0 ; j < aLoopNode->GetNodeInPortsSize() ; j++ ) {
2501         GraphBase::InPort *anInPort = aLoopNode->GetChangeNodeInPort(j) ;
2502         if ( !anInPort->IsGate() && anInPort->IsNotConnected() ) {
2503           if ( !AddLink( aLoopNode->CoupledNode() , aLoopNode->CoupledNode()->GetChangeNodeOutPort( j ) ,
2504                          aLoopNode , anInPort ) ) {
2505 //            cdebug << "GraphBase::Graph::CreateService AddLink ERROR " << aLoopNode->CoupledNode()->Name()
2506 //                   << "( " << aLoopNode->CoupledNode()->GetChangeNodeOutPort( j )->PortName() << " ) --> "
2507 //                   << aLoopNode->Name() << "( " << anInPort->PortName() << " )" << endl ;
2508             RetVal = false ;
2509           }
2510           else {
2511             NewLink = true ;
2512           }
2513         }
2514       }
2515       for ( j = 0 ; j < aLoopNode->CoupledNode()->GetNodeInPortsSize() ; j++ ) {
2516         GraphBase::InPort *anInPort = aLoopNode->CoupledNode()->GetChangeNodeInPort( j ) ;
2517         if ( !anInPort->IsGate() && anInPort->IsNotConnected() ) {
2518           if ( !AddLink( aLoopNode , aLoopNode->GetChangeNodeOutPort( j ) ,
2519                          aLoopNode->CoupledNode() , anInPort ) ) {
2520 //            cdebug << "GraphBase::Graph::CreateService AddLink ERROR " << aLoopNode->Name() << "( "
2521 //                   << aLoopNode->GetChangeNodeOutPort( j )->PortName() << " ) --> "
2522 //                   << aLoopNode->CoupledNode()->Name() << "( " << anInPort->PortName() << " )" << endl ;
2523             RetVal = false ;
2524           }
2525           else {
2526             NewLink = true ;
2527           }
2528         }
2529       }
2530     }
2531     else if ( aNode->IsGOTONode() ) {
2532       GraphBase::GOTONode * aGOTONode = (GraphBase::GOTONode * ) aNode ;
2533       GraphBase::OutPort *anOutGate = aGOTONode->GetChangeNodeOutGate() ;
2534       if ( anOutGate->IsNotConnected() ) {
2535         RetVal = aGOTONode->CoupledNode() != NULL;
2536         if ( RetVal ) {
2537           RetVal = AddLink( aGOTONode , anOutGate ,
2538                        aGOTONode->CoupledNode() , aGOTONode->CoupledNode()->GetChangeNodeInGate() );
2539         // cdebug << "GraphBase::Graph::CreateService AddLink ERROR " << aGOTONode->Name() << "( "
2540         //        << anOutGate->PortName() << " ) --> " << aGOTONode->CoupledNode()->Name() << "( "
2541         //        << aGOTONode->CoupledNode()->GetChangeNodeInGate()->PortName() << " )" << endl ;
2542           if ( !RetVal )
2543             NewLink = true;
2544         }
2545       }
2546     }
2547   }
2548   cdebug_out << "GraphBase::Graph::LinkLoopNodes() " << RetVal << endl;
2549   return RetVal ;
2550 }
2551
2552 // Controle de la coherence des noeuds de calcul
2553 // Enregistrement dans la liste des noeuds "tete" de graphe
2554
2555 bool GraphBase::Graph::DataServerNodes() const {
2556
2557   cdebug << "GraphBase::Graph::DataServerNodes ()" << endl;
2558
2559 //  const GraphExecutor::InNode *DataFlowDatas = GetDataFlowDatas() ;
2560   int i , j , ierr = 0 ;
2561
2562 //  if ( DataFlowDatas == NULL ) {
2563 //    MESSAGE( "No input data available in the DataFlow " << _G->Name() );
2564 //    return 0 ;
2565 //  }
2566
2567 //  const GraphExecutor::InNode *DataFlowNode = _G->GetDataFlowNode() ;
2568 //  MESSAGE( "DataServerNodes DataFlowNode : " << *DataFlowNode );
2569
2570 //  MESSAGE( "DataServerNodes DataFlowDatas : " << *DataFlowDatas );
2571
2572 // cout are inversed because DataFlowDatas is a mirror node of the DataFlow
2573
2574   ierr = CheckDataServerNodes() ;
2575
2576 //  list<GraphExecutor::InNode *> aComputingNodesList = _G->ComputingNodesList() ;
2577 //  list<GraphExecutor::InNode *>::iterator aNode = aComputingNodesList.begin();
2578   if ( GraphNodesSize() == 0 ) {
2579     ierr++ ;
2580   }
2581   else {
2582     GraphBase::ComputingNode * aNode ;
2583     for ( i = 0 ; i < GraphNodesSize() ; i++ ) {
2584       aNode = GraphNodes( i ) ;
2585 //  while ( aNode != aComputingNodesList.end() ) {
2586       if ( aNode->IsFactoryNode() ) {
2587         GraphBase::FactoryNode * FaNode = (GraphBase::FactoryNode * ) aNode ;
2588         if ( !strlen( FaNode->Computer() ) ) {
2589 //          cdebug << "ComputerName missing for node " << FaNode->Name() ;
2590           if ( !strlen( FaNode->Computer() ) ) {
2591             ierr++ ;
2592             cdebug << endl ;
2593           }
2594           else {
2595 //            cdebug << ". " << FaNode->Computer() << " will be used." << endl ;
2596           }
2597         }
2598     }
2599 // For Outputs of the DataFlow :
2600       for ( j = 0 ; j < aNode->GetNodeOutPortsSize() ; j++ ) {
2601         if ( aNode->GetNodeOutPort(j)->IsNotConnected() ) {
2602           if ( aNode->GetNodeOutPort(j)->IsDataStream() ) {
2603             aNode->AddStreamLinkedNode( (GraphBase::ComputingNode *) this ) ;
2604           }
2605           else {
2606             aNode->AddLinkedNode( (GraphBase::ComputingNode *) this ) ;
2607           }
2608         }
2609       }
2610     }
2611   }
2612
2613 // Chaque noeud dataserver ne possede qu'un seul port entree ou sortie et il est bien connecte
2614
2615 //  list<GraphExecutor::InNode *> aDataServerNodesList = _G->DataServerNodesList() ;
2616 //  list<GraphExecutor::InNode *>::iterator it = aDataServerNodesList.begin() ;
2617
2618 //  for (it = _G->DataServerNodesList().begin(); it !=_G->DataServerNodesList().end(); it++){
2619 //  while ( it != aDataServerNodesList.end() ) {
2620 //    if ( (*it)->GetNodeOutPortsSize() && (*it)->GetNodeInPortsSize() ) {
2621 //      cerr << "Erreur dans le noeud serveur de donnees "
2622 //           << (*it)->Name() << " du graphe  " << _G->Name() << endl;
2623 //      cerr << "A la fois importation et exportation de donnees" << endl;
2624 //      _dataServerError.push_front(1);
2625 //    }
2626
2627 //    if ((*it)->GetNodeOutPortsSize()) {
2628 //      if ((*it)->GetNodeOutPortsSize()==1){
2629 //      if ( (*it)->GetNodeOutPort(0)->IsPortConnected() ){
2630 //        _headNodes.push_front(*it);
2631 //      }
2632 //      else {
2633 //        cerr << "Le port de sortie du noeud serveur de donnees "
2634 //               << (*it)->Name() << " du graphe  " << _G->Name()
2635 //               << " n'est pas connecte "<< endl;
2636 //        _dataServerError.push_front(4);
2637 //      }
2638 //      }
2639 //      else {
2640 //      cerr << "Plus d'une donnee importee du noeud serveur de donnees "
2641 //             << (*it)->Name() << " du graphe  " << _G->Name() << endl;
2642 //      _dataServerError.push_front(2);
2643 //      }
2644 //    }
2645
2646 //    if ((*it)->GetNodeInPortsSize()) {
2647 //      if ((*it)->GetNodeInPortsSize() > 1){
2648 //      cerr << "Plus d'une donnee exportee vers le noeud serveur de donnees "
2649 //             << (*it)->Name() << " du graphe  " << _G->Name() << endl;
2650 //      _dataServerError.push_front(3);
2651 //      }
2652 //      else
2653 //      if ( !(*it)->GetNodeInPort(0)->IsPortConnected() ){
2654 //      cerr << "Le port d'entree du noeud serveur de donnees "
2655 //             << (*it)->Name() << " du graphe  " << _G->Name()
2656 //             << " n'est pas connecte "<< endl;
2657 //      _dataServerError.push_front(5);
2658 //      }
2659 //    }
2660 //    it++ ;
2661 //  };
2662
2663 //  return _dataServerError.size ();
2664   return ( ierr == 0 ) ;
2665 }
2666
2667 SUPERV::GraphState GraphBase::Graph::PortState(
2668                                    const char* NodeName ,
2669                                    const char* ServiceParameterName ) {
2670   SUPERV::GraphState aRet = SUPERV::UndefinedState ;
2671 //  cdebug << "GraphBase::Graph::PortState( " << NodeName << " , "
2672 //         << ServiceParameterName << " )" << endl ;
2673
2674   char *theNode ;
2675   char *aPort ;
2676   NodePort( NodeName , ServiceParameterName , &theNode , &aPort ) ;
2677
2678   GraphBase::ComputingNode * aNode = GetChangeGraphNode( theNode ) ;
2679   if ( aNode ) {
2680     GraphBase::OutPort *anOutPort ;
2681     anOutPort = aNode->GetChangeOutPort( aPort );
2682     if ( anOutPort == NULL ) {
2683       GraphBase::InPort *anInPort = aNode->GetChangeInPort( aPort );
2684       if ( anInPort )
2685         anOutPort = anInPort->GetOutPort() ;
2686       else {
2687         cdebug << "ERROR GraphBase::Graph::PortState OutPort/InPort not found --> "
2688                << aRet << endl ;
2689       }
2690     }
2691     if ( anOutPort ) {
2692       aRet = anOutPort->State() ;
2693 //      cdebug << "GraphBase::Graph::PortState --> " << aRet << endl ;
2694     }
2695   }
2696   else {
2697     cdebug << "ERROR GraphBase::Graph::PortState Node not found --> " << aRet
2698            << endl ;
2699   }
2700   delete theNode ;
2701   delete aPort ;
2702   return aRet ;
2703 }
2704
2705 const CORBA::Any * GraphBase::Graph::PortInData( const char* ToNodeName ,
2706                                                  const char* ToServiceParameterName ) {
2707   const CORBA::Any * aRet = new CORBA::Any() ;
2708   char *theNode ;
2709   char *aPort ;
2710 //  cdebug_in << "GraphBase::Graph::PortInData " << ToNodeName << " "
2711 //            << ToServiceParameterName << endl ;
2712   NodePort( ToNodeName , ToServiceParameterName , &theNode , &aPort ) ;
2713
2714   GraphBase::ComputingNode * aNode = GetChangeGraphNode( theNode ) ;
2715
2716   if ( aNode ) {
2717     GraphBase::OutPort *anOutPort = NULL ;
2718     GraphBase::InPort *anInPort = aNode->GetChangeInPort( aPort );
2719     if ( anInPort ) {
2720       anOutPort = anInPort->GetOutPort() ;
2721       if ( anOutPort ) {
2722         aRet = anOutPort->Value() ;
2723         cdebug << "Graph::PortInData OutPort value " << anOutPort->NodeName() << "("
2724                << anOutPort->PortName() << ") --> InPort " << anInPort->NodeName()
2725                << "(" << anInPort->PortName() << ") " << anInPort->PortStatus() << endl ;
2726       }
2727       else {
2728         cdebug << "Graph::PortInData GraphBase::Graph::PortInData " << ToNodeName << " "
2729                << ToServiceParameterName << " ERROR no OutPort" << endl ;
2730       }
2731     }
2732     else {
2733       cdebug << "GraphBase::Graph::PortInData " << ToNodeName << " "
2734              << ToServiceParameterName << " ERROR no InPort" << endl ;
2735     }
2736   }
2737   else {
2738     cdebug << "GraphBase::Graph::PortInData " << ToNodeName << " "
2739            << ToServiceParameterName << " ERROR no Node" << endl ;
2740   }
2741   delete theNode ;
2742   delete aPort ;
2743 //  cdebug_out << "GraphBase::Graph::PortInData " << endl ;
2744   return aRet ;
2745 }
2746
2747 const CORBA::Any * GraphBase::Graph::PortOutData( const char* FromNodeName ,
2748                                                   const char* FromServiceParameterName ) {
2749   const CORBA::Any * aRet = new CORBA::Any() ;
2750   char *theNode ;
2751   char *aPort ;
2752 //  cdebug_in << "GraphBase::Graph::PortOutData " << FromNodeName << " "
2753 //            << FromServiceParameterName << endl ;
2754   NodePort( FromNodeName , FromServiceParameterName , &theNode , &aPort ) ;
2755
2756   GraphBase::ComputingNode * aNode = GetChangeGraphNode( theNode ) ;
2757
2758   if ( aNode ) {
2759     GraphBase::OutPort *anOutPort ;
2760     anOutPort = aNode->GetChangeOutPort( aPort );
2761     if ( anOutPort ) {
2762       aRet = anOutPort->Value() ;
2763     }
2764     else {
2765       cdebug << "GraphBase::Graph::PortOutData " << FromNodeName << " "
2766              << FromServiceParameterName << " ERROR no OutPort" << endl ;
2767     }
2768   }
2769   else {
2770     cdebug << "GraphBase::Graph::PortOutData " << FromNodeName << " "
2771            << FromServiceParameterName << " ERROR no Node" << endl ;
2772   }
2773   delete theNode ;
2774   delete aPort ;
2775 //  cdebug_out << "GraphBase::Graph::PortOutData " << endl ;
2776   return aRet ;
2777 }
2778
2779 SUPERV::ListOfStrings * GraphBase::Graph::LevelNodes(long aLevel ) {
2780   SUPERV::ListOfStrings_var RetVal = new SUPERV::ListOfStrings;
2781   if ( aLevel >= 0 && aLevel <= _LevelsNumber ) {
2782     int i ;
2783     RetVal->length( _NodesNumber[ aLevel ] + 1 );
2784     for ( i= 0 ; i <= _NodesNumber[ aLevel ] ; i++ ) {
2785       RetVal[i] = CORBA::string_dup( (_SortedNodes[ aLevel ])[ i ]->Name() ) ;
2786     }
2787   }
2788   return ( RetVal._retn() ) ;
2789 }
2790
2791 bool GraphBase::Graph::StartComponent(const int aThread ,
2792                                       const char * aComputerContainer ,
2793                                       const char * ComponentName ,
2794                                       Engines::Container_var & myContainer ,
2795                                       Engines::Component_var & objComponent ) {
2796   cdebug_in << aThread
2797             << " GraphBase::Graph::StartComponent " << aComputerContainer
2798             << " " << ComponentName << endl;
2799   bool RetVal = true ;
2800
2801   SALOME_LifeCycleCORBA LCC( NamingService() ) ;
2802   objComponent = LCC.FindOrLoad_Component( aComputerContainer ,
2803                                            ComponentName );
2804   if ( CORBA::is_nil( objComponent ) ) {
2805     cdebug_out << aThread
2806                << " StartComponent cannot FindOrLoad " << aComputerContainer
2807                << " " << ComponentName << " ERROR" << endl;
2808     return 0 ;
2809   }
2810   else {
2811     myContainer = LCC.FindContainer( aComputerContainer );
2812     if ( CORBA::is_nil( myContainer ) ) {
2813       cdebug_out << aThread
2814                  << " GraphBase::Graph::StartComponent myContainer = LCC.FindContainer( '"
2815                  << aComputerContainer << "' ) Container does not exist ERROR"
2816                  << endl ;
2817       return 0 ;
2818     }
2819   }
2820   cdebug_out << aThread << " GraphBase::Graph::StartComponent " << RetVal << endl;
2821   return RetVal ;
2822 }