src/SALOMEDS/SALOMEDS_Driver_i.cxx

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