src/GraphExecutor/DataFlowExecutor_DataFlow.lxx

   1 //  SUPERV GraphExecutor : contains classes that permit execution of graphs and particularly the execution automaton
   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   : DataFlowExecutor_DataFlow.lxx
  25 //  Module : SUPERV
  26
  27 #ifndef _DATAFLOWEXECUTOR_DATAFLOW_LXX
  28 #define _DATAFLOWEXECUTOR_DATAFLOW_LXX
  29
  30 #include "DataFlowExecutor_OutNode.hxx"
  31
  32 inline bool GraphExecutor::DataFlow::LoadDataFlow(
  33        const GraphBase::SGraph &aDataFlow ) {
  34   return GraphExecutor::OutNode::LoadDataFlow( aDataFlow ) ;
  35 }
  36
  37 inline bool GraphExecutor::DataFlow::LoadXml( const char* myFileName ) {
  38   return GraphExecutor::OutNode::LoadXml( myFileName ) ;
  39 }
  40
  41 inline const SALOME_ModuleCatalog::Service * GraphExecutor::DataFlow::NodeService(
  42                                              const char * aNodeName ) {
  43   if ( GetGraphNode( aNodeName ) )
  44     return GetGraphNode( aNodeName )->GetService() ;
  45   return NULL ;
  46 }
  47
  48 inline bool GraphExecutor::DataFlow::ChangeInputData( const char* ToNodeName ,
  49                                                  const char* ToParameterName ,
  50                                                  const CORBA::Any aValue ) {
  51   if ( !IsValid() )
  52     return false ;
  53   return GraphBase::Graph::ChangeInputData( ToNodeName , ToParameterName ,
  54                                             aValue ) ;
  55 } ;
  56
  57 inline bool GraphExecutor::DataFlow::AddInputSharedData(const char* ToNodeName1 ,
  58                                                       const char* ToParameterName1 ,
  59                                                       const char* ToNodeName2 ,
  60                                                       const char* ToParameterName2 ) {
  61   if ( !IsValid() )
  62     return false ;
  63   return GraphExecutor::OutNode::AddInputData( ToNodeName1 ,
  64                                                ToParameterName1 ,
  65                                                ToNodeName2 ,
  66                                                ToParameterName2 ) ;
  67 //                                         aKindOfPortValue ) ;
  68 } ;
  69
  70 inline bool GraphExecutor::DataFlow::IsValid() {
  71   return GraphExecutor::OutNode::IsValid() ;
  72 }
  73
  74 inline bool GraphExecutor::DataFlow::IsExecutable() {
  75   return GraphExecutor::OutNode::IsExecutable() ;
  76 }
  77
  78 inline bool GraphExecutor::DataFlow::Run( const bool AndSuspend ) {
  79   return GraphExecutor::OutNode::Run( AndSuspend ) ;
  80 }
  81 inline bool GraphExecutor::DataFlow::Run( const char * aNodeName ,
  82                                           const char * AtNodeName ,
  83                                           const bool AndSuspend ) {
  84   return GraphExecutor::OutNode::Run( aNodeName ,  AtNodeName , AndSuspend ) ;
  85 }
  86
  87 inline long GraphExecutor::DataFlow::LastLevelDone() {
  88   return GraphExecutor::OutNode::LastLevelDone() ;
  89 }
  90
  91 inline long GraphExecutor::DataFlow::Threads() {
  92   return GraphExecutor::OutNode::Threads() ;
  93 }
  94
  95 inline bool GraphExecutor::DataFlow::Event( char ** aNodeName ,
  96                                             SUPERV::GraphEvent & anEvent ,
  97                                             SUPERV::GraphState & aState ,
  98                                             bool WithWait ) {
  99   return GraphExecutor::OutNode::Event( aNodeName , anEvent , aState , WithWait ) ;
 100 }
 101 inline bool GraphExecutor::DataFlow::EventW( char ** aNodeName ,
 102                                              SUPERV::GraphEvent & anEvent ,
 103                                              SUPERV::GraphState & aState ) {
 104   return GraphExecutor::OutNode::EventW( aNodeName , anEvent , aState ) ;
 105 }
 106 inline long GraphExecutor::DataFlow::EventQSize() {
 107   return GraphExecutor::OutNode::EventQSize() ;
 108 }
 109
 110 inline SUPERV::GraphState GraphExecutor::DataFlow::State() {
 111   return GraphExecutor::OutNode::State() ;
 112 }
 113
 114 inline SUPERV::GraphState GraphExecutor::DataFlow::State(
 115                                const char * aNodeName ) {
 116   return GraphExecutor::OutNode::State( aNodeName ) ;
 117 }
 118
 119 inline SUPERV::GraphState GraphExecutor::DataFlow::State(
 120                                const char * aNodeName ,
 121                                const char * anOutServiceParameterName ) {
 122   return GraphExecutor::OutNode::State( aNodeName ,
 123                                         anOutServiceParameterName ) ;
 124 }
 125
 126 inline long GraphExecutor::DataFlow::Thread() {
 127   return GraphExecutor::OutNode::ThreadNo() ;
 128 }
 129 inline long GraphExecutor::DataFlow::Thread( const char * aNodeName ) {
 130   return GraphExecutor::OutNode::Thread( aNodeName ) ;
 131 }
 132
 133 inline SUPERV::AutomatonState GraphExecutor::DataFlow::AutomatonState() {
 134   return GraphExecutor::OutNode::AutomatonState() ;
 135 }
 136
 137 inline SUPERV::AutomatonState GraphExecutor::DataFlow::AutomatonState(
 138                                const char * aNodeName ) {
 139   return GraphExecutor::OutNode::AutomatonState( aNodeName ) ;
 140 }
 141
 142 inline SUPERV::ControlState GraphExecutor::DataFlow::ControlState() {
 143   return GraphExecutor::OutNode::ControlState() ;
 144 }
 145
 146 inline SUPERV::ControlState GraphExecutor::DataFlow::ControlState(
 147                                const char * aNodeName ) {
 148   return GraphExecutor::OutNode::ControlState( aNodeName ) ;
 149 }
 150
 151 inline void GraphExecutor::DataFlow::ControlClear() {
 152   return GraphExecutor::OutNode::ControlClear() ;
 153 }
 154
 155 inline void GraphExecutor::DataFlow::ControlClear(
 156                                const char * aNodeName ) {
 157   return GraphExecutor::OutNode::ControlClear( aNodeName ) ;
 158 }
 159
 160 inline bool GraphExecutor::DataFlow::IsWaiting() {
 161   return GraphExecutor::OutNode::IsWaiting() ;
 162 }
 163 inline bool GraphExecutor::DataFlow::IsReady() {
 164   return GraphExecutor::OutNode::IsReady() ;
 165 }
 166 inline bool GraphExecutor::DataFlow::IsRunning() {
 167   return GraphExecutor::OutNode::IsRunning() ;
 168 }
 169 inline bool GraphExecutor::DataFlow::IsDone() {
 170   return GraphExecutor::OutNode::IsDone() ;
 171 }
 172 inline bool GraphExecutor::DataFlow::IsSuspended() {
 173   return GraphExecutor::OutNode::IsSuspended() ;
 174 }
 175
 176 inline bool GraphExecutor::DataFlow::IsWaiting(const char * aNodeName ) {
 177   return GraphExecutor::OutNode::IsWaiting( aNodeName ) ;
 178 }
 179 inline bool GraphExecutor::DataFlow::IsReady(const char * aNodeName ) {
 180   return GraphExecutor::OutNode::IsReady( aNodeName ) ;
 181 }
 182 inline bool GraphExecutor::DataFlow::IsRunning(const char * aNodeName ) {
 183   return GraphExecutor::OutNode::IsRunning( aNodeName ) ;
 184 }
 185 inline bool GraphExecutor::DataFlow::IsDone(const char * aNodeName ) {
 186   return GraphExecutor::OutNode::IsDone( aNodeName ) ;
 187 }
 188 inline bool GraphExecutor::DataFlow::IsSuspended(const char * aNodeName ) {
 189   return GraphExecutor::OutNode::IsSuspended( aNodeName ) ;
 190 }
 191
 192 inline bool GraphExecutor::DataFlow::IsDone(
 193                                   const char * aNodeName ,
 194                                   const char * anOutServiceParameterName ) {
 195   return GraphExecutor::OutNode::IsDone( aNodeName ,
 196                                          anOutServiceParameterName ) ;
 197 }
 198
 199 inline bool GraphExecutor::DataFlow::ReadyWait() {
 200   return GraphExecutor::OutNode::ReadyWait() ;
 201 }
 202 inline bool GraphExecutor::DataFlow::RunningWait() {
 203   return GraphExecutor::OutNode::RunningWait() ;
 204 }
 205 inline bool GraphExecutor::DataFlow::DoneWait() {
 206   return GraphExecutor::OutNode::DoneWait() ;
 207 }
 208 inline bool GraphExecutor::DataFlow::SuspendedWait() {
 209   return GraphExecutor::OutNode::SuspendedWait() ;
 210 }
 211
 212 inline bool GraphExecutor::DataFlow::ReadyWait(const char * aNodeName ) {
 213   return GraphExecutor::OutNode::ReadyWait( aNodeName ) ;
 214 }
 215 inline bool GraphExecutor::DataFlow::RunningWait(const char * aNodeName ) {
 216   return GraphExecutor::OutNode::RunningWait( aNodeName ) ;
 217 }
 218 inline bool GraphExecutor::DataFlow::DoneWait(const char * aNodeName ) {
 219   return GraphExecutor::OutNode::DoneWait( aNodeName ) ;
 220 }
 221 inline bool GraphExecutor::DataFlow::SuspendedWait(const char * aNodeName ) {
 222   return GraphExecutor::OutNode::SuspendedWait( aNodeName ) ;
 223 }
 224
 225 inline const CORBA::Any *GraphExecutor::DataFlow::GetInData(
 226                                    const char * ToNodeName ,
 227                                    const char * ToParameterName ) {
 228   return GraphExecutor::OutNode::GetInData( ToNodeName ,
 229                                             ToParameterName ) ;
 230 }
 231 inline const CORBA::Any *GraphExecutor::DataFlow::GetOutData(
 232                                    const char * FromNodeName ,
 233                                    const char * FromParameterName ) {
 234   return GraphExecutor::OutNode::GetOutData( FromNodeName ,
 235                                              FromParameterName ) ;
 236 }
 237 #endif
 238
 239
 240