src/GraphBase/DataFlowBase_StreamNode.cxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 //  SUPERV GraphBase : contains fondamental classes for Services, Input Ports, Output Ports Links and Nodes.
  23 //  File   : DataFlowBase_StreamNode.cxx
  24 //  Author : Jean Rahuel
  25 //  Module : SUPERV
  26 //
  27 using namespace std;
  28
  29 #include "DataFlowBase_Graph.hxx"
  30 #include "DataFlowBase_StreamNode.hxx"
  31
  32 GraphBase::StreamNode::StreamNode() :
  33   GraphBase::PortsOfNode::PortsOfNode() {
  34   _Name = NULL ;
  35   _Kind = SUPERV::UnknownNode ;
  36   _LinkedNodesSize = 0 ;
  37   _LinkedFromNodesSize = 0 ;
  38   _LinkedStreamNodesSize = 0 ;
  39   _HeadNode = false ;
  40   _LevelNumber = -1 ;
  41   _SortedIndex = -1 ;
  42   _GraphEditor = NULL ;
  43   _GraphMacroNode =  SUPERV::Graph::_nil() ;
  44   _GraphOfNode = NULL ;
  45   _GraphMacroLevel = 0 ;
  46   _SubGraphNumber = 0 ;
  47   _SubStreamGraphNumber = 0 ;
  48   cdebug << "GraphBase::StreamNode::StreamNode " << this << " "  << endl ;
  49 }
  50
  51 GraphBase::StreamNode::StreamNode( const char * NodeName ,
  52                                    const SUPERV::KindOfNode DataFlowkind ,
  53                                    int * Graph_prof_debug ,
  54                                    ofstream * Graph_fdebug ) :
  55   GraphBase::PortsOfNode::PortsOfNode( NodeName ) {
  56   if ( NodeName != NULLSTRING && strlen( NodeName ) ) {
  57     _Name = new char[ strlen( NodeName )+1 ] ;
  58     strcpy( _Name , NodeName ) ;
  59   }
  60   else {
  61     _Name = NULLSTRING ;
  62   }
  63   Kind( DataFlowkind ) ;
  64   _LinkedNodesSize = 0 ;
  65   _LinkedFromNodesSize = 0 ;
  66   _LinkedStreamNodesSize = 0 ;
  67   _HeadNode = false ;
  68   _LevelNumber = -1 ;
  69   _SortedIndex = -1 ;
  70   _GraphEditor = NULL ;
  71   _GraphMacroNode =  SUPERV::Graph::_nil() ;
  72   _GraphOfNode = NULL ;
  73   _GraphMacroLevel = 0 ;
  74   _SubGraphNumber = 0 ;
  75   _SubStreamGraphNumber = 0 ;
  76   cdebug << "GraphBase::StreamNode::StreamNode " << NodeName << " "
  77          << this << " "  << endl ;
  78 }
  79
  80 GraphBase::StreamNode::~StreamNode() {
  81   cdebug << "GraphBase::StreamNode::~StreamNode " << this << endl ;
  82 }
  83
  84 bool GraphBase::StreamNode::Name( const char * aName) {
  85   bool RetVal ;
  86   char * aGraphName = "" ;
  87   bool aNodeWithThatName ;
  88   if ( IsDataFlowNode() || IsDataStreamNode() ) {
  89     aGraphName = Name() ;
  90     aNodeWithThatName = ((GraphBase::Graph * ) this)->GetGraphNode( aName ) ;
  91   }
  92   else if ( GraphOfNode() ) {
  93     aGraphName = GraphOfNode()->Name() ;
  94     aNodeWithThatName = GraphOfNode()->GetGraphNode( aName ) ;
  95   }
  96   cdebug_in << "GraphBase::StreamNode::Name from '" << _Name << "' to '" << aName
  97             << "' in Graph '" << aGraphName << "' IsGraph "
  98             << ( IsDataFlowNode() || IsDataStreamNode() ) << endl ;
  99   if ( strcmp( aName , aGraphName ) && !aNodeWithThatName ) {
 100     cdebug << "GraphBase::StreamNode::ReName "  << _Name << " --> " << aName << endl ;
 101     if ( _Name ) {
 102       delete [] _Name ;
 103     }
 104     _Name = new char[strlen(aName)+1] ;
 105     strcpy( _Name , aName ) ;
 106     RetVal = true ;
 107   }
 108   else {
 109     if ( !strcmp( aName , Name() ) ) {
 110 //ReName of the graph with the same name :
 111       cdebug << "GraphBase::StreamNode::ReName '" << Name() << "' to '" << aName
 112              << "' with same name" << endl ;
 113       RetVal = true ;
 114     }
 115     else {
 116       cdebug << "GraphBase::StreamNode::ReName ERROR '" << Name() << "' to '" << aName
 117              << "' already exists" << endl ;
 118       RetVal = false ;
 119     }
 120   }
 121   cdebug_out << "GraphBase::StreamNode::Name " << aName << " " << RetVal << endl;
 122   return RetVal ;
 123 }
 124
 125 void GraphBase::StreamNode::SetSubStreamGraph( int SubStreamGraphsNumber , int & RetVal ) {
 126   int jnode ;
 127   cdebug_in << Name() << " GraphBase::StreamNode::SetSubStreamGraph Level "<< Level() << " SortedIndex "
 128             << SortedIndex() << " SubStreamGraphsNumber " << SubStreamGraphsNumber << " RetVal " << RetVal
 129             << endl ;
 130   if ( SubStreamGraph() == 0 || SubStreamGraph() == SubStreamGraphsNumber ) {
 131     SubStreamGraph( SubStreamGraphsNumber ) ;
 132     cdebug << Name() << " SubStreamGraph " << SubStreamGraph() << " SetSubStreamGraph LinkedStreamNodesSize "
 133            << LinkedStreamNodesSize() << endl ;
 134     for ( jnode = 0 ; jnode < LinkedStreamNodesSize() ; jnode++ ) {
 135       if ( LinkedStreamNodes( jnode )->Level() > Level() ||
 136            ( LinkedStreamNodes( jnode )->Level() == Level() &&
 137              LinkedStreamNodes( jnode )->SortedIndex() > SortedIndex() ) ) {
 138         LinkedStreamNodes( jnode )->SetSubStreamGraph( SubStreamGraphsNumber , RetVal ) ;
 139         if ( RetVal != SubStreamGraphsNumber ) {
 140           break ;
 141         }
 142       }
 143       else if ( LinkedStreamNodes( jnode )->SubStreamGraph() == 0 ) {
 144         LinkedStreamNodes( jnode )->SubStreamGraph( SubStreamGraphsNumber ) ;
 145         cdebug << LinkedStreamNodes( jnode )->Name() << " SubStreamGraph "
 146                << LinkedStreamNodes( jnode )->SubStreamGraph() << endl ;
 147       }
 148       else if ( LinkedStreamNodes( jnode )->SubStreamGraph() != SubStreamGraphsNumber ) {
 149         cdebug << LinkedStreamNodes( jnode )->Name() << " SubStreamGraph "
 150                << LinkedStreamNodes( jnode )->SubStreamGraph() << " != " << SubStreamGraphsNumber << endl ;
 151         RetVal = LinkedStreamNodes( jnode )->SubStreamGraph() ;
 152         break ;
 153       }
 154     }
 155   }
 156   else {
 157     cdebug << Name() << " SubStreamGraph " << SubStreamGraph() << " != " << SubStreamGraphsNumber << endl ;
 158     RetVal = SubStreamGraph() ;
 159   }
 160
 161   cdebug_out << Name() << "->GraphBase::StreamNode::SetSubStreamGraph RetVal " << RetVal << endl ;
 162   return ;
 163 }
 164
 165 void GraphBase::StreamNode::AddLinkedNode( GraphBase::StreamNode * ToNode ) {
 166   int index = GetLinkedNodeIndex( ToNode->Name() ) ;
 167   if ( index < 0 ) {
 168     cdebug << Name() << "->GraphBase::StreamNode::AddLinkedNode( " << ToNode->Name()
 169            << " ) new LinkedNode " << endl ;
 170     _LinkedNodes.resize( _LinkedNodesSize+1 ) ;
 171     _LinkedInPortsNumber.resize( _LinkedNodesSize+1 ) ;
 172     _LinkedNodes[ _LinkedNodesSize ] = ToNode ;
 173     _LinkedInPortsNumber[ _LinkedNodesSize ] = 0 ;
 174     IncrLinkedInPortsNumber( _LinkedNodesSize ) ;
 175 //    _LinkedInPortsNumber[ _LinkedNodesSize ] = 1 ;
 176     SetLinkedNodeIndex( ToNode->Name() , _LinkedNodesSize ) ;
 177     index = _LinkedNodesSize ;
 178     _LinkedNodesSize++ ;
 179   }
 180   else {
 181     cdebug << Name() << "->GraphBase::StreamNode::AddLinkedNode( " << ToNode->Name()
 182            << " ) old LinkedNode " << _LinkedNodes[index ]->Name() << endl ;
 183     IncrLinkedInPortsNumber( index ) ;
 184 //    _LinkedInPortsNumber[ index ] += 1 ;
 185   }
 186   cdebug << Name() << "->GraphBase::StreamNode::AddLinkedNode( " << ToNode->Name()
 187          << " ) LinkedNodesSize " << _LinkedNodesSize << " [ " << index
 188          << " ] _LinkedInPortsNumber " << _LinkedInPortsNumber[ index ] << endl ;
 189
 190   index = ToNode->GetLinkedFromNodeIndex( Name() ) ;
 191   if ( index < 0 ) {
 192     cdebug << ToNode->Name() << "<-GraphBase::StreamNode::AddLinkedFromNode( " << Name()
 193            << " ) new LinkedFromNode " << endl ;
 194     ToNode->_LinkedFromNodes.resize( ToNode->_LinkedFromNodesSize+1 ) ;
 195     ToNode->_LinkedFromInPortsNumber.resize( ToNode->_LinkedFromNodesSize+1 ) ;
 196     ToNode->_LinkedFromNodes[ ToNode->_LinkedFromNodesSize ] = this ;
 197     ToNode->_LinkedFromInPortsNumber[ ToNode->_LinkedFromNodesSize ] = 0 ;
 198     ToNode->IncrLinkedFromInPortsNumber( ToNode->_LinkedFromNodesSize ) ;
 199 //    ToNode->_LinkedFromInPortsNumber[ ToNode->_LinkedFromNodesSize ] = 1 ;
 200     ToNode->SetLinkedFromNodeIndex( Name() , ToNode->_LinkedFromNodesSize ) ;
 201     index = ToNode->_LinkedFromNodesSize ;
 202     ToNode->_LinkedFromNodesSize++ ;
 203   }
 204   else {
 205     cdebug << Name() << "->GraphBase::StreamNode::AddLinkedFromNode( " << ToNode->Name()
 206            << " ) old LinkedFromNode " << ToNode->_LinkedFromNodes[index ]->Name() << endl ;
 207     ToNode->IncrLinkedFromInPortsNumber( index ) ;
 208 //    ToNode->_LinkedFromInPortsNumber[ index ] += 1 ;
 209   }
 210   cdebug << ToNode->Name() << "->GraphBase::StreamNode::AddLinkedFromNode( " << Name()
 211          << " ) LinkedFromNodesSize " << ToNode->_LinkedFromNodesSize << " [ " << index
 212          << " ] _LinkedFromInPortsNumber " << ToNode->_LinkedFromInPortsNumber[ index ] << endl ;
 213 }
 214
 215 bool GraphBase::StreamNode::RemoveLinkedNode( GraphBase::StreamNode * ToNode ,
 216                                               bool DoLinkedFromNode ) {
 217   cdebug_in << "StreamNode::RemoveLinkedNode between " << Name() << " LinkedNodesSize "
 218             << LinkedNodesSize() << " and " << ToNode->Name() << " LinkedFromNodesSize "
 219             << ToNode->LinkedFromNodesSize() << endl ;
 220 #if 1
 221   map< string , int >::iterator aMapOfLinkedNodesIterator ;
 222   int i = 0 ;
 223   for ( aMapOfLinkedNodesIterator = _MapOfLinkedNodes.begin() ;
 224         aMapOfLinkedNodesIterator != _MapOfLinkedNodes.end() && i < _LinkedNodesSize ;
 225         aMapOfLinkedNodesIterator++ ) {
 226     cdebug << "_MapOfLinkedNodes" << i++ << " of " << Name() << " : "
 227            << aMapOfLinkedNodesIterator->first << " --> " << aMapOfLinkedNodesIterator->second
 228            << endl ;
 229   }
 230 #endif
 231 #if 1
 232   map< string , int >::iterator aMapOfLinkedFromNodesIterator ;
 233   int ifrom = 0 ;
 234   for ( aMapOfLinkedFromNodesIterator = ToNode->_MapOfLinkedFromNodes.begin() ;
 235         aMapOfLinkedFromNodesIterator != ToNode->_MapOfLinkedFromNodes.end() &&
 236         ifrom < ToNode->_LinkedFromNodesSize ; aMapOfLinkedFromNodesIterator++ ) {
 237     cdebug << "_MapOfLinkedFromNodes" << ifrom++ << " of " << ToNode->Name() << " : "
 238            << aMapOfLinkedFromNodesIterator->first << " --> "
 239            << aMapOfLinkedFromNodesIterator->second << endl ;
 240   }
 241 #endif
 242
 243   int index = -1 ;
 244   if ( _LinkedNodesSize ) {
 245     index = GetLinkedNodeIndex( ToNode->Name() ) ;
 246   }
 247   if ( index >= 0 ) {
 248     cdebug << "GraphBase::StreamNode::RemoveLinkedNode to " << ToNode->Name() << " from "
 249            << Name() << " index : " << index << " " << ToNode->Name() << "->LinkedInPortsNumber "
 250            << _LinkedInPortsNumber[ index ] << " - 1" << endl ;
 251     DecrLinkedInPortsNumber( index ) ;
 252 //    _LinkedInPortsNumber[ index ] -= 1 ;
 253     if ( _LinkedInPortsNumber[ index ] == 0 ) {
 254       _LinkedNodesSize-- ;
 255       cdebug << "GraphBase::StreamNode::RemoveLinkedNode new LinkedNodesSize "
 256              << _LinkedNodesSize << " " << ToNode->Name() << " removed from "
 257              << " linkednodes of " << Name() << endl ;
 258       int i ;
 259       for ( i = index ; i < _LinkedNodesSize ; i++ ) {
 260         _LinkedNodes[ i ] = _LinkedNodes[ i+1 ] ;
 261         _LinkedInPortsNumber[ i ] =  _LinkedInPortsNumber[ i+1 ] ;
 262         SetLinkedNodeIndex( _LinkedNodes[ i ]->Name() , i ) ;
 263       }
 264       DelLinkedNodeIndex( ToNode->Name() ) ;
 265       _LinkedNodes.resize( _LinkedNodesSize+1 ) ;
 266       _LinkedInPortsNumber.resize( _LinkedNodesSize+1 ) ;
 267     }
 268     else {
 269       cdebug << "StreamNode::RemoveLinkedNode to " << ToNode->Name() << " from "
 270              << Name() << " " << ToNode->Name() << "->LinkedInPortsNumber # 0 " << endl ;
 271     }
 272   }
 273   else if ( Kind() != SUPERV::GOTONode ) {
 274     cdebug << "StreamNode::RemoveLinkedNode index Error " << ToNode->Name() << " <-- " << Name() << " : " << index
 275            << " _LinkedNodesSize " << ToNode->_LinkedNodesSize << endl ;
 276   }
 277   int fromindex = -1 ;
 278   if ( ToNode->LinkedFromNodesSize() ) {
 279 //  if ( ToNode->_LinkedFromNodesSize ) {
 280     fromindex = ToNode->GetLinkedFromNodeIndex( Name() ) ;
 281   }
 282   if ( fromindex >= 0 ) {
 283     cdebug << "GraphBase::StreamNode::RemoveLinkedFromNode from " << ToNode->Name() << " to "
 284            << Name() << " index : " << fromindex << " " << ToNode->Name()
 285            << "->LinkedFromInPortsNumber "
 286            << ToNode->_LinkedFromInPortsNumber[ fromindex ] << " - 1" << endl ;
 287 //    ToNode->_LinkedFromInPortsNumber[ fromindex ] -= 1 ;
 288     ToNode->DecrLinkedFromInPortsNumber( fromindex ) ;
 289     if ( ToNode->LinkedFromInPortsNumber( fromindex ) == 0 ) {
 290 //    if ( ToNode->_LinkedFromInPortsNumber[ fromindex ] == 0 ) {
 291       ToNode->DecrLinkedFromNodesSize() ;
 292 //      ToNode->_LinkedFromNodesSize-- ;
 293       cdebug << "GraphBase::StreamNode::RemoveLinkedFromNode new LinkedFromNodesSize "
 294              << ToNode->_LinkedFromNodesSize << " " << Name() << " removed from "
 295              << " linkedFromnodes of " << ToNode->Name() << endl ;
 296       int i ;
 297       for ( i = 0 ; i < ToNode->_LinkedFromNodesSize ; i++ ) {
 298         if ( i >= fromindex ) {
 299           ToNode->_LinkedFromNodes[ i ] = ToNode->_LinkedFromNodes[ i+1 ] ;
 300           ToNode->_LinkedFromInPortsNumber[ i ] =  ToNode->_LinkedFromInPortsNumber[ i+1 ] ;
 301           ToNode->SetLinkedFromNodeIndex( ToNode->_LinkedFromNodes[ i ]->Name() , i ) ;
 302         }
 303         cdebug << "StreamNode::RemoveLinkedFromNode" << i << " "
 304                << ToNode->_LinkedFromNodes[ i ]->Name() << endl ;
 305       }
 306       ToNode->DelLinkedFromNodeIndex( Name() ) ;
 307       ToNode->_LinkedFromNodes.resize( ToNode->_LinkedFromNodesSize+1 ) ;
 308       ToNode->_LinkedFromInPortsNumber.resize( ToNode->_LinkedFromNodesSize+1 ) ;
 309     }
 310     else {
 311       cdebug << "StreamNode::RemoveLinkedFromNode from " << ToNode->Name()
 312              << "->LinkedFromInPortsNumber "
 313              << ToNode->_LinkedFromInPortsNumber[ fromindex ] << " # 0" << endl ;
 314     }
 315   }
 316   else if ( DoLinkedFromNode ) {
 317     cdebug << "StreamNode::RemoveLinkedFromNode index Error " << ToNode->Name() << " --> "
 318            << Name() << " : " << fromindex
 319            << " _LinkedFromNodesSize " << ToNode->_LinkedFromNodesSize << endl ;
 320   }
 321   else {
 322     cdebug << "StreamNode::RemoveLinkedFromNode index " << ToNode->Name() << " --> " << Name()
 323            << " : " << fromindex
 324            << " _LinkedFromNodesSize " << ToNode->_LinkedFromNodesSize << endl ;
 325     fromindex = 0 ; // No error in EndSwitchNodes
 326   }
 327
 328 #if 1
 329   map< string , int >::iterator aMapOfLinkedNodesIterator1 ;
 330   int ii = 0 ;
 331   for ( aMapOfLinkedNodesIterator1 = _MapOfLinkedNodes.begin() ;
 332         aMapOfLinkedNodesIterator1 != _MapOfLinkedNodes.end() && ii < _LinkedNodesSize ;
 333         aMapOfLinkedNodesIterator1++ ) {
 334     if ( aMapOfLinkedNodesIterator1->second ) {
 335       cdebug << "_MapOfLinkedNodes" << ii++ << " of " << Name() << " : "
 336              << aMapOfLinkedNodesIterator1->first << " --> " << aMapOfLinkedNodesIterator1->second
 337              << " " << _LinkedNodes[ aMapOfLinkedNodesIterator1->second - 1 ]->Name() << endl ;
 338     }
 339     else {
 340       cdebug << "_MapOfLinkedNodes" << ii << " of " << Name() << " : "
 341              << aMapOfLinkedNodesIterator1->second - 1 << endl ;
 342     }
 343   }
 344 #endif
 345 #if 1
 346   map< string , int >::iterator aMapOfLinkedFromNodesIterator1 ;
 347   int iifrom = 0 ;
 348   for ( aMapOfLinkedFromNodesIterator1 = ToNode->_MapOfLinkedFromNodes.begin() ;
 349         aMapOfLinkedFromNodesIterator1 != ToNode->_MapOfLinkedFromNodes.end() &&
 350         iifrom < ToNode->_LinkedFromNodesSize ; aMapOfLinkedFromNodesIterator1++ ) {
 351     if ( aMapOfLinkedFromNodesIterator1->second ) {
 352       cdebug << "_MapOfLinkedFromNodes" << iifrom++ << " of " << ToNode->Name() << " : "
 353              << aMapOfLinkedFromNodesIterator1->first << " --> "
 354              << aMapOfLinkedFromNodesIterator1->second << " "
 355              << ToNode->_LinkedFromNodes[ aMapOfLinkedFromNodesIterator1->second - 1 ]->Name()
 356              << endl ;
 357     }
 358     else {
 359       cdebug << "_MapOfLinkedFromNodes" << iifrom << " of " << ToNode->Name() << " : "
 360              << aMapOfLinkedFromNodesIterator1->second - 1 << endl ;
 361     }
 362   }
 363 #endif
 364   cdebug_out << "StreamNode::RemoveLinkedNode between " << Name() << " and " << ToNode->Name()
 365              << " " << (index >= 0) << " " << (fromindex >= 0) << endl ;
 366   return (index >= 0 ) && (fromindex >= 0 ) ;
 367 }
 368
 369 void GraphBase::StreamNode::ReNameLinkedNode( const char* OldNodeName ,
 370                                               const char* NewNodeName ) {
 371   cdebug_in << Name() << "->GraphBase::StreamNode::ReNameLinkedNode (" << OldNodeName << " , "
 372             << NewNodeName << ") _LinkedNodesSize " << _LinkedNodesSize << endl;
 373   int index = GetLinkedNodeIndex( OldNodeName ) ;
 374   if ( index >= 0 ) {
 375 //    _MapOfLinkedNodes.erase( OldNodeName ) ;
 376     DelLinkedNodeIndex( OldNodeName ) ;
 377     SetLinkedNodeIndex( NewNodeName , index ) ;
 378   }
 379   else {
 380     cdebug << "GraphBase::StreamNode::ReNameLinkedNode ERROR " << OldNodeName << " not found in "
 381            << Name() << endl ;
 382   }
 383 #if 1
 384   map< string , int >::iterator aMapOfLinkedNodesIterator1 ;
 385   int ii = 0 ;
 386   for ( aMapOfLinkedNodesIterator1 = _MapOfLinkedNodes.begin() ;
 387         aMapOfLinkedNodesIterator1 != _MapOfLinkedNodes.end() && ii < _LinkedNodesSize ;
 388         aMapOfLinkedNodesIterator1++ ) {
 389     cdebug << "_MapOfLinkedNodes" << ii++ << " of " << Name() << " : "
 390            << aMapOfLinkedNodesIterator1->first << " --> " << aMapOfLinkedNodesIterator1->second
 391            << " " << _LinkedNodes[ aMapOfLinkedNodesIterator1->second - 1 ]->Name() << endl ;
 392   }
 393 #endif
 394   cdebug_out << Name() << "->GraphBase::StreamNode::ReNameLinkedNode" << endl ;
 395 }
 396
 397 void GraphBase::StreamNode::ReNameLinkedFromNode( const char* OldNodeName ,
 398                                                   const char* NewNodeName ) {
 399   cdebug_in << Name() << "->GraphBase::StreamNode::ReNameLinkedFromNode (" << OldNodeName
 400             << " , " << NewNodeName << ") _LinkedFromNodesSize " << _LinkedFromNodesSize
 401             << endl;
 402   int index = GetLinkedFromNodeIndex( OldNodeName ) ;
 403   if ( index >= 0 ) {
 404 //    _MapOfLinkedFromNodes.erase( OldNodeName ) ;
 405     DelLinkedFromNodeIndex( OldNodeName ) ;
 406     SetLinkedFromNodeIndex( NewNodeName , index ) ;
 407   }
 408   else {
 409     cdebug << Name() << "->GraphBase::StreamNode::ReNameLinkedFromNode ERROR " << OldNodeName
 410            << " not found in " << Name() << endl ;
 411   }
 412 #if 1
 413   map< string , int >::iterator aMapOfLinkedFromNodesIterator1 ;
 414   int iifrom = 0 ;
 415   for ( aMapOfLinkedFromNodesIterator1 = _MapOfLinkedFromNodes.begin() ;
 416         aMapOfLinkedFromNodesIterator1 != _MapOfLinkedFromNodes.end() &&
 417         iifrom < _LinkedFromNodesSize ; aMapOfLinkedFromNodesIterator1++ ) {
 418     cdebug << "_MapOfLinkedFromNodes" << iifrom++ << " of " << Name() << " : "
 419            << aMapOfLinkedFromNodesIterator1->first << " --> "
 420            << aMapOfLinkedFromNodesIterator1->second << " "
 421            << _LinkedFromNodes[ aMapOfLinkedFromNodesIterator1->second - 1 ]->Name()
 422            << endl ;
 423   }
 424 #endif
 425   cdebug_out << Name() << "->GraphBase::StreamNode::ReNameLinkedFromNode" << endl ;
 426 }
 427
 428 void GraphBase::StreamNode::AddStreamLinkedNode( GraphBase::StreamNode * ToNode ) {
 429   int index = GetLinkedStreamNodeIndex( ToNode->Name() ) ;
 430   if ( index < 0 ) {
 431     cdebug_in << Name() << "->GraphBase::StreamNode::AddStreamLinkedNode( " << ToNode->Name()
 432               << " ) new LinkedNode " << endl ;
 433     _LinkedStreamNodes.resize( _LinkedStreamNodesSize+1 ) ;
 434     _LinkedInStreamPortsNumber.resize( _LinkedStreamNodesSize+1 ) ;
 435     _LinkedStreamNodes[ _LinkedStreamNodesSize ] = ToNode ;
 436     _LinkedInStreamPortsNumber[ _LinkedStreamNodesSize ] = 1 ;
 437     SetLinkedStreamNodeIndex( ToNode->Name() , _LinkedStreamNodesSize ) ;
 438     index = _LinkedStreamNodesSize ;
 439     _LinkedStreamNodesSize++ ;
 440   }
 441   else {
 442     cdebug_in << Name() << "->GraphBase::StreamNode::AddStreamLinkedNode( " << ToNode->Name()
 443               << " ) old LinkedNode " << _LinkedStreamNodes[index ]->Name() << endl ;
 444     _LinkedInStreamPortsNumber[ index ] += 1 ;
 445   }
 446   cdebug_out << Name() << "->GraphBase::StreamNode::AddStreamLinkedNode( " << ToNode->Name()
 447              << " ) LinkedStreamNodesSize " << _LinkedStreamNodesSize << " [ " << index
 448              << " ] _LinkedInStreamPortsNumber " << _LinkedInStreamPortsNumber[ index ] << endl ;
 449 }
 450
 451 bool GraphBase::StreamNode::RemoveStreamLinkedNode( GraphBase::StreamNode * ToNode ) {
 452   int index = GetLinkedStreamNodeIndex( ToNode->Name() ) ;
 453   if ( index >= 0 ) {
 454     cdebug << "GraphBase::StreamNode::RemoveStreamLinkedNode( to " << ToNode->Name() << " from "
 455            << Name() << " index : " << index << " LinkedInStreamPortsNumber "
 456            << _LinkedInStreamPortsNumber[ index ] << " - 1" << endl ;
 457     _LinkedInStreamPortsNumber[ index ] -= 1 ;
 458     if ( _LinkedInStreamPortsNumber[ index ] == 0 ) {
 459       _LinkedStreamNodesSize-- ;
 460       cdebug << "GraphBase::StreamNode::RemoveStreamLinkedNode new LinkedNodesSize "
 461              << _LinkedStreamNodesSize << " " << ToNode->Name() << " removed from "
 462              << " linkednodes of " << Name() << endl ;
 463       int i ;
 464       for ( i = index ; i < _LinkedStreamNodesSize ; i++ ) {
 465         _LinkedStreamNodes[ i ] = _LinkedStreamNodes[ i+1 ] ;
 466         _LinkedInStreamPortsNumber[ i ] =  _LinkedInStreamPortsNumber[ i+1 ] ;
 467         SetLinkedStreamNodeIndex( _LinkedStreamNodes[ i ]->Name() , i ) ;
 468       }
 469       DelLinkedStreamNodeIndex( ToNode->Name() ) ;
 470       _LinkedStreamNodes.resize( _LinkedStreamNodesSize+1 ) ;
 471       _LinkedInStreamPortsNumber.resize( _LinkedStreamNodesSize+1 ) ;
 472     }
 473   }
 474   else {
 475     cdebug << "StreamNode::RemoveStreamLinkedNode Error index " << index << endl ;
 476   }
 477   return (index >= 0 ) ;
 478 }
 479
 480 void GraphBase::StreamNode::ReNameStreamLinkedNode( const char* OldNodeName ,
 481                                               const char* NewNodeName ) {
 482   cdebug_in << "GraphBase::StreamNode::ReNameStreamLinkedNode (" << OldNodeName << " , "
 483             << NewNodeName << ")" << endl;
 484   int index = GetLinkedStreamNodeIndex( OldNodeName ) ;
 485   if ( index >= 0 ) {
 486 //    _MapOfLinkedNodes.erase( OldNodeName ) ;
 487     DelLinkedStreamNodeIndex( OldNodeName ) ;
 488     SetLinkedStreamNodeIndex( NewNodeName , index ) ;
 489   }
 490   cdebug_out << "GraphBase::StreamNode::ReNameStreamLinkedNode" << endl ;
 491 }