src/GraphBase/DataFlowBase_Base.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_Base.cxx
  25 //  Author : Jean Rahuel, CEA
  26 //  Module : SUPERV
  27 //  $Header:
  28
  29 using namespace std;
  30 #include "DataFlowBase_Base.hxx"
  31
  32 char *SuperVision_Version = "3.0" ;
  33
  34 char *NULLSTRING = "" ;
  35
  36 char *FACTORYSERVER = "localhost/FactoryServer" ;
  37
  38 GraphBase::Base::Base() {
  39   _prof_debug = NULL ;
  40   _fdebug = NULL ;
  41 }
  42
  43 void GraphBase::Base::SetDebug( CORBA::ORB_ptr ORB ,
  44                                 int * theprof_debug , ofstream * thefdebug ) {
  45   if ( _prof_debug == NULL ) {
  46 //    *thefdebug << "GraphBase::Base::SetDebug Done _fdebug " << _fdebug << " = thefdebug " << thefdebug
  47 //           << endl ;
  48     if ( theprof_debug ) {
  49       _Orb = CORBA::ORB::_duplicate( ORB ) ;
  50       _prof_debug = theprof_debug ;
  51       _fdebug = thefdebug ;
  52     }
  53     else {
  54       MESSAGE( "GraphBase::Base::SetDebug with theprof_debug == NULL" ) ;
  55     }
  56   }
  57   else {
  58     cdebug << "GraphBase::Base::SetDebug already done" << endl ;
  59   }
  60 //  cdebug_in << "GraphBase::Base::SetDebug" << endl ;
  61 //  cdebug << "GraphBase::Base::SetDebug" << endl ;
  62 //  cdebug_out << "GraphBase::Base::SetDebug" << endl ;
  63 }
  64
  65 char * GraphBase::Base::ObjectToString( CORBA::Object_ptr obj ) const {
  66   return _Orb->object_to_string( obj );
  67 }
  68
  69 CORBA::Object_ptr GraphBase::Base::StringToObject( char * obj ) const {
  70   return _Orb->string_to_object( obj );
  71 }
  72
  73 ostream & GraphBase::Base::AnyValue( const CORBA::Any & anAny ) {
  74   switch (anAny.type()->kind()) {
  75     case CORBA::tk_string: {
  76       char * t;
  77       anAny >>= t;
  78       *_fdebug << " " << t << " (tk_string)" << endl ;
  79       break;
  80     }
  81     case CORBA::tk_boolean: {
  82       bool b ;
  83       anAny >>= (CORBA::Any::to_boolean ) b;
  84       *_fdebug << " " << b << " (tk_boolean)" << endl ;
  85       break;
  86     }
  87     case CORBA::tk_char: {
  88       unsigned char c ;
  89       anAny >>= (CORBA::Any::to_char ) c;
  90       *_fdebug << " " << c << "(tk_char)" << endl ;
  91       break;
  92     }
  93     case CORBA::tk_short: {
  94       short s;
  95       anAny >>= s;
  96       *_fdebug << " " << s << "(tk_short)" << endl ;
  97       break;
  98     }
  99     case CORBA::tk_long: {
 100       long l;
 101       anAny >>= l;
 102       *_fdebug << " " << l << "(tk_long)" << endl ;
 103       break;
 104     }
 105     case CORBA::tk_float: {
 106       float f;
 107       anAny >>= f;
 108       *_fdebug << " " << f << "(tk_float)" << endl ;
 109       break;
 110     }
 111     case CORBA::tk_double: {
 112       double d;
 113       anAny >>= d;
 114       *_fdebug << " " << d << "(tk_double)" << endl ;
 115       break;
 116     }
 117     case CORBA::tk_objref: {
 118       try {
 119         CORBA::Object_ptr obj ;
 120         anAny >>= obj ;
 121         if ( CORBA::is_nil( obj ) ) {
 122           *_fdebug << "CORBA::Object_ptr " << obj << " nil reference (tk_object)"
 123                    << endl ;
 124         }
 125         else {
 126           *_fdebug << "CORBA::Object_ptr " << obj << "(tk_object)" << endl ;
 127         }
 128         try {
 129           char * retstr ;
 130           retstr = ObjectToString( obj ) ;
 131           *_fdebug << retstr << "(tk_object)" << endl ;
 132         }
 133         catch( ... ) {
 134           *_fdebug << "ObjectToString( CORBA::Object_ptr ) Catched ERROR" << endl ;
 135         }
 136       }
 137       catch( ... ) {
 138         *_fdebug << "anAny >>= CORBA::Object_ptr ( tk_object ) Catched ERROR" << endl ;
 139       }
 140       break;
 141     }
 142     default: {
 143       *_fdebug << " " << "(other ERROR)" << endl ;
 144     }
 145   }
 146   return *_fdebug ;
 147 }
 148
 149 string DataStreamTypeToString( const SALOME_ModuleCatalog::DataStreamType aDataStreamType ) {
 150   string aIdlType ;
 151   switch ( aDataStreamType ) {
 152   case SALOME_ModuleCatalog::DATASTREAM_UNKNOWN : {
 153     aIdlType = "Unknown" ;
 154     break;
 155   }
 156   case SALOME_ModuleCatalog::DATASTREAM_INTEGER : {
 157     aIdlType = "int" ;
 158     break;
 159   }
 160   case SALOME_ModuleCatalog::DATASTREAM_FLOAT : {
 161     aIdlType = "float" ;
 162     break;
 163   }
 164   case SALOME_ModuleCatalog::DATASTREAM_DOUBLE : {
 165     aIdlType = "double" ;
 166     break;
 167   }
 168   case SALOME_ModuleCatalog::DATASTREAM_STRING : {
 169     aIdlType = "string" ;
 170     break;
 171   }
 172   case SALOME_ModuleCatalog::DATASTREAM_BOOLEAN : {
 173     aIdlType = "bool" ;
 174     break;
 175   }
 176   default: {
 177     aIdlType = "Unknown" ;
 178     break;
 179   }
 180   }
 181   return aIdlType ;
 182 }
 183
 184 SALOME_ModuleCatalog::DataStreamType StringToDataStreamType( const char * aIdlType ) {
 185   SALOME_ModuleCatalog::DataStreamType aDataStreamType ;
 186   if ( !strcmp( aIdlType ,  "Unknown" ) ) {
 187     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN ;
 188   }
 189   else if ( !strcmp( aIdlType ,  "int" ) ) {
 190     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_INTEGER ;
 191   }
 192   else if ( !strcmp( aIdlType ,  "float" ) ) {
 193     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_FLOAT ;
 194   }
 195   else if ( !strcmp( aIdlType ,  "double" ) ) {
 196     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_DOUBLE ;
 197   }
 198   else if ( !strcmp( aIdlType ,  "string" ) ) {
 199     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_STRING ;
 200   }
 201   else if ( !strcmp( aIdlType ,  "bool" ) ) {
 202     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_BOOLEAN ;
 203   }
 204   else {
 205     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN ;
 206   }
 207   return aDataStreamType ;
 208 }
 209
 210 string KindOfDataStreamTraceToString( SUPERV::KindOfDataStreamTrace aDataStreamTrace ) {
 211   string aTrace ;
 212   switch ( aDataStreamTrace ) {
 213   case SUPERV::WithoutTrace :
 214     aTrace = "SANS";
 215     break;
 216   case SUPERV::SummaryTrace :
 217     aTrace = "SUCCINT";
 218     break;
 219   case SUPERV::DetailedTrace :
 220     aTrace = "DETAILLE";
 221     break;
 222   default :
 223     aTrace = "UndefinedTrace";
 224     break;
 225   }
 226   return aTrace ;
 227 }
 228
 229 string DataStreamDependencyToString( const SALOME_ModuleCatalog::DataStreamDependency aDataStreamDependency ) {
 230   string aDependency ;
 231   switch ( aDataStreamDependency ) {
 232   case SALOME_ModuleCatalog::DATASTREAM_UNDEFINED :
 233     aDependency = "U" ;
 234     break;
 235   case SALOME_ModuleCatalog::DATASTREAM_TEMPORAL :
 236     aDependency = "T" ;
 237     break;
 238   case SALOME_ModuleCatalog::DATASTREAM_ITERATIVE :
 239     aDependency = "I" ;
 240     break;
 241   default :
 242     aDependency = "?" ;
 243     break;
 244   }
 245
 246   return aDependency;
 247 }
 248
 249 string DataStreamToString( const SALOME_ModuleCatalog::DataStreamType aDataStreamType ) {
 250   string aStreamType ;
 251   switch ( aDataStreamType ) {
 252   case SALOME_ModuleCatalog::DATASTREAM_UNKNOWN : {
 253     aStreamType = "Unknown" ;
 254     break;
 255   }
 256   case SALOME_ModuleCatalog::DATASTREAM_INTEGER : {
 257     aStreamType = "ENTIER" ;
 258     break;
 259   }
 260   case SALOME_ModuleCatalog::DATASTREAM_FLOAT : {
 261     aStreamType = "REEL" ;
 262     break;
 263   }
 264   case SALOME_ModuleCatalog::DATASTREAM_DOUBLE : {
 265     aStreamType = "DOUBLE" ;
 266     break;
 267   }
 268   case SALOME_ModuleCatalog::DATASTREAM_STRING : {
 269     aStreamType = "CHAINE" ;
 270     break;
 271   }
 272   case SALOME_ModuleCatalog::DATASTREAM_BOOLEAN : {
 273     aStreamType = "LOGIQUE" ;
 274     break;
 275   }
 276   default: {
 277     aStreamType = "?" ;
 278     break;
 279   }
 280   }
 281   return aStreamType ;
 282 }
 283
 284 ostream & operator<< (ostream & f ,const SALOME_ModuleCatalog::DataStreamType & s ) {
 285   switch (s) {
 286   case SALOME_ModuleCatalog::DATASTREAM_UNKNOWN :
 287     f << "DATASTREAM_UNKNOWN";
 288     break;
 289   case SALOME_ModuleCatalog::DATASTREAM_INTEGER :
 290     f << "DATASTREAM_INTEGER";
 291     break;
 292   case SALOME_ModuleCatalog::DATASTREAM_FLOAT :
 293     f << "DATASTREAM_FLOAT";
 294     break;
 295   case SALOME_ModuleCatalog::DATASTREAM_DOUBLE :
 296     f << "DATASTREAM_DOUBLE";
 297     break;
 298   case SALOME_ModuleCatalog::DATASTREAM_STRING :
 299     f << "DATASTREAM_STRING";
 300     break;
 301   case SALOME_ModuleCatalog::DATASTREAM_BOOLEAN :
 302     f << "DATASTREAM_BOOLEAN";
 303     break;
 304   default :
 305     f << "DATASTREAM_UNKNOWN";
 306     break;
 307   }
 308
 309   return f;
 310 }
 311