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     if ( pers_string.in() )
 207       pstr = pers_string;
 208   }
 209
 210   so->UnRegister();
 211   SALOMEDS::lock();
 212
 213   return pstr;
 214 }
 215
 216
 217 std::string SALOMEDS_Driver_i::LocalPersistentIDToIOR(const SALOMEDSImpl_SObject& theObject,
 218                                                       const std::string& aLocalPersistentID,
 219                                                       bool isMultiFile,
 220                                                       bool isASCII)
 221 {
 222   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 223   CORBA::String_var pers_string = CORBA::string_dup(aLocalPersistentID.c_str());
 224   SALOMEDS::unlock();
 225
 226   std::string ior = "";
 227
 228   if ( !CORBA::is_nil(_driver) ) {
 229     CORBA::String_var IOR = _driver->LocalPersistentIDToIOR(so.in(), pers_string.in(), isMultiFile, isASCII);
 230     ior = IOR;
 231   }
 232   so->UnRegister();
 233   SALOMEDS::lock();
 234   return ior;
 235 }
 236
 237 bool SALOMEDS_Driver_i::CanCopy(const SALOMEDSImpl_SObject& theObject)
 238 {
 239   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 240
 241   SALOMEDS::unlock();
 242   bool isOk = false;
 243
 244   if ( !CORBA::is_nil(_driver) )
 245     isOk = _driver->CanCopy(so.in());
 246
 247   so->UnRegister();
 248   SALOMEDS::lock();
 249
 250   return isOk;
 251 }
 252
 253
 254 SALOMEDSImpl_TMPFile* SALOMEDS_Driver_i::CopyFrom(const SALOMEDSImpl_SObject& theObject,
 255                                                   int& theObjectID,
 256                                                   long& theStreamLength)
 257 {
 258   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 259
 260   SALOMEDS::unlock();
 261   CORBA::Long anObjectID;
 262   SALOMEDS::TMPFile_var aStream;
 263
 264   if ( !CORBA::is_nil(_driver) )
 265     aStream = _driver->CopyFrom(so.in(), anObjectID);
 266
 267   SALOMEDSImpl_TMPFile* aTMPFile = new SALOMEDS_TMPFile_i(aStream._retn());
 268   theStreamLength = aTMPFile->Size();
 269   theObjectID = anObjectID;
 270
 271   so->UnRegister();
 272   SALOMEDS::lock();
 273
 274   return aTMPFile;
 275 }
 276
 277 bool SALOMEDS_Driver_i::CanPaste(const std::string& theComponentName, int theObjectID)
 278 {
 279   SALOMEDS::unlock();
 280   bool canPaste = false;
 281
 282   if ( !CORBA::is_nil(_driver) )
 283     canPaste = _driver->CanPaste(theComponentName.c_str(), theObjectID);
 284
 285   SALOMEDS::lock();
 286   return canPaste;
 287 }
 288
 289 std::string SALOMEDS_Driver_i::PasteInto(const unsigned char* theStream,
 290                                          const long theStreamLength,
 291                                          int theObjectID,
 292                                          const SALOMEDSImpl_SObject& theObject)
 293 {
 294   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (theObject, _orb);
 295   CORBA::Octet* anOctetBuf =  (CORBA::Octet*)theStream;
 296
 297   SALOMEDS::TMPFile_var aStream;
 298   if(theStreamLength > 0)
 299     aStream = new SALOMEDS::TMPFile(theStreamLength, theStreamLength, anOctetBuf, 0);
 300   else
 301     aStream = new SALOMEDS::TMPFile(0);
 302
 303   SALOMEDS::unlock();
 304
 305   std::string entry = "";
 306
 307   if ( !CORBA::is_nil(_driver) ) {
 308     SALOMEDS::SObject_var ret_so = _driver->PasteInto(aStream.in(), theObjectID, so.in());
 309     entry = ret_so->GetID();
 310   }
 311
 312   so->UnRegister();
 313   SALOMEDS::lock();
 314
 315   return entry;
 316 }
 317
 318 SALOMEDSImpl_TMPFile* SALOMEDS_Driver_i::DumpPython(SALOMEDSImpl_Study* theStudy,
 319                                                     bool isPublished,
 320                                                     bool isMultiFile,
 321                                                     bool& isValidScript,
 322                                                     long& theStreamLength)
 323 {
 324   SALOMEDS_Study_i *  st_servant = SALOMEDS_Study_i::GetStudyServant(theStudy, _orb);//new SALOMEDS_Study_i (theStudy, _orb);
 325   SALOMEDS::Study_var st  = SALOMEDS::Study::_narrow(st_servant->_this());
 326
 327   SALOMEDS::unlock();
 328
 329   Engines::TMPFile_var aStream;
 330   CORBA::Boolean aValidScript = true; // VSR: maybe should be false by default ???
 331
 332   if ( !CORBA::is_nil( _engine ) )
 333     aStream = _engine->DumpPython(st.in(), isPublished, isMultiFile, aValidScript);
 334
 335   SALOMEDSImpl_TMPFile* aTMPFile = new Engines_TMPFile_i(aStream._retn());
 336   theStreamLength = aTMPFile->Size();
 337   isValidScript = aValidScript;
 338
 339   SALOMEDS::lock();
 340
 341   return aTMPFile;
 342 }
 343
 344 //###############################################################################################################
 345 //                                          SALOMEDS_DriverFactory
 346 //###############################################################################################################
 347
 348 SALOMEDS_DriverFactory_i::SALOMEDS_DriverFactory_i(CORBA::ORB_ptr theORB)
 349 {
 350   _orb = CORBA::ORB::_duplicate(theORB);
 351   _name_service = new SALOME_NamingService(_orb);
 352 }
 353
 354
 355 SALOMEDS_DriverFactory_i::~SALOMEDS_DriverFactory_i()
 356 {
 357   delete _name_service;
 358 }
 359
 360 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByType(const std::string& theComponentType)
 361 {
 362
 363   if ( theComponentType == SALOMEDSImpl_IParameters::getDefaultVisualComponent() )
 364     return NULL; // skip the "Interface Applicative" component
 365
 366   SALOMEDSImpl_Driver* driver = 0;
 367
 368   CORBA::Object_var obj = SALOME_LifeCycleCORBA(_name_service).FindOrLoad_Component("FactoryServer", theComponentType.c_str());
 369
 370   if (!CORBA::is_nil(obj)) {
 371     Engines::EngineComponent_var anEngine = Engines::EngineComponent::_narrow(obj);
 372     driver = new SALOMEDS_Driver_i(anEngine, _orb);
 373   }
 374   else {
 375     // It can be "light" module
 376     obj = _name_service->Resolve("/Kernel/Session");
 377     if (!CORBA::is_nil(obj)) {
 378       SALOME::Session_var session = SALOME::Session::_narrow(obj);
 379       if (!CORBA::is_nil(session)) {
 380         Engines::EngineComponent_var anEngine = session->GetComponent(theComponentType.c_str());
 381         if (!CORBA::is_nil(anEngine))
 382           driver = new SALOMEDS_Driver_i(anEngine, _orb);
 383       }
 384     }
 385   }
 386
 387   return driver;
 388 }
 389
 390 SALOMEDSImpl_Driver* SALOMEDS_DriverFactory_i::GetDriverByIOR(const std::string& theIOR)
 391 {
 392   CORBA::Object_var obj;
 393   obj = _orb->string_to_object(theIOR.c_str());
 394
 395   if (!CORBA::is_nil(obj)) {
 396     Engines::EngineComponent_var anEngine = Engines::EngineComponent::_narrow(obj);
 397     return new SALOMEDS_Driver_i(anEngine, _orb);
 398   }
 399
 400   return NULL;
 401 }