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