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