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