src/GraphEditor/DataFlowEditor_InNode.cxx

   1 using namespace std;
   2 #include <string.h>
   3 #include <strstream>
   4 #include <iostream>
   5
   6 #include "DataFlowEditor_InNode.hxx"
   7
   8 GraphEditor::InNode::InNode() {
   9 }
  10
  11 GraphEditor::InNode::InNode( CORBA::ORB_ptr ORB,
  12                              SALOME_NamingService* ptrNamingService ,
  13                              GraphBase::ListOfFuncName aFuncName ,
  14                              GraphBase::ListOfPythonFunctions aPythonFunction ,
  15                              const SALOME_ModuleCatalog::Service& aService ,
  16                              const char * ComponentName ,
  17                              const char* NodeInterfaceName ,
  18                              const char * NodeName ,
  19                              const SUPERV::KindOfNode akind ,
  20                              const SUPERV::SDate NodeFirstCreation ,
  21                              const SUPERV::SDate NodeLastModification  ,
  22                              const char * NodeEditorRelease ,
  23                              const char * NodeAuthor ,
  24                              const char * NodeComputer ,
  25                              const char * NodeComment ,
  26                              const bool   GeneratedName ,
  27                              const int X ,
  28                              const int Y ,
  29                              int * Graph_prof_debug,
  30                              ostream * Graph_fdebug) {
  31   SetDebug( ORB , Graph_prof_debug , Graph_fdebug ) ;
  32
  33   _ComputingNode = NULL ;
  34   _FactoryNode = NULL ;
  35   _InLineNode = NULL ;
  36   _GOTONode = NULL ;
  37   _LoopNode = NULL ;
  38   _EndOfLoopNode = NULL ;
  39   _SwitchNode = NULL ;
  40   _EndOfSwitchNode = NULL ;
  41   switch ( akind ) {
  42   case SUPERV::ComputingNode : {
  43     cdebug << "GraphEditor::InNode::InNode SUPERV::ComputingNode : " << NodeName ;
  44     _ComputingNode = new GraphBase::ComputingNode( ORB , ptrNamingService , aService ,
  45                                                    NodeName , akind ,
  46                                                    NodeFirstCreation ,
  47                                                    NodeLastModification  ,
  48                                                    NodeEditorRelease , NodeAuthor ,
  49                                                    NodeComment , GeneratedName ,
  50                                                    X , Y ,
  51                                                    Graph_prof_debug , Graph_fdebug ) ;
  52     break ;
  53   }
  54   case SUPERV::FactoryNode : {
  55     cdebug << "GraphEditor::InNode::InNode SUPERV::FactoryNode : " << NodeName ;
  56     _FactoryNode = new GraphBase::FactoryNode( ORB , ptrNamingService , aService ,
  57                                                ComponentName , NodeInterfaceName ,
  58                                                NodeName , akind ,
  59                                                NodeFirstCreation ,
  60                                                NodeLastModification  ,
  61                                                NodeEditorRelease , NodeAuthor ,
  62                                                NodeComputer , NodeComment ,
  63                                                GeneratedName , X , Y ,
  64                                                Graph_prof_debug , Graph_fdebug ) ;
  65     _ComputingNode = (GraphBase::ComputingNode *) _FactoryNode ;
  66     break ;
  67   }
  68   case SUPERV::InLineNode : {
  69     cdebug << "GraphEditor::InNode::InNode SUPERV::InLineNode : " << NodeName ;
  70     _InLineNode = new GraphBase::InLineNode( ORB , ptrNamingService ,
  71                                              aFuncName[0].c_str() , *aPythonFunction[0] ,
  72                                              NodeName , akind ,
  73                                              NodeFirstCreation , NodeLastModification  ,
  74                                              NodeEditorRelease , NodeAuthor ,
  75                                              NodeComment , GeneratedName ,
  76                                              X , Y ,
  77                                              Graph_prof_debug , Graph_fdebug ) ;
  78     _ComputingNode = (GraphBase::ComputingNode *) _InLineNode ;
  79     break ;
  80   }
  81   case SUPERV::GOTONode : {
  82     cdebug << "GraphEditor::InNode::InNode SUPERV::GOTONode : " << NodeName ;
  83     _GOTONode = new GraphBase::GOTONode( ORB , ptrNamingService ,
  84                                          aFuncName[0].c_str() , *aPythonFunction[0] ,
  85                                          NodeName , akind ,
  86                                          NodeFirstCreation , NodeLastModification  ,
  87                                          NodeEditorRelease , NodeAuthor ,
  88                                          NodeComment , GeneratedName ,
  89                                          X , Y ,
  90                                          Graph_prof_debug , Graph_fdebug ) ;
  91     _ComputingNode = (GraphBase::ComputingNode *) _GOTONode ;
  92     break ;
  93   }
  94   case SUPERV::LoopNode : {
  95     cdebug << "GraphEditor::InNode::InNode SUPERV::LoopNode : " << NodeName ;
  96     _LoopNode = new GraphBase::LoopNode( ORB , ptrNamingService ,
  97                                          aFuncName[0].c_str() , *aPythonFunction[0] ,
  98                                          aFuncName[1].c_str() , *aPythonFunction[1] ,
  99                                          aFuncName[2].c_str() , *aPythonFunction[2] ,
 100                                          NodeName , akind ,
 101                                          NodeFirstCreation , NodeLastModification  ,
 102                                          NodeEditorRelease , NodeAuthor ,
 103                                          NodeComment , GeneratedName ,
 104                                          X , Y ,
 105                                          Graph_prof_debug , Graph_fdebug ) ;
 106     _ComputingNode = (GraphBase::ComputingNode *) _LoopNode ;
 107     _GOTONode = (GraphBase::GOTONode *) _ComputingNode ;
 108     break ;
 109   }
 110   case SUPERV::EndLoopNode : {
 111     cdebug << "GraphEditor::InNode::InNode SUPERV::EndOfLoopNode : " << NodeName ;
 112     _EndOfLoopNode = new GraphBase::EndOfLoopNode(
 113                                          ORB , ptrNamingService ,
 114                                          aFuncName[0].c_str() , *aPythonFunction[0] ,
 115                                          NodeName , akind ,
 116                                          NodeFirstCreation , NodeLastModification  ,
 117                                          NodeEditorRelease , NodeAuthor ,
 118                                          NodeComment , GeneratedName ,
 119                                          X , Y ,
 120                                          Graph_prof_debug , Graph_fdebug ) ;
 121     _ComputingNode = (GraphBase::ComputingNode *) _EndOfLoopNode ;
 122     _GOTONode = (GraphBase::GOTONode *) _ComputingNode ;
 123     break ;
 124   }
 125   case SUPERV::SwitchNode : {
 126     cdebug << "GraphEditor::InNode::InNode SUPERV::SwitchNode : " << NodeName ;
 127     _SwitchNode = new GraphBase::SwitchNode( ORB , ptrNamingService ,
 128                                              aFuncName[0].c_str() , *aPythonFunction[0] ,
 129                                              NodeName , akind ,
 130                                              NodeFirstCreation , NodeLastModification  ,
 131                                              NodeEditorRelease , NodeAuthor ,
 132                                              NodeComment , GeneratedName ,
 133                                              X , Y ,
 134                                              Graph_prof_debug , Graph_fdebug ) ;
 135     _ComputingNode = (GraphBase::ComputingNode *) _SwitchNode ;
 136     _GOTONode = (GraphBase::GOTONode *) _ComputingNode ;
 137     break ;
 138   }
 139   case SUPERV::EndSwitchNode : {
 140     cdebug << "GraphEditor::InNode::InNode SUPERV::EndOfSwitchNode : " << NodeName ;
 141     _EndOfSwitchNode = new GraphBase::EndOfSwitchNode(
 142                                              ORB , ptrNamingService ,
 143                                              aFuncName[0].c_str() , *aPythonFunction[0] ,
 144                                              NodeName , akind ,
 145                                              NodeFirstCreation , NodeLastModification  ,
 146                                              NodeEditorRelease , NodeAuthor ,
 147                                              NodeComment , GeneratedName ,
 148                                              X , Y ,
 149                                              Graph_prof_debug , Graph_fdebug ) ;
 150     _ComputingNode = (GraphBase::ComputingNode *) _EndOfSwitchNode ;
 151     _GOTONode = (GraphBase::GOTONode *) _ComputingNode ;
 152     break ;
 153   }
 154   }
 155   cdebug << "GraphEditor::InNode::InNode "  << (void *) this
 156          << " _ComputingNode " << (void *) _ComputingNode  ;
 157   _ComputingNode->InNode( this ) ;
 158 }
 159
 160 GraphEditor::InNode::~InNode() {
 161 }
 162