src/SALOMEDS/SALOMEDS_Study.cxx

   1 //  Copyright (C) 2007-2008  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.
  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 //  File   : SALOMEDS_Study.cxx
  23 //  Author : Sergey RUIN
  24 //  Module : SALOME
  25 //
  26 #include "utilities.h"
  27
  28 #include "SALOMEDS_Study.hxx"
  29
  30 #include "SALOMEDS.hxx"
  31 #include "SALOMEDS_SComponent.hxx"
  32 #include "SALOMEDS_SObject.hxx"
  33 #include "SALOMEDS_StudyBuilder.hxx"
  34 #include "SALOMEDS_ChildIterator.hxx"
  35 #include "SALOMEDS_SComponentIterator.hxx"
  36 #include "SALOMEDS_AttributeStudyProperties.hxx"
  37 #include "SALOMEDS_AttributeParameter.hxx"
  38 #include "SALOMEDS_UseCaseBuilder.hxx"
  39
  40 #include "SALOMEDSImpl_SComponent.hxx"
  41 #include "SALOMEDSImpl_SObject.hxx"
  42 #include "SALOMEDSImpl_StudyBuilder.hxx"
  43 #include "SALOMEDSImpl_ChildIterator.hxx"
  44 #include "SALOMEDSImpl_SComponentIterator.hxx"
  45 #include "SALOMEDSImpl_AttributeStudyProperties.hxx"
  46 #include "SALOMEDSImpl_AttributeParameter.hxx"
  47 #include "SALOMEDSImpl_UseCaseBuilder.hxx"
  48
  49 #include "SALOMEDS_Driver_i.hxx"
  50 #include "SALOMEDS_Study_i.hxx"
  51
  52 #include "Utils_ORB_INIT.hxx"
  53 #include "Utils_SINGLETON.hxx"
  54
  55 #include "Basics_Utils.hxx"
  56
  57 #ifdef WIN32
  58 #include <process.h>
  59 #else
  60 #include <sys/types.h>
  61 #include <unistd.h>
  62 #endif
  63
  64 using namespace std;
  65
  66 SALOMEDS_Study::SALOMEDS_Study(SALOMEDSImpl_Study* theStudy)
  67 {
  68   _isLocal = true;
  69   _local_impl = theStudy;
  70   _corba_impl = SALOMEDS::Study::_nil();
  71   init_orb();
  72 }
  73
  74 SALOMEDS_Study::SALOMEDS_Study(SALOMEDS::Study_ptr theStudy)
  75 {
  76 #ifdef WIN32
  77   long pid =  (long)_getpid();
  78 #else
  79   long pid =  (long)getpid();
  80 #endif
  81
  82   long addr = theStudy->GetLocalImpl(Kernel_Utils::GetHostname().c_str(), pid, _isLocal);
  83   if(_isLocal) {
  84     _local_impl = reinterpret_cast<SALOMEDSImpl_Study*>(addr);
  85     _corba_impl = SALOMEDS::Study::_duplicate(theStudy);
  86   }
  87   else {
  88     _local_impl = NULL;
  89     _corba_impl = SALOMEDS::Study::_duplicate(theStudy);
  90   }
  91
  92   init_orb();
  93 }
  94
  95 SALOMEDS_Study::~SALOMEDS_Study()
  96 {
  97 }
  98
  99 std::string SALOMEDS_Study::GetPersistentReference()
 100 {
 101   std::string aRef;
 102   if (_isLocal) {
 103     SALOMEDS::Locker lock;
 104     aRef = _local_impl->GetPersistentReference();
 105   }
 106   else aRef = (CORBA::String_var)_corba_impl->GetPersistentReference();
 107   return aRef;
 108 }
 109
 110 std::string SALOMEDS_Study::GetTransientReference()
 111 {
 112   std::string aRef;
 113   if (_isLocal) {
 114     SALOMEDS::Locker lock;
 115     aRef = _local_impl->GetTransientReference();
 116   }
 117   else aRef = _corba_impl->GetTransientReference();
 118   return aRef;
 119 }
 120
 121 bool SALOMEDS_Study::IsEmpty()
 122 {
 123   bool ret;
 124   if (_isLocal) {
 125     SALOMEDS::Locker lock;
 126     ret = _local_impl->IsEmpty();
 127   }
 128   else ret = _corba_impl->IsEmpty();
 129   return ret;
 130 }
 131
 132 _PTR(SComponent) SALOMEDS_Study::FindComponent (const std::string& aComponentName)
 133 {
 134   SALOMEDSClient_SComponent* aSCO = NULL;
 135   if (_isLocal) {
 136     SALOMEDS::Locker lock;
 137
 138     SALOMEDSImpl_SComponent aSCO_impl = _local_impl->FindComponent(aComponentName);
 139     if (!aSCO_impl) return _PTR(SComponent)(aSCO);
 140     aSCO = new SALOMEDS_SComponent(aSCO_impl);
 141   }
 142   else {
 143     SALOMEDS::SComponent_var aSCO_impl = _corba_impl->FindComponent((char*)aComponentName.c_str());
 144     if (CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
 145     aSCO = new SALOMEDS_SComponent(aSCO_impl);
 146   }
 147   return _PTR(SComponent)(aSCO);
 148 }
 149
 150 _PTR(SComponent) SALOMEDS_Study::FindComponentID(const std::string& aComponentID)
 151 {
 152   SALOMEDSClient_SComponent* aSCO = NULL;
 153   if (_isLocal) {
 154     SALOMEDS::Locker lock;
 155
 156     SALOMEDSImpl_SComponent aSCO_impl = _local_impl->FindComponentID(aComponentID);
 157     if (!aSCO_impl) return _PTR(SComponent)(aSCO);
 158     aSCO = new SALOMEDS_SComponent(aSCO_impl);
 159   }
 160   else {
 161     SALOMEDS::SComponent_var aSCO_impl = _corba_impl->FindComponentID((char*)aComponentID.c_str());
 162     if(CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
 163     aSCO = new SALOMEDS_SComponent(aSCO_impl);
 164   }
 165   return _PTR(SComponent)(aSCO);
 166 }
 167
 168 _PTR(SObject) SALOMEDS_Study::FindObject(const std::string& anObjectName)
 169 {
 170   SALOMEDSClient_SObject* aSO = NULL;
 171
 172   if (_isLocal) {
 173     SALOMEDS::Locker lock;
 174
 175     SALOMEDSImpl_SObject aSO_impl = _local_impl->FindObject(anObjectName);
 176     if (!aSO_impl) return _PTR(SObject)(aSO);
 177     if(aSO_impl.IsComponent()) {
 178         SALOMEDSImpl_SComponent aSCO_impl = aSO_impl;
 179         return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
 180     }
 181     aSO = new SALOMEDS_SObject(aSO_impl);
 182   }
 183   else {
 184     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObject((char*)anObjectName.c_str());
 185     if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 186     SALOMEDS::SComponent_var aSCO_impl = SALOMEDS::SComponent::_narrow(aSO_impl);
 187     if (!CORBA::is_nil(aSCO_impl)) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
 188     aSO = new SALOMEDS_SObject(aSO_impl);
 189   }
 190
 191   return _PTR(SObject)(aSO);
 192 }
 193
 194 std::vector<_PTR(SObject)> SALOMEDS_Study::FindObjectByName(const std::string& anObjectName,
 195                                                             const std::string& aComponentName)
 196 {
 197   std::vector<_PTR(SObject)> aVector;
 198   int i, aLength = 0;
 199
 200   if (_isLocal) {
 201     SALOMEDS::Locker lock;
 202
 203     vector<SALOMEDSImpl_SObject> aSeq = _local_impl->FindObjectByName(anObjectName, aComponentName);
 204     aLength = aSeq.size();
 205     for (i = 0; i< aLength; i++)
 206       aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
 207   }
 208   else {
 209     SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindObjectByName((char*)anObjectName.c_str(),
 210                                                                             (char*)aComponentName.c_str());
 211     aLength = aSeq->length();
 212     for (i = 0; i< aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
 213   }
 214
 215   return aVector;
 216 }
 217
 218 _PTR(SObject) SALOMEDS_Study::FindObjectID(const std::string& anObjectID)
 219 {
 220   SALOMEDSClient_SObject* aSO = NULL;
 221   if (_isLocal) {
 222     SALOMEDS::Locker lock;
 223
 224     SALOMEDSImpl_SObject aSO_impl = _local_impl->FindObjectID(anObjectID);
 225     if(!aSO_impl) return _PTR(SObject)(aSO);
 226     return _PTR(SObject)(new SALOMEDS_SObject(aSO_impl));
 227   }
 228   else {
 229     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectID((char*)anObjectID.c_str());
 230     if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 231     return _PTR(SObject)(new SALOMEDS_SObject(aSO_impl));
 232   }
 233   return _PTR(SObject)(aSO);
 234 }
 235
 236 _PTR(SObject) SALOMEDS_Study::CreateObjectID(const std::string& anObjectID)
 237 {
 238   SALOMEDSClient_SObject* aSO = NULL;
 239   if (_isLocal) {
 240     SALOMEDS::Locker lock;
 241     SALOMEDSImpl_SObject aSO_impl = _local_impl->CreateObjectID(anObjectID);
 242     if(!aSO_impl) return _PTR(SObject)(aSO);
 243     aSO = new SALOMEDS_SObject(aSO_impl);
 244   }
 245   else {
 246     SALOMEDS::SObject_var aSO_impl = _corba_impl->CreateObjectID((char*)anObjectID.c_str());
 247     if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 248     aSO = new SALOMEDS_SObject(aSO_impl);
 249   }
 250   return _PTR(SObject)(aSO);
 251 }
 252
 253 _PTR(SObject) SALOMEDS_Study::FindObjectIOR(const std::string& anObjectIOR)
 254 {
 255   SALOMEDSClient_SObject* aSO = NULL;
 256   if (_isLocal) {
 257     SALOMEDS::Locker lock;
 258
 259     SALOMEDSImpl_SObject aSO_impl = _local_impl->FindObjectIOR(anObjectIOR);
 260     if (!aSO_impl) return _PTR(SObject)(aSO);
 261     aSO = new SALOMEDS_SObject(aSO_impl);
 262   }
 263   else {
 264     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectIOR((char*)anObjectIOR.c_str());
 265     if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 266     aSO = new SALOMEDS_SObject(aSO_impl);
 267   }
 268   return _PTR(SObject)(aSO);
 269 }
 270
 271 _PTR(SObject) SALOMEDS_Study::FindObjectByPath(const std::string& thePath)
 272 {
 273   SALOMEDSClient_SObject* aSO = NULL;
 274   if (_isLocal) {
 275     SALOMEDS::Locker lock;
 276
 277     SALOMEDSImpl_SObject aSO_impl = _local_impl->FindObjectByPath(thePath);
 278     if (!aSO_impl) return _PTR(SObject)(aSO);
 279     aSO = new SALOMEDS_SObject(aSO_impl);
 280   }
 281   else {
 282     SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectByPath((char*)thePath.c_str());
 283     if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
 284     aSO = new SALOMEDS_SObject(aSO_impl);
 285   }
 286   return _PTR(SObject)(aSO);
 287 }
 288
 289 std::string SALOMEDS_Study::GetObjectPath(const _PTR(SObject)& theSO)
 290 {
 291   if(!theSO) return "";
 292   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 293   std::string aPath;
 294   if (_isLocal) {
 295     SALOMEDS::Locker lock;
 296     aPath = _local_impl->GetObjectPath(*(aSO->GetLocalImpl()));
 297   }
 298   else aPath = _corba_impl->GetObjectPath(aSO->GetCORBAImpl());
 299   return aPath;
 300 }
 301
 302 void SALOMEDS_Study::SetContext(const std::string& thePath)
 303 {
 304   if (_isLocal) {
 305     SALOMEDS::Locker lock;
 306     _local_impl->SetContext(thePath);
 307   }
 308   else _corba_impl->SetContext((char*)thePath.c_str());
 309 }
 310
 311 std::string SALOMEDS_Study::GetContext()
 312 {
 313   std::string aPath;
 314   if (_isLocal) {
 315     SALOMEDS::Locker lock;
 316     aPath = _local_impl->GetContext();
 317   }
 318   else aPath = _corba_impl->GetContext();
 319   return aPath;
 320 }
 321
 322 std::vector<std::string> SALOMEDS_Study::GetObjectNames(const std::string& theContext)
 323 {
 324   std::vector<std::string> aVector;
 325   int aLength, i;
 326   if (_isLocal) {
 327     SALOMEDS::Locker lock;
 328     aVector = _local_impl->GetObjectNames(theContext);
 329   }
 330   else {
 331     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetObjectNames((char*)theContext.c_str());
 332     aLength = aSeq->length();
 333     for (i = 0; i < aLength; i++) aVector.push_back(std::string((std::string)aSeq[i].in()));
 334   }
 335   return aVector;
 336 }
 337
 338 std::vector<std::string> SALOMEDS_Study::GetDirectoryNames(const std::string& theContext)
 339 {
 340   std::vector<std::string> aVector;
 341   int aLength, i;
 342   if (_isLocal) {
 343     SALOMEDS::Locker lock;
 344     aVector = _local_impl->GetDirectoryNames(theContext);
 345   }
 346   else {
 347     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetDirectoryNames((char*)theContext.c_str());
 348     aLength = aSeq->length();
 349     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 350   }
 351   return aVector;
 352 }
 353
 354 std::vector<std::string> SALOMEDS_Study::GetFileNames(const std::string& theContext)
 355 {
 356   std::vector<std::string> aVector;
 357   int aLength, i;
 358   if (_isLocal) {
 359     SALOMEDS::Locker lock;
 360     aVector = _local_impl->GetFileNames(theContext);
 361   }
 362   else {
 363     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetFileNames((char*)theContext.c_str());
 364     aLength = aSeq->length();
 365
 366     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 367   }
 368   return aVector;
 369 }
 370
 371 std::vector<std::string> SALOMEDS_Study::GetComponentNames(const std::string& theContext)
 372 {
 373   std::vector<std::string> aVector;
 374   int aLength, i;
 375   if (_isLocal) {
 376     SALOMEDS::Locker lock;
 377     aVector = _local_impl->GetComponentNames(theContext);
 378   }
 379   else {
 380     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetComponentNames((char*)theContext.c_str());
 381     aLength = aSeq->length();
 382     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 383   }
 384   return aVector;
 385 }
 386
 387 _PTR(ChildIterator) SALOMEDS_Study::NewChildIterator(const _PTR(SObject)& theSO)
 388 {
 389   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 390   SALOMEDSClient_ChildIterator* aCI = NULL;
 391   if (_isLocal) {
 392     SALOMEDS::Locker lock;
 393     SALOMEDSImpl_ChildIterator aCIimpl = _local_impl->NewChildIterator(*(aSO->GetLocalImpl()));
 394     aCI = new SALOMEDS_ChildIterator(aCIimpl);
 395   }
 396   else {
 397     SALOMEDS::ChildIterator_var aCIimpl = _corba_impl->NewChildIterator(aSO->GetCORBAImpl());
 398     aCI = new SALOMEDS_ChildIterator(aCIimpl);
 399   }
 400
 401   return _PTR(ChildIterator)(aCI);
 402 }
 403
 404 _PTR(SComponentIterator) SALOMEDS_Study::NewComponentIterator()
 405 {
 406   SALOMEDSClient_SComponentIterator* aCI = NULL;
 407   if (_isLocal) {
 408     SALOMEDS::Locker lock;
 409
 410     SALOMEDSImpl_SComponentIterator aCIimpl = _local_impl->NewComponentIterator();
 411     aCI = new SALOMEDS_SComponentIterator(aCIimpl);
 412   }
 413   else {
 414     SALOMEDS::SComponentIterator_var aCIimpl = _corba_impl->NewComponentIterator();
 415     aCI = new SALOMEDS_SComponentIterator(aCIimpl);
 416   }
 417
 418   return _PTR(SComponentIterator)(aCI);
 419 }
 420
 421 _PTR(StudyBuilder) SALOMEDS_Study::NewBuilder()
 422 {
 423   SALOMEDSClient_StudyBuilder* aSB = NULL;
 424   if (_isLocal) {
 425     SALOMEDS::Locker lock;
 426
 427     SALOMEDSImpl_StudyBuilder* aSBimpl = _local_impl->NewBuilder();
 428     aSB = new SALOMEDS_StudyBuilder(aSBimpl);
 429   }
 430   else {
 431     SALOMEDS::StudyBuilder_var aSBimpl = _corba_impl->NewBuilder();
 432     aSB = new SALOMEDS_StudyBuilder(aSBimpl);
 433   }
 434
 435   return _PTR(StudyBuilder)(aSB);
 436 }
 437
 438 std::string SALOMEDS_Study::Name()
 439 {
 440   std::string aName;
 441   if (_isLocal) {
 442     SALOMEDS::Locker lock;
 443     aName = _local_impl->Name();
 444   }
 445   else aName = _corba_impl->Name();
 446   return aName;
 447 }
 448
 449 void SALOMEDS_Study::Name(const std::string& theName)
 450 {
 451   if (_isLocal) {
 452     SALOMEDS::Locker lock;
 453     _local_impl->Name(theName);
 454   }
 455   else _corba_impl->Name((char*)theName.c_str());
 456 }
 457
 458 bool SALOMEDS_Study::IsSaved()
 459 {
 460   bool isSaved;
 461   if (_isLocal) {
 462     SALOMEDS::Locker lock;
 463     isSaved = _local_impl->IsSaved();
 464   }
 465   else isSaved = _corba_impl->IsSaved();
 466   return isSaved;
 467 }
 468
 469 void SALOMEDS_Study::IsSaved(bool save)
 470 {
 471   if (_isLocal) {
 472     SALOMEDS::Locker lock;
 473     _local_impl->IsSaved(save);
 474   }
 475   else _corba_impl->IsSaved(save);
 476 }
 477
 478 bool SALOMEDS_Study::IsModified()
 479 {
 480   bool isModified;
 481   if (_isLocal) {
 482     SALOMEDS::Locker lock;
 483     isModified = _local_impl->IsModified();
 484   }
 485   else isModified = _corba_impl->IsModified();
 486   return isModified;
 487 }
 488
 489 void SALOMEDS_Study::Modified()
 490 {
 491   if (_isLocal) {
 492     SALOMEDS::Locker lock;
 493     _local_impl->Modify();
 494   }
 495   else _corba_impl->Modified();
 496 }
 497
 498
 499 std::string SALOMEDS_Study::URL()
 500 {
 501   std::string aURL;
 502   if (_isLocal) {
 503     SALOMEDS::Locker lock;
 504     aURL = _local_impl->URL();
 505   }
 506   else aURL = _corba_impl->URL();
 507   return aURL;
 508 }
 509
 510 void SALOMEDS_Study::URL(const std::string& url)
 511 {
 512   if (_isLocal) {
 513     SALOMEDS::Locker lock;
 514     _local_impl->URL(url);
 515   }
 516   else _corba_impl->URL((char*)url.c_str());
 517 }
 518
 519 int SALOMEDS_Study::StudyId()
 520 {
 521   int anID;
 522   if (_isLocal) {
 523     SALOMEDS::Locker lock;
 524     anID = _local_impl->StudyId();
 525   }
 526   else anID = _corba_impl->StudyId();
 527   return anID;
 528 }
 529
 530 void SALOMEDS_Study::StudyId(int id)
 531 {
 532   if (_isLocal) {
 533     SALOMEDS::Locker lock;
 534     _local_impl->StudyId(id);
 535   }
 536   else _corba_impl->StudyId(id);
 537 }
 538
 539 std::vector<_PTR(SObject)> SALOMEDS_Study::FindDependances(const _PTR(SObject)& theSO)
 540 {
 541   std::vector<_PTR(SObject)> aVector;
 542   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 543   int aLength, i;
 544   if (_isLocal) {
 545     SALOMEDS::Locker lock;
 546
 547     vector<SALOMEDSImpl_SObject> aSeq = _local_impl->FindDependances(*(aSO->GetLocalImpl()));
 548     if (aSeq.size()) {
 549       aLength = aSeq.size();
 550       for (i = 0; i < aLength; i++)
 551         aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
 552     }
 553   }
 554   else {
 555     SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindDependances(aSO->GetCORBAImpl());
 556     aLength = aSeq->length();
 557     for (i = 0; i < aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
 558   }
 559   return aVector;
 560 }
 561
 562 _PTR(AttributeStudyProperties) SALOMEDS_Study::GetProperties()
 563 {
 564   SALOMEDSClient_AttributeStudyProperties* aProp;
 565   if (_isLocal) {
 566     SALOMEDS::Locker lock;
 567     aProp = new SALOMEDS_AttributeStudyProperties(_local_impl->GetProperties());
 568   }
 569   else aProp = new SALOMEDS_AttributeStudyProperties((SALOMEDS::AttributeStudyProperties_var)_corba_impl->GetProperties());
 570   return _PTR(AttributeStudyProperties)(aProp);
 571 }
 572
 573 std::string SALOMEDS_Study::GetLastModificationDate()
 574 {
 575   std::string aDate;
 576   if (_isLocal) {
 577     SALOMEDS::Locker lock;
 578     aDate = _local_impl->GetLastModificationDate();
 579   }
 580   else aDate = _corba_impl->GetLastModificationDate();
 581   return aDate;
 582 }
 583
 584 std::vector<std::string> SALOMEDS_Study::GetModificationsDate()
 585 {
 586   std::vector<std::string> aVector;
 587   int aLength, i;
 588   if (_isLocal) {
 589     SALOMEDS::Locker lock;
 590     aVector = _local_impl->GetModificationsDate();
 591   }
 592   else {
 593     SALOMEDS::ListOfDates_var aSeq = _corba_impl->GetModificationsDate();
 594     aLength = aSeq->length();
 595     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 596   }
 597   return aVector;
 598 }
 599
 600 _PTR(UseCaseBuilder) SALOMEDS_Study::GetUseCaseBuilder()
 601 {
 602   SALOMEDSClient_UseCaseBuilder* aUB = NULL;
 603   if (_isLocal) {
 604     SALOMEDS::Locker lock;
 605
 606     SALOMEDSImpl_UseCaseBuilder* aUBimpl = _local_impl->GetUseCaseBuilder();
 607     aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
 608   }
 609   else {
 610     SALOMEDS::UseCaseBuilder_var aUBimpl = _corba_impl->GetUseCaseBuilder();
 611     aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
 612   }
 613
 614   return _PTR(UseCaseBuilder)(aUB);
 615 }
 616
 617 void SALOMEDS_Study::Close()
 618 {
 619   if (_isLocal) {
 620     SALOMEDS::Locker lock;
 621     _local_impl->Close();
 622   }
 623   else _corba_impl->Close();
 624 }
 625
 626 void SALOMEDS_Study::EnableUseCaseAutoFilling(bool isEnabled)
 627 {
 628   if(_isLocal) _local_impl->EnableUseCaseAutoFilling(isEnabled);
 629   else _corba_impl->EnableUseCaseAutoFilling(isEnabled);
 630 }
 631
 632 bool SALOMEDS_Study::DumpStudy(const string& thePath, const string& theBaseName, bool isPublished)
 633 {
 634   //SRN: Pure CORBA DumpStudy as it does more cleaning than the local one
 635   if(CORBA::is_nil(_corba_impl)) GetStudy(); //If CORBA implementation is null then retrieve it
 636   bool ret = _corba_impl->DumpStudy(thePath.c_str(), theBaseName.c_str(), isPublished);
 637   return ret;
 638 }
 639
 640 void SALOMEDS_Study::SetStudyLock(const string& theLockerID)
 641 {
 642   if (_isLocal) {
 643     SALOMEDS::Locker lock;
 644     _local_impl->SetStudyLock(theLockerID.c_str());
 645   }
 646   else _corba_impl->SetStudyLock((char*)theLockerID.c_str());
 647 }
 648
 649 bool SALOMEDS_Study::IsStudyLocked()
 650 {
 651   bool isLocked;
 652   if (_isLocal) {
 653     SALOMEDS::Locker lock;
 654     isLocked = _local_impl->IsStudyLocked();
 655   }
 656   else isLocked = _corba_impl->IsStudyLocked();
 657   return isLocked;
 658 }
 659
 660 void SALOMEDS_Study::UnLockStudy(const string& theLockerID)
 661 {
 662   if(_isLocal) _local_impl->UnLockStudy(theLockerID.c_str());
 663   else _corba_impl->UnLockStudy((char*)theLockerID.c_str());
 664 }
 665
 666 vector<string> SALOMEDS_Study::GetLockerID()
 667 {
 668   std::vector<std::string> aVector;
 669   int aLength, i;
 670   if (_isLocal) {
 671     SALOMEDS::Locker lock;
 672     aVector = _local_impl->GetLockerID();
 673   }
 674   else {
 675     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetLockerID();
 676     aLength = aSeq->length();
 677     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 678   }
 679   return aVector;
 680 }
 681
 682 std::string SALOMEDS_Study::ConvertObjectToIOR(CORBA::Object_ptr theObject)
 683 {
 684   return _orb->object_to_string(theObject);
 685 }
 686
 687 CORBA::Object_ptr SALOMEDS_Study::ConvertIORToObject(const std::string& theIOR)
 688 {
 689   return _orb->string_to_object(theIOR.c_str());
 690 }
 691
 692 void SALOMEDS_Study::init_orb()
 693 {
 694   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 695   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 696   _orb = init(0 , 0 ) ;
 697 }
 698
 699 SALOMEDS::Study_ptr SALOMEDS_Study::GetStudy()
 700 {
 701   if (_isLocal) {
 702     SALOMEDS::Locker lock;
 703
 704     if (!CORBA::is_nil(_corba_impl)) return SALOMEDS::Study::_duplicate(_corba_impl);
 705     std::string anIOR = _local_impl->GetTransientReference();
 706     SALOMEDS::Study_var aStudy;
 707     if (!_local_impl->IsError() && anIOR != "") {
 708       aStudy = SALOMEDS::Study::_narrow(_orb->string_to_object(anIOR.c_str()));
 709     }
 710     else {
 711       SALOMEDS_Study_i *aStudy_servant = new SALOMEDS_Study_i(_local_impl, _orb);
 712       aStudy = aStudy_servant->_this();
 713       _local_impl->SetTransientReference(_orb->object_to_string(aStudy));
 714     }
 715     _corba_impl = SALOMEDS::Study::_duplicate(aStudy);
 716     return aStudy._retn();
 717   }
 718   else {
 719     return SALOMEDS::Study::_duplicate(_corba_impl);
 720   }
 721
 722   return SALOMEDS::Study::_nil();
 723 }
 724
 725
 726 _PTR(AttributeParameter) SALOMEDS_Study::GetCommonParameters(const string& theID, int theSavePoint)
 727 {
 728   SALOMEDSClient_AttributeParameter* AP = NULL;
 729   if(theSavePoint >= 0) {
 730     if (_isLocal) {
 731       SALOMEDS::Locker lock;
 732       AP = new SALOMEDS_AttributeParameter(_local_impl->GetCommonParameters(theID.c_str(), theSavePoint));
 733     }
 734     else {
 735       AP = new SALOMEDS_AttributeParameter(_corba_impl->GetCommonParameters(theID.c_str(), theSavePoint));
 736     }
 737   }
 738   return _PTR(AttributeParameter)(AP);
 739 }
 740
 741 _PTR(AttributeParameter) SALOMEDS_Study::GetModuleParameters(const string& theID,
 742                                                              const string& theModuleName, int theSavePoint)
 743 {
 744   SALOMEDSClient_AttributeParameter* AP = NULL;
 745   if(theSavePoint > 0) {
 746     if (_isLocal) {
 747       SALOMEDS::Locker lock;
 748       AP = new SALOMEDS_AttributeParameter(_local_impl->GetModuleParameters(theID.c_str(), theModuleName.c_str(), theSavePoint));
 749     }
 750     else {
 751       AP = new SALOMEDS_AttributeParameter(_corba_impl->GetModuleParameters(theID.c_str(), theModuleName.c_str(), theSavePoint));
 752     }
 753   }
 754   return _PTR(AttributeParameter)(AP);
 755 }