src/GraphBase/DataFlowBase_StreamNode.cxx

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