src/SALOMEDS/SALOMEDS_Driver_i.cxx

   1 // Copyright (C) 2007-2014  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 // Copyright (C) 2003-2007  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, or (at your option) any later version.
  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 #include "SALOMEDS_Driver_i.hxx"
  24 #include "SALOMEDS_TMPFile_i.hxx"
  25 #include "utilities.h"
  26 #include "SALOMEDS_SObject_i.hxx"
  27 #include "SALOMEDS_SComponent_i.hxx"
  28 #include "SALOMEDS_Study_i.hxx"
  29 #include "SALOMEDS.hxx"
  30 #include <SALOMEDSImpl_IParameters.hxx>
  31 #include <stdlib.h>
  32
  33 #include CORBA_CLIENT_HEADER(SALOME_Session)
  34
  35 SALOMEDS_Driver_i::SALOMEDS_Driver_i(Engines::EngineComponent_ptr theEngine, CORBA::ORB_ptr theORB)
  36 {
  37   // engine should not be null - component is supposed to be inherited from Engines::EngineComponent
  38   _engine = Engines::EngineComponent::_duplicate(theEngine);
  39   // driver can be null - if component interface does not inherit SALOMEDS::Driver
  40   _driver = SALOMEDS::Driver::_narrow(theEngine);
  41   _orb = CORBA::ORB::_duplicate(theORB);
  42 }
  43
  44 SALOMEDS_Driver_i::SALOMEDS_Driver_i(SALOMEDS::Driver_ptr theDriver, CORBA::ORB_ptr theORB)
  45 {
  46   // driver can be null - if component interface does not inherit SALOMEDS::Driver
  47   _driver = SALOMEDS::Driver::_duplicate(theDriver);
  48   // engine can be null - since it is narrowed from SALOMEDS::Driver ptr which can be null
  49   _engine = Engines::EngineComponent::_narrow(theDriver);
  50   _orb = CORBA::ORB::_duplicate(theORB);
  51 }
  52
  53 SALOMEDS_Driver_i::~SALOMEDS_Driver_i()
  54 {
  55 }
  56
  57 std::string SALOMEDS_Driver_i::GetIOR()
  58 {
  59   std::string ior = "";
  60   if ( !CORBA::is_nil(_engine) ) {
  61     CORBA::String_var cior = _orb->object_to_string(_engine);
  62     ior = cior;
  63   }
  64   return ior;
  65 }
  66
  67 SALOMEDSImpl_TMPFile* SALOMEDS_Driver_i::Save(const SALOMEDSImpl_SComponent& theComponent,
  68                                               const std::string& theURL,
  69                                               long& theStreamLength,
  70                                               bool isMultiFile)
  71 {
  72   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  73   CORBA::String_var url = CORBA::string_dup(theURL.c_str());
  74
  75   SALOMEDS::unlock();
  76   SALOMEDS::TMPFile_var aStream;
  77
  78   if ( !CORBA::is_nil(_driver) )
  79     aStream = _driver->Save(sco.in(), url, isMultiFile);
  80
  81   SALOMEDSImpl_TMPFile* aTMPFile = new SALOMEDS_TMPFile_i(aStream._retn());
  82   theStreamLength = aTMPFile->Size();
  83
  84   sco->UnRegister();
  85   SALOMEDS::lock();
  86
  87   return aTMPFile;
  88 }
  89
  90 SALOMEDSImpl_TMPFile* SALOMEDS_Driver_i::SaveASCII(const SALOMEDSImpl_SComponent& theComponent,
  91                                                    const std::string& theURL,
  92                                                    long& theStreamLength,
  93                                                    bool isMultiFile)
  94 {
  95   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
  96   CORBA::String_var url = CORBA::string_dup(theURL.c_str());
  97
  98   SALOMEDS::unlock();
  99   SALOMEDS::TMPFile_var aStream;
 100
 101   if ( !CORBA::is_nil(_driver) )
 102     aStream = _driver->SaveASCII(sco.in(), url, isMultiFile);
 103
 104   SALOMEDSImpl_TMPFile* aTMPFile = new SALOMEDS_TMPFile_i(aStream._retn());
 105   theStreamLength = aTMPFile->Size();
 106
 107   sco->UnRegister();
 108   SALOMEDS::lock();
 109
 110   return aTMPFile;
 111 }
 112
 113 bool SALOMEDS_Driver_i::Load(const SALOMEDSImpl_SComponent& theComponent,
 114                              const unsigned char* theStream,
 115                              const long theStreamLength,
 116                              const std::string& theURL,
 117                              bool isMultiFile)
 118 {
 119   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
 120   CORBA::String_var url = CORBA::string_dup(theURL.c_str());
 121   CORBA::Octet* anOctetBuf = (CORBA::Octet*)theStream;
 122
 123   SALOMEDS::TMPFile_var aStream;
 124   if (theStreamLength > 0)
 125     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 126   else
 127     aStream = new SALOMEDS::TMPFile(0);
 128
 129   SALOMEDS::unlock();
 130   bool isOk = false;
 131
 132   if ( !CORBA::is_nil(_driver) )
 133     isOk = _driver->Load(sco.in(), aStream.in(), url, isMultiFile);
 134
 135   sco->UnRegister();
 136   SALOMEDS::lock();
 137   return isOk;
 138 }
 139
 140 bool SALOMEDS_Driver_i::LoadASCII(const SALOMEDSImpl_SComponent& theComponent,
 141                                   const unsigned char* theStream,
 142                                   const long theStreamLength,
 143                                   const std::string& theURL,
 144                                   bool isMultiFile)
 145 {
 146   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
 147   CORBA::String_var url = CORBA::string_dup(theURL.c_str());
 148   CORBA::Octet* anOctetBuf = (CORBA::Octet*)theStream;
 149
 150   SALOMEDS::TMPFile_var aStream;
 151   if(theStreamLength > 0)
 152     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 153   else
 154     aStream = new SALOMEDS::TMPFile(0);
 155
 156   SALOMEDS::unlock();
 157   bool isOk = false;
 158
 159   if ( !CORBA::is_nil(_driver) )
 160     isOk = _driver->LoadASCII(sco.in(), aStream.in(), url, isMultiFile);
 161
 162   sco->UnRegister();
 163   SALOMEDS::lock();
 164   return isOk;
 165 }
 166
 167 void SALOMEDS_Driver_i::Close(const SALOMEDSImpl_SComponent& theComponent)
 168 {
 169   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (theComponent, _orb);
 170
 171   SALOMEDS::unlock();
 172   if ( !CORBA::is_nil(_driver) )
 173     _driver->Close(sco.in());
 174   sco->UnRegister();
 175   SALOMEDS::lock();
 176 }
 177
 178 std::string SALOMEDS_Driver_i::ComponentDataType()
 179 {
 180   std::string dtype = "";
 181   if ( !CORBA::is_nil(_driver) ) {
 182     CORBA::String_var type = _driver->ComponentDataType();
 183     dtype = type;
 184   }
 185   return dtype;
 186 }
 187
 188 std::string SALOMEDS_Driver_i::Version()
 189 {
 190   return !CORBA::is_nil( _engine ) ? _engine->getVersion() : std::string("");
 191 }
 192
 193 std::string SALOMEDS_Driver_i::IORToLocalPersistentID(const SALOMEDSImpl_SObject& theSObject,
 194                                                       const std::string& IORString,
 195                                                       bool isMultiFile,
 196                                                       bool isASCII)
 197 {
 198   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theSObject, _orb);
 199   SALOMEDS::unlock();
 200
 201   std::string pstr = "";
 202
 203   if ( !CORBA::is_nil(_driver) ) {
 204     CORBA::String_var pers_string =_driver->IORToLocalPersistentID(so.in(), IORString.c_str(),
 205                                                                    isMultiFile, isASCII);
 206     pstr = pers_string;
 207   }
 208
 209   so->UnRegister();
 210   SALOMEDS::lock();
 211
 212   return pstr;
 213 }
 214
 215
 216 std::string SALOMEDS_Driver_i::LocalPersistentIDToIOR(const SALOMEDSImpl_SObject& theObject,
 217                                                       const std::string& aLocalPersistentID,
 218                                                       bool isMultiFile,
 219                                                       bool isASCII)
 220 {
 221   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 222   CORBA::String_var pers_string = CORBA::string_dup(aLocalPersistentID.c_str());
 223   SALOMEDS::unlock();
 224
 225   std::string ior = "";
 226
 227   if ( !CORBA::is_nil(_driver) ) {
 228     CORBA::String_var IOR = _driver->LocalPersistentIDToIOR(so.in(), pers_string.in(), isMultiFile, isASCII);
 229     ior = IOR;
 230   }
 231   so->UnRegister();
 232   SALOMEDS::lock();
 233   return ior;
 234 }
 235
 236 bool SALOMEDS_Driver_i::CanCopy(const SALOMEDSImpl_SObject& theObject)
 237 {
 238   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 239
 240   SALOMEDS::unlock();
 241   bool isOk = false;
 242
 243   if ( !CORBA::is_nil(_driver) )
 244     isOk = _driver->CanCopy(so.in());
 245
 246   so->UnRegister();
 247   SALOMEDS::lock();
 248
 249   return isOk;
 250 }
 251
 252
 253 SALOMEDSImpl_TMPFile* SALOMEDS_Driver_i::CopyFrom(const SALOMEDSImpl_SObject& theObject,
 254                                                   int& theObjectID,
 255                                                   long& theStreamLength)
 256 {
 257   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 258
 259   SALOMEDS::unlock();
 260   CORBA::Long anObjectID;
 261   SALOMEDS::TMPFile_var aStream;
 262
 263   if ( !CORBA::is_nil(_driver) )
 264     aStream = _driver->CopyFrom(so.in(), anObjectID);
 265
 266   SALOMEDSImpl_TMPFile* aTMPFile = new SALOMEDS_TMPFile_i(aStream._retn());
 267   theStreamLength = aTMPFile->Size();
 268   theObjectID = anObjectID;
 269
 270   so->UnRegister();
 271   SALOMEDS::lock();
 272
 273   return aTMPFile;
 274 }
 275
 276 bool SALOMEDS_Driver_i::CanPaste(const std::string& theComponentName, int theObjectID)
 277 {
 278   SALOMEDS::unlock();
 279   bool canPaste = false;
 280
 281   if ( !CORBA::is_nil(_driver) )
 282     canPaste = _driver->CanPaste(theComponentName.c_str(), theObjectID);
 283
 284   SALOMEDS::lock();
 285   return canPaste;
 286 }
 287
 288 std::string SALOMEDS_Driver_i::PasteInto(const unsigned char* theStream,
 289                                          const long theStreamLength,
 290                                          int theObjectID,
 291                                          const SALOMEDSImpl_SObject& theObject)
 292 {
 293   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 294   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
 295
 296   SALOMEDS::TMPFile_var aStream;
 297   if(theStreamLength > 0)
 298     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 299   else
 300     aStream = new SALOMEDS::TMPFile(0);
 301
 302   SALOMEDS::unlock();
 303
 304   std::string entry = "";
 305
 306   if ( !CORBA::is_nil(_driver) ) {
 307     SALOMEDS::SObject_var ret_so = _driver->PasteInto(aStream.in(), theObjectID, so.in());
 308     entry = ret_so->GetID();
 309   }
 310
 311   so->UnRegister();
 312   SALOMEDS::lock();
 313
 314   return entry;
 315 }
 316
 317 SALOMEDSImpl_TMPFile* SALOMEDS_Driver_i::DumpPython(SALOMEDSImpl_Study* theStudy,
 318                                                     bool isPublished,
 319                                                     bool isMultiFile,
 320                                                     bool& isValidScript,
 321                                                     long& theStreamLength)
 322 {
 323   SALOMEDS_Study_i *  st_servant = SALOMEDS_Study_i::GetStudyServant(theStudy, _orb);//new SALOMEDS_Study_i (theStudy, _orb);
 324   SALOMEDS::Study_var st  = SALOMEDS::Study::_narrow(st_servant->_this());
 325
 326   SALOMEDS::unlock();
 327
 328   Engines::TMPFile_var aStream;
 329   CORBA::Boolean aValidScript = true; // VSR: maybe should be false by default ???
 330
 331   if ( !CORBA::is_nil( _engine ) )
 332     aStream = _engine->DumpPython(st.in(), isPublished, isMultiFile, aValidScript);
 333
 334   SALOMEDSImpl_TMPFile* aTMPFile = new Engines_TMPFile_i(aStream._retn());
 335   theStreamLength = aTMPFile->Size();
 336   isValidScript = aValidScript;
 337
 338   SALOMEDS::lock();
 339
 340   return aTMPFile;
 341 }
 342
 343 //###############################################################################################################
 344 //                                          SALOMEDS_DriverFactory
 345 //###############################################################################################################
 346
 347 SALOMEDS_DriverFactory_i::SALOMEDS_DriverFactory_i(CORBA::ORB_ptr theORB)
 348 {
 349   _orb = CORBA::ORB::_duplicate(theORB);
 350   _name_service = new SALOME_NamingService(_orb);
 351 }
 352
 353
 354 SALOMEDS_DriverFactory_i::~SALOMEDS_DriverFactory_i()
 355 {
 356   delete _name_service;
 357 }
 358
 359 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType(const std::string& theComponentType)
 360 {
 361
 362   if ( theComponentType == SALOMEDSImpl_IParameters::getDefaultVisualComponent() )
 363     return NULL; // skip the "Interface Applicative" component
 364
 365   SALOMEDSImpl_Driver* driver = 0;
 366
 367   CORBA::Object_var obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component("FactoryServer", theComponentType.c_str());
 368
 369   if (!CORBA::is_nil(obj)) {
 370     Engines::EngineComponent_var anEngine = Engines::EngineComponent::_narrow(obj);
 371     driver = new SALOMEDS_Driver_i(anEngine, _orb);
 372   }
 373   else {
 374     // It can be "light" module
 375     obj = _name_service->Resolve("/Kernel/Session");
 376     if (!CORBA::is_nil(obj)) {
 377       SALOME::Session_var session = SALOME::Session::_narrow(obj);
 378       if (!CORBA::is_nil(session)) {
 379         Engines::EngineComponent_var anEngine = session->GetComponent(theComponentType.c_str());
 380         if (!CORBA::is_nil(anEngine))
 381           driver = new SALOMEDS_Driver_i(anEngine, _orb);
 382       }
 383     }
 384   }
 385
 386   return driver;
 387 }
 388
 389 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByIOR(const std::string& theIOR)
 390 {
 391   CORBA::Object_var obj;
 392   obj = _orb->string_to_object(theIOR.c_str());
 393
 394   if (!CORBA::is_nil(obj)) {
 395     Engines::EngineComponent_var anEngine = Engines::EngineComponent::_narrow(obj);
 396     return new SALOMEDS_Driver_i(anEngine, _orb);
 397   }
 398
 399   return NULL;
 400 }