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.salome-platform.org/ or email : webmaster.salome@opencascade.com
  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 #if OMNIORB_VERSION >= 4
 121         anAny >>= (CORBA::Any::to_object ) obj ;
 122 #else
 123         anAny >>= obj ;
 124 #endif
 125         if ( CORBA::is_nil( obj ) ) {
 126           *_fdebug << "CORBA::Object_ptr " << obj << " nil reference (tk_object)"
 127                    << endl ;
 128         }
 129         else {
 130           *_fdebug << "CORBA::Object_ptr " << obj << "(tk_object)" << endl ;
 131         }
 132         try {
 133           char * retstr ;
 134           retstr = ObjectToString( obj ) ;
 135           *_fdebug << retstr << "(tk_object)" << endl ;
 136         }
 137         catch( ... ) {
 138           *_fdebug << "ObjectToString( CORBA::Object_ptr ) Catched ERROR" << endl ;
 139         }
 140       }
 141       catch( ... ) {
 142         *_fdebug << "anAny >>= CORBA::Object_ptr ( tk_object ) Catched ERROR" << endl ;
 143       }
 144       break;
 145     }
 146     default: {
 147       *_fdebug << " " << "(other ERROR)" << endl ;
 148     }
 149   }
 150   return *_fdebug ;
 151 }
 152
 153 string DataStreamTypeToString( const SALOME_ModuleCatalog::DataStreamType aDataStreamType ) {
 154   string aIdlType ;
 155   switch ( aDataStreamType ) {
 156   case SALOME_ModuleCatalog::DATASTREAM_UNKNOWN : {
 157     aIdlType = "Unknown" ;
 158     break;
 159   }
 160   case SALOME_ModuleCatalog::DATASTREAM_INTEGER : {
 161     aIdlType = "int" ;
 162     break;
 163   }
 164   case SALOME_ModuleCatalog::DATASTREAM_FLOAT : {
 165     aIdlType = "float" ;
 166     break;
 167   }
 168   case SALOME_ModuleCatalog::DATASTREAM_DOUBLE : {
 169     aIdlType = "double" ;
 170     break;
 171   }
 172   case SALOME_ModuleCatalog::DATASTREAM_STRING : {
 173     aIdlType = "string" ;
 174     break;
 175   }
 176   case SALOME_ModuleCatalog::DATASTREAM_BOOLEAN : {
 177     aIdlType = "bool" ;
 178     break;
 179   }
 180   default: {
 181     aIdlType = "Unknown" ;
 182     break;
 183   }
 184   }
 185   return aIdlType ;
 186 }
 187
 188 SALOME_ModuleCatalog::DataStreamType StringToDataStreamType( const char * aIdlType ) {
 189   SALOME_ModuleCatalog::DataStreamType aDataStreamType ;
 190   if ( !strcmp( aIdlType ,  "Unknown" ) ) {
 191     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN ;
 192   }
 193   else if ( !strcmp( aIdlType ,  "int" ) ) {
 194     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_INTEGER ;
 195   }
 196   else if ( !strcmp( aIdlType ,  "float" ) ) {
 197     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_FLOAT ;
 198   }
 199   else if ( !strcmp( aIdlType ,  "double" ) ) {
 200     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_DOUBLE ;
 201   }
 202   else if ( !strcmp( aIdlType ,  "string" ) ) {
 203     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_STRING ;
 204   }
 205   else if ( !strcmp( aIdlType ,  "bool" ) ) {
 206     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_BOOLEAN ;
 207   }
 208   else {
 209     aDataStreamType = SALOME_ModuleCatalog::DATASTREAM_UNKNOWN ;
 210   }
 211   return aDataStreamType ;
 212 }
 213
 214 string KindOfDataStreamTraceToString( SUPERV::KindOfDataStreamTrace aDataStreamTrace ) {
 215   string aTrace ;
 216   switch ( aDataStreamTrace ) {
 217   case SUPERV::WithoutTrace :
 218     aTrace = "SANS";
 219     break;
 220   case SUPERV::SummaryTrace :
 221     aTrace = "SUCCINT";
 222     break;
 223   case SUPERV::DetailedTrace :
 224     aTrace = "DETAILLE";
 225     break;
 226   default :
 227     aTrace = "UndefinedTrace";
 228     break;
 229   }
 230   return aTrace ;
 231 }
 232
 233 string DataStreamDependencyToString( const SALOME_ModuleCatalog::DataStreamDependency aDataStreamDependency ) {
 234   string aDependency ;
 235   switch ( aDataStreamDependency ) {
 236   case SALOME_ModuleCatalog::DATASTREAM_UNDEFINED :
 237     aDependency = "U" ;
 238     break;
 239   case SALOME_ModuleCatalog::DATASTREAM_TEMPORAL :
 240     aDependency = "T" ;
 241     break;
 242   case SALOME_ModuleCatalog::DATASTREAM_ITERATIVE :
 243     aDependency = "I" ;
 244     break;
 245   default :
 246     aDependency = "?" ;
 247     break;
 248   }
 249
 250   return aDependency;
 251 }
 252
 253 string DataStreamToString( const SALOME_ModuleCatalog::DataStreamType aDataStreamType ) {
 254   string aStreamType ;
 255   switch ( aDataStreamType ) {
 256   case SALOME_ModuleCatalog::DATASTREAM_UNKNOWN : {
 257     aStreamType = "Unknown" ;
 258     break;
 259   }
 260   case SALOME_ModuleCatalog::DATASTREAM_INTEGER : {
 261     aStreamType = "ENTIER" ;
 262     break;
 263   }
 264   case SALOME_ModuleCatalog::DATASTREAM_FLOAT : {
 265     aStreamType = "REEL" ;
 266     break;
 267   }
 268   case SALOME_ModuleCatalog::DATASTREAM_DOUBLE : {
 269     aStreamType = "DOUBLE" ;
 270     break;
 271   }
 272   case SALOME_ModuleCatalog::DATASTREAM_STRING : {
 273     aStreamType = "CHAINE" ;
 274     break;
 275   }
 276   case SALOME_ModuleCatalog::DATASTREAM_BOOLEAN : {
 277     aStreamType = "LOGIQUE" ;
 278     break;
 279   }
 280   default: {
 281     aStreamType = "?" ;
 282     break;
 283   }
 284   }
 285   return aStreamType ;
 286 }
 287
 288 ostream & operator<< (ostream & f ,const SALOME_ModuleCatalog::DataStreamType & s ) {
 289   switch (s) {
 290   case SALOME_ModuleCatalog::DATASTREAM_UNKNOWN :
 291     f << "DATASTREAM_UNKNOWN";
 292     break;
 293   case SALOME_ModuleCatalog::DATASTREAM_INTEGER :
 294     f << "DATASTREAM_INTEGER";
 295     break;
 296   case SALOME_ModuleCatalog::DATASTREAM_FLOAT :
 297     f << "DATASTREAM_FLOAT";
 298     break;
 299   case SALOME_ModuleCatalog::DATASTREAM_DOUBLE :
 300     f << "DATASTREAM_DOUBLE";
 301     break;
 302   case SALOME_ModuleCatalog::DATASTREAM_STRING :
 303     f << "DATASTREAM_STRING";
 304     break;
 305   case SALOME_ModuleCatalog::DATASTREAM_BOOLEAN :
 306     f << "DATASTREAM_BOOLEAN";
 307     break;
 308   default :
 309     f << "DATASTREAM_UNKNOWN";
 310     break;
 311   }
 312
 313   return f;
 314 }
 315