src/SALOMEDS/SALOMEDS_Driver_i.cxx

   1
   2
   3 #include "SALOMEDS_Driver_i.hxx"
   4 #include "utilities.h"
   5 #include "SALOMEDS_SObject_i.hxx"
   6 #include "SALOMEDS_SComponent_i.hxx"
   7 #include "SALOMEDS_Study_i.hxx"
   8 #include "SALOMEDS.hxx"
   9 #include <stdlib.h>
  10
  11 using namespace std;
  12
  13 SALOMEDS_Driver_i::~SALOMEDS_Driver_i()
  14 {
  15 }
  16
  17 unsigned char* SALOMEDS_Driver_i::Save(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  18                                        const TCollection_AsciiString& theURL,
  19                                        long& theStreamLength,
  20                                        bool isMultiFile)
  21 {
  22   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  23   SALOMEDS::TMPFile_var aStream;
  24   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
  25   SALOMEDS::unlock();
  26   aStream = _driver->Save(sco.in(), url, isMultiFile);
  27   theStreamLength = aStream->length();
  28   unsigned char* aRetStream = NULL;
  29   if(theStreamLength > 0) {
  30     aRetStream = new unsigned char[theStreamLength];
  31     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
  32   }
  33   return aRetStream;
  34 }
  35
  36 unsigned char* SALOMEDS_Driver_i::SaveASCII(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  37                                             const TCollection_AsciiString& theURL,
  38                                             long& theStreamLength,
  39                                             bool isMultiFile)
  40 {
  41   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  42   SALOMEDS::TMPFile_var aStream;
  43   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
  44   SALOMEDS::unlock();
  45   aStream = _driver->SaveASCII(sco.in(), url, isMultiFile);
  46   theStreamLength = aStream->length();
  47   unsigned char* aRetStream = NULL;
  48   if(theStreamLength > 0) {
  49     aRetStream = new unsigned char[theStreamLength];
  50     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
  51   }
  52   return aRetStream;
  53 }
  54
  55 bool SALOMEDS_Driver_i::Load(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  56                              const unsigned char* theStream,
  57                              const long theStreamLength,
  58                              const TCollection_AsciiString& theURL,
  59                              bool isMultiFile)
  60 {
  61   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  62   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
  63   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
  64
  65   SALOMEDS::TMPFile_var aStream;
  66   if(theStreamLength > 0)
  67     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
  68   else
  69     aStream = new SALOMEDS::TMPFile(0);
  70
  71   SALOMEDS::unlock();
  72   return _driver->Load(sco.in(), aStream.in(), url, isMultiFile);
  73 }
  74
  75 bool SALOMEDS_Driver_i::LoadASCII(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  76                                   const unsigned char* theStream,
  77                                   const long theStreamLength,
  78                                   const TCollection_AsciiString& theURL,
  79                                   bool isMultiFile)
  80 {
  81   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  82   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
  83   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
  84
  85   SALOMEDS::TMPFile_var aStream;
  86   if(theStreamLength > 0)
  87     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
  88   else
  89     aStream = new SALOMEDS::TMPFile(0);
  90
  91   SALOMEDS::unlock();
  92   return _driver->LoadASCII(sco.in(), aStream.in(), url, isMultiFile);
  93 }
  94
  95 void SALOMEDS_Driver_i::Close(const Handle(SALOMEDSImpl_SComponent)& theComponent)
  96 {
  97   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  98   SALOMEDS::unlock();
  99   _driver->Close(sco.in());
 100 }
 101
 102
 103
 104 TCollection_AsciiString SALOMEDS_Driver_i::IORToLocalPersistentID(const Handle(SALOMEDSImpl_SObject)& theSObject,
 105                                                                   const TCollection_AsciiString& IORString,
 106                                                                   bool isMultiFile,
 107                                                                   bool isASCII)
 108 {
 109   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theSObject, _orb);
 110   CORBA::String_var ior = CORBA::string_dup(IORString.ToCString());
 111   SALOMEDS::unlock();
 112   CORBA::String_var pers_string =_driver->IORToLocalPersistentID(so.in(), ior.in(), isMultiFile, isASCII);
 113   return TCollection_AsciiString(pers_string);
 114 }
 115
 116
 117 TCollection_AsciiString SALOMEDS_Driver_i::LocalPersistentIDToIOR(const Handle(SALOMEDSImpl_SObject)& theObject,
 118                                                                   const TCollection_AsciiString& aLocalPersistentID,
 119                                                                   bool isMultiFile,
 120                                                                   bool isASCII)
 121 {
 122   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 123   CORBA::String_var pers_string = CORBA::string_dup(aLocalPersistentID.ToCString());
 124   SALOMEDS::unlock();
 125   CORBA::String_var IOR =_driver->LocalPersistentIDToIOR(so.in(), pers_string.in(), isMultiFile, isASCII);
 126   return TCollection_AsciiString(IOR);
 127 }
 128
 129 bool SALOMEDS_Driver_i::CanCopy(const Handle(SALOMEDSImpl_SObject)& theObject)
 130 {
 131   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 132   SALOMEDS::unlock();
 133   return _driver->CanCopy(so.in());
 134 }
 135
 136
 137 unsigned char* SALOMEDS_Driver_i::CopyFrom(const Handle(SALOMEDSImpl_SObject)& theObject,
 138                                            int& theObjectID,
 139                                            long& theStreamLength)
 140 {
 141   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 142   SALOMEDS::TMPFile_var aStream;
 143   CORBA::Long anObjectID;
 144
 145   SALOMEDS::unlock();
 146   aStream = _driver->CopyFrom(so.in(), anObjectID);
 147
 148   theObjectID = anObjectID;
 149   theStreamLength = aStream->length();
 150
 151   unsigned char* aRetStream = NULL;
 152   if(theStreamLength > 0) {
 153     aRetStream = new unsigned char[theStreamLength];
 154     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
 155   }
 156
 157   return aRetStream;
 158 }
 159
 160 bool SALOMEDS_Driver_i::CanPaste(const TCollection_AsciiString& theComponentName, int theObjectID)
 161 {
 162   SALOMEDS::unlock();
 163   return _driver->CanPaste(theComponentName.ToCString(), theObjectID);
 164 }
 165
 166 TCollection_AsciiString SALOMEDS_Driver_i::PasteInto(const unsigned char* theStream,
 167                                                      const long theStreamLength,
 168                                                      int theObjectID,
 169                                                      const Handle(SALOMEDSImpl_SObject)& theObject)
 170 {
 171   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 172   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
 173
 174   SALOMEDS::TMPFile_var aStream;
 175   if(theStreamLength > 0)
 176     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 177   else
 178     aStream = new SALOMEDS::TMPFile(0);
 179
 180   SALOMEDS::unlock();
 181   SALOMEDS::SObject_var ret_so = _driver->PasteInto(aStream.in(), theObjectID, so.in());
 182
 183   return TCollection_AsciiString((char*)ret_so->GetID());
 184 }
 185
 186 unsigned char* SALOMEDS_Driver_i::DumpPython(const Handle(SALOMEDSImpl_Study)& theStudy,
 187                                              bool isPublished,
 188                                              bool& isValidScript,
 189                                              long& theStreamLength)
 190 {
 191   SALOMEDS_Study_i *  st_servant = new SALOMEDS_Study_i (theStudy, _orb);
 192   SALOMEDS::Study_var st  = SALOMEDS::Study::_narrow(st_servant->_this());
 193   Engines::TMPFile_var aStream;
 194   CORBA::Boolean aValidScript, aPublished;
 195   aPublished = isPublished;
 196   Engines::Component_ptr aComponent = Engines::Component::_narrow(_driver);
 197   SALOMEDS::unlock();
 198   aStream = aComponent->DumpPython(st.in(), aPublished, aValidScript);
 199   SALOMEDS::lock();
 200   isValidScript = aValidScript;
 201   theStreamLength = aStream->length();
 202   unsigned char* aRetStream = NULL;
 203
 204   if(theStreamLength > 0) {
 205     aRetStream = new unsigned char[theStreamLength];
 206     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
 207   }
 208
 209   return aRetStream;
 210 }
 211
 212 //###############################################################################################################
 213 //                                          SALOMEDS_DriverFactory
 214 //###############################################################################################################
 215
 216 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType(const TCollection_AsciiString& theComponentType)
 217 {
 218   CORBA::Object_var obj;
 219
 220   TCollection_AsciiString aFactoryType;
 221   if (theComponentType == "SUPERV") aFactoryType = "SuperVisionContainer";
 222   else aFactoryType = "FactoryServer";
 223
 224   SALOMEDS::unlock();
 225   obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component(aFactoryType.ToCString(),
 226                                                                   theComponentType.ToCString());
 227
 228   if (CORBA::is_nil(obj)) {
 229     obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component("FactoryServerPy", theComponentType.ToCString());
 230   }
 231
 232   if (!CORBA::is_nil(obj)) {
 233     SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
 234     return new SALOMEDS_Driver_i(aDriver, _orb);
 235   }
 236
 237   return NULL;
 238 }
 239
 240 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByIOR(const TCollection_AsciiString& theIOR)
 241 {
 242   CORBA::Object_var obj;
 243   obj = _orb->string_to_object(theIOR.ToCString());
 244
 245   if (!CORBA::is_nil(obj)) {
 246     SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
 247     return new SALOMEDS_Driver_i(aDriver, _orb);
 248   }
 249
 250   return NULL;
 251 }