src/SALOMEDS/SALOMEDS_Driver_i.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/
  19 //
  20
  21
  22 #include "SALOMEDS_Driver_i.hxx"
  23 #include "utilities.h"
  24 #include "SALOMEDS_SObject_i.hxx"
  25 #include "SALOMEDS_SComponent_i.hxx"
  26 #include "SALOMEDS_Study_i.hxx"
  27 #include "SALOMEDS.hxx"
  28 #include <stdlib.h>
  29
  30 using namespace std;
  31
  32 SALOMEDS_Driver_i::~SALOMEDS_Driver_i()
  33 {
  34 }
  35
  36 unsigned char* SALOMEDS_Driver_i::Save(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->Save(sco.in(), url, isMultiFile);
  46   SALOMEDS::lock();
  47   theStreamLength = aStream->length();
  48   unsigned char* aRetStream = NULL;
  49   if (theStreamLength > 0) {
  50     aRetStream = new unsigned char[theStreamLength];
  51     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
  52   }
  53   return aRetStream;
  54 }
  55
  56 unsigned char* SALOMEDS_Driver_i::SaveASCII(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  57                                             const TCollection_AsciiString& theURL,
  58                                             long& theStreamLength,
  59                                             bool isMultiFile)
  60 {
  61   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  62   SALOMEDS::TMPFile_var aStream;
  63   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
  64   SALOMEDS::unlock();
  65   aStream = _driver->SaveASCII(sco.in(), url, isMultiFile);
  66   SALOMEDS::lock();
  67   theStreamLength = aStream->length();
  68   unsigned char* aRetStream = NULL;
  69   if (theStreamLength > 0) {
  70     aRetStream = new unsigned char[theStreamLength];
  71     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
  72   }
  73   return aRetStream;
  74 }
  75
  76 bool SALOMEDS_Driver_i::Load(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  77                              const unsigned char* theStream,
  78                              const long theStreamLength,
  79                              const TCollection_AsciiString& theURL,
  80                              bool isMultiFile)
  81 {
  82   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  83   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
  84   CORBA::Octet* anOctetBuf = (CORBA::Octet*)theStream;
  85
  86   SALOMEDS::TMPFile_var aStream;
  87   if (theStreamLength > 0)
  88     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
  89   else
  90     aStream = new SALOMEDS::TMPFile(0);
  91
  92   SALOMEDS::unlock();
  93   bool isOk = _driver->Load(sco.in(), aStream.in(), url, isMultiFile);
  94   SALOMEDS::lock();
  95   return isOk;
  96 }
  97
  98 bool SALOMEDS_Driver_i::LoadASCII(const Handle(SALOMEDSImpl_SComponent)& theComponent,
  99                                   const unsigned char* theStream,
 100                                   const long theStreamLength,
 101                                   const TCollection_AsciiString& theURL,
 102                                   bool isMultiFile)
 103 {
 104   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
 105   CORBA::String_var url = CORBA::string_dup(theURL.ToCString());
 106   CORBA::Octet* anOctetBuf = (CORBA::Octet*)theStream;
 107
 108   SALOMEDS::TMPFile_var aStream;
 109   if(theStreamLength > 0)
 110     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 111   else
 112     aStream = new SALOMEDS::TMPFile(0);
 113
 114   SALOMEDS::unlock();
 115   bool isOk = _driver->LoadASCII(sco.in(), aStream.in(), url, isMultiFile);
 116   SALOMEDS::lock();
 117   return isOk;
 118 }
 119
 120 void SALOMEDS_Driver_i::Close(const Handle(SALOMEDSImpl_SComponent)& theComponent)
 121 {
 122   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
 123   SALOMEDS::unlock();
 124   _driver->Close(sco.in());
 125   SALOMEDS::lock();
 126 }
 127
 128
 129
 130 TCollection_AsciiString SALOMEDS_Driver_i::IORToLocalPersistentID(const Handle(SALOMEDSImpl_SObject)& theSObject,
 131                                                                   const TCollection_AsciiString& IORString,
 132                                                                   bool isMultiFile,
 133                                                                   bool isASCII)
 134 {
 135   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theSObject, _orb);
 136   CORBA::String_var ior = CORBA::string_dup(IORString.ToCString());
 137   SALOMEDS::unlock();
 138   CORBA::String_var pers_string =_driver->IORToLocalPersistentID(so.in(), ior.in(), isMultiFile, isASCII);
 139   SALOMEDS::lock();
 140   return TCollection_AsciiString(pers_string);
 141 }
 142
 143
 144 TCollection_AsciiString SALOMEDS_Driver_i::LocalPersistentIDToIOR(const Handle(SALOMEDSImpl_SObject)& theObject,
 145                                                                   const TCollection_AsciiString& aLocalPersistentID,
 146                                                                   bool isMultiFile,
 147                                                                   bool isASCII)
 148 {
 149   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 150   CORBA::String_var pers_string = CORBA::string_dup(aLocalPersistentID.ToCString());
 151   SALOMEDS::unlock();
 152   CORBA::String_var IOR = _driver->LocalPersistentIDToIOR(so.in(), pers_string.in(), isMultiFile, isASCII);
 153   SALOMEDS::lock();
 154   return TCollection_AsciiString(IOR);
 155 }
 156
 157 bool SALOMEDS_Driver_i::CanCopy(const Handle(SALOMEDSImpl_SObject)& theObject)
 158 {
 159   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 160   SALOMEDS::unlock();
 161   bool isOk = _driver->CanCopy(so.in());
 162   SALOMEDS::lock();
 163   return isOk;
 164 }
 165
 166
 167 unsigned char* SALOMEDS_Driver_i::CopyFrom(const Handle(SALOMEDSImpl_SObject)& theObject,
 168                                            int& theObjectID,
 169                                            long& theStreamLength)
 170 {
 171   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 172   SALOMEDS::TMPFile_var aStream;
 173   CORBA::Long anObjectID;
 174
 175   SALOMEDS::unlock();
 176   aStream = _driver->CopyFrom(so.in(), anObjectID);
 177   SALOMEDS::lock();
 178
 179   theObjectID = anObjectID;
 180   theStreamLength = aStream->length();
 181
 182   unsigned char* aRetStream = NULL;
 183   if(theStreamLength > 0) {
 184     aRetStream = new unsigned char[theStreamLength];
 185     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
 186   }
 187
 188   return aRetStream;
 189 }
 190
 191 bool SALOMEDS_Driver_i::CanPaste(const TCollection_AsciiString& theComponentName, int theObjectID)
 192 {
 193   SALOMEDS::unlock();
 194   bool canPaste = _driver->CanPaste(theComponentName.ToCString(), theObjectID);
 195   SALOMEDS::lock();
 196   return canPaste;
 197 }
 198
 199 TCollection_AsciiString SALOMEDS_Driver_i::PasteInto(const unsigned char* theStream,
 200                                                      const long theStreamLength,
 201                                                      int theObjectID,
 202                                                      const Handle(SALOMEDSImpl_SObject)& theObject)
 203 {
 204   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 205   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
 206
 207   SALOMEDS::TMPFile_var aStream;
 208   if(theStreamLength > 0)
 209     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 210   else
 211     aStream = new SALOMEDS::TMPFile(0);
 212
 213   SALOMEDS::unlock();
 214   SALOMEDS::SObject_var ret_so = _driver->PasteInto(aStream.in(), theObjectID, so.in());
 215   SALOMEDS::lock();
 216
 217   return TCollection_AsciiString((char*)ret_so->GetID());
 218 }
 219
 220 unsigned char* SALOMEDS_Driver_i::DumpPython(const Handle(SALOMEDSImpl_Study)& theStudy,
 221                                              bool isPublished,
 222                                              bool& isValidScript,
 223                                              long& theStreamLength)
 224 {
 225   SALOMEDS_Study_i *  st_servant = new SALOMEDS_Study_i (theStudy, _orb);
 226   SALOMEDS::Study_var st  = SALOMEDS::Study::_narrow(st_servant->_this());
 227   Engines::TMPFile_var aStream;
 228   CORBA::Boolean aValidScript, aPublished;
 229   aPublished = isPublished;
 230   Engines::Component_ptr aComponent = Engines::Component::_narrow(_driver);
 231   SALOMEDS::unlock();
 232   aStream = aComponent->DumpPython(st.in(), aPublished, aValidScript);
 233   SALOMEDS::lock();
 234   isValidScript = aValidScript;
 235   theStreamLength = aStream->length();
 236   unsigned char* aRetStream = NULL;
 237
 238   if(theStreamLength > 0) {
 239     aRetStream = new unsigned char[theStreamLength];
 240     memcpy(aRetStream, aStream->NP_data(), theStreamLength);
 241   }
 242
 243   return aRetStream;
 244 }
 245
 246 //###############################################################################################################
 247 //                                          SALOMEDS_DriverFactory
 248 //###############################################################################################################
 249
 250 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType
 251                      (const TCollection_AsciiString& theComponentType)
 252 {
 253   CORBA::Object_var obj;
 254
 255   TCollection_AsciiString aFactoryType;
 256   if (theComponentType == "SUPERV") aFactoryType = "SuperVisionContainer";
 257   else aFactoryType = "FactoryServer";
 258
 259   SALOMEDS::unlock();
 260   obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component
 261     (aFactoryType.ToCString(), theComponentType.ToCString());
 262   SALOMEDS::lock();
 263
 264   if (CORBA::is_nil(obj)) {
 265     obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component
 266       ("FactoryServerPy", theComponentType.ToCString());
 267   }
 268
 269   if (!CORBA::is_nil(obj)) {
 270     SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
 271     return new SALOMEDS_Driver_i(aDriver, _orb);
 272   }
 273
 274   return NULL;
 275 }
 276
 277 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByIOR(const TCollection_AsciiString& theIOR)
 278 {
 279   CORBA::Object_var obj;
 280   obj = _orb->string_to_object(theIOR.ToCString());
 281
 282   if (!CORBA::is_nil(obj)) {
 283     SALOMEDS::Driver_var aDriver = SALOMEDS::Driver::_narrow(obj);
 284     return new SALOMEDS_Driver_i(aDriver, _orb);
 285   }
 286
 287   return NULL;
 288 }