src/SALOMEDS/SALOMEDS_Study.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 //  File   : SALOMEDS_Study.cxx
  24 //  Author : Sergey RUIN
  25 //  Module : SALOME
  26 //
  27 #include "utilities.h"
  28
  29 #include "SALOMEDS_Study.hxx"
  30
  31 #include "SALOMEDS.hxx"
  32 #include "SALOMEDS_SComponent.hxx"
  33 #include "SALOMEDS_SObject.hxx"
  34 #include "SALOMEDS_StudyBuilder.hxx"
  35 #include "SALOMEDS_ChildIterator.hxx"
  36 #include "SALOMEDS_SComponentIterator.hxx"
  37 #include "SALOMEDS_AttributeStudyProperties.hxx"
  38 #include "SALOMEDS_AttributeParameter.hxx"
  39 #include "SALOMEDS_UseCaseBuilder.hxx"
  40
  41 #include "SALOMEDSImpl_SComponent.hxx"
  42 #include "SALOMEDSImpl_SObject.hxx"
  43 #include "SALOMEDSImpl_StudyBuilder.hxx"
  44 #include "SALOMEDSImpl_ChildIterator.hxx"
  45 #include "SALOMEDSImpl_SComponentIterator.hxx"
  46 #include "SALOMEDSImpl_AttributeStudyProperties.hxx"
  47 #include "SALOMEDSImpl_AttributeParameter.hxx"
  48 #include "SALOMEDSImpl_GenericVariable.hxx"
  49 #include "SALOMEDSImpl_UseCaseBuilder.hxx"
  50
  51 #include "SALOMEDS_Driver_i.hxx"
  52 #include "SALOMEDS_Study_i.hxx"
  53
  54 #include "Utils_ORB_INIT.hxx"
  55 #include "Utils_SINGLETON.hxx"
  56
  57 #include "Basics_Utils.hxx"
  58
  59 #ifdef WIN32
  60 #include <process.h>
  61 #else
  62 #include <sys/types.h>
  63 #include <unistd.h>
  64 #endif
  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     std::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 = Kernel_Utils::encode_s(_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(Kernel_Utils::decode_s(theName));
 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
 507       aURL = Kernel_Utils::encode_s(_corba_impl->URL());
 508   return aURL;
 509 }
 510
 511 void SALOMEDS_Study::URL(const std::string& url)
 512 {
 513   if (_isLocal) {
 514     SALOMEDS::Locker lock;
 515     _local_impl->URL(url);
 516   }
 517   else _corba_impl->URL(Kernel_Utils::decode_s(url));
 518 }
 519
 520 int SALOMEDS_Study::StudyId()
 521 {
 522   int anID;
 523   if (_isLocal) {
 524     SALOMEDS::Locker lock;
 525     anID = _local_impl->StudyId();
 526   }
 527   else anID = _corba_impl->StudyId();
 528   return anID;
 529 }
 530
 531 void SALOMEDS_Study::StudyId(int id)
 532 {
 533   if (_isLocal) {
 534     SALOMEDS::Locker lock;
 535     _local_impl->StudyId(id);
 536   }
 537   else _corba_impl->StudyId(id);
 538 }
 539
 540 std::vector<_PTR(SObject)> SALOMEDS_Study::FindDependances(const _PTR(SObject)& theSO)
 541 {
 542   std::vector<_PTR(SObject)> aVector;
 543   SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
 544   int aLength, i;
 545   if (_isLocal) {
 546     SALOMEDS::Locker lock;
 547
 548     std::vector<SALOMEDSImpl_SObject> aSeq = _local_impl->FindDependances(*(aSO->GetLocalImpl()));
 549     if (aSeq.size()) {
 550       aLength = aSeq.size();
 551       for (i = 0; i < aLength; i++)
 552         aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
 553     }
 554   }
 555   else {
 556     SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindDependances(aSO->GetCORBAImpl());
 557     aLength = aSeq->length();
 558     for (i = 0; i < aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
 559   }
 560   return aVector;
 561 }
 562
 563 _PTR(AttributeStudyProperties) SALOMEDS_Study::GetProperties()
 564 {
 565   SALOMEDSClient_AttributeStudyProperties* aProp;
 566   if (_isLocal) {
 567     SALOMEDS::Locker lock;
 568     aProp = new SALOMEDS_AttributeStudyProperties(_local_impl->GetProperties());
 569   }
 570   else aProp = new SALOMEDS_AttributeStudyProperties((SALOMEDS::AttributeStudyProperties_var)_corba_impl->GetProperties());
 571   return _PTR(AttributeStudyProperties)(aProp);
 572 }
 573
 574 std::string SALOMEDS_Study::GetLastModificationDate()
 575 {
 576   std::string aDate;
 577   if (_isLocal) {
 578     SALOMEDS::Locker lock;
 579     aDate = _local_impl->GetLastModificationDate();
 580   }
 581   else aDate = _corba_impl->GetLastModificationDate();
 582   return aDate;
 583 }
 584
 585 std::vector<std::string> SALOMEDS_Study::GetModificationsDate()
 586 {
 587   std::vector<std::string> aVector;
 588   int aLength, i;
 589   if (_isLocal) {
 590     SALOMEDS::Locker lock;
 591     aVector = _local_impl->GetModificationsDate();
 592   }
 593   else {
 594     SALOMEDS::ListOfDates_var aSeq = _corba_impl->GetModificationsDate();
 595     aLength = aSeq->length();
 596     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 597   }
 598   return aVector;
 599 }
 600
 601 _PTR(UseCaseBuilder) SALOMEDS_Study::GetUseCaseBuilder()
 602 {
 603   SALOMEDSClient_UseCaseBuilder* aUB = NULL;
 604   if (_isLocal) {
 605     SALOMEDS::Locker lock;
 606
 607     SALOMEDSImpl_UseCaseBuilder* aUBimpl = _local_impl->GetUseCaseBuilder();
 608     aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
 609   }
 610   else {
 611     SALOMEDS::UseCaseBuilder_var aUBimpl = _corba_impl->GetUseCaseBuilder();
 612     aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
 613   }
 614
 615   return _PTR(UseCaseBuilder)(aUB);
 616 }
 617
 618 void SALOMEDS_Study::Close()
 619 {
 620   if (_isLocal) {
 621     SALOMEDS::Locker lock;
 622     _local_impl->Close();
 623   }
 624   else _corba_impl->Close();
 625 }
 626
 627 void SALOMEDS_Study::EnableUseCaseAutoFilling(bool isEnabled)
 628 {
 629   if(_isLocal) _local_impl->EnableUseCaseAutoFilling(isEnabled);
 630   else _corba_impl->EnableUseCaseAutoFilling(isEnabled);
 631 }
 632
 633 bool SALOMEDS_Study::DumpStudy(const std::string& thePath,
 634                                const std::string& theBaseName,
 635                                bool isPublished,
 636                                bool isMultiFile)
 637 {
 638   //SRN: Pure CORBA DumpStudy as it does more cleaning than the local one
 639   if(CORBA::is_nil(_corba_impl)) GetStudy(); //If CORBA implementation is null then retrieve it
 640   bool ret = _corba_impl->DumpStudy(thePath.c_str(), theBaseName.c_str(), isPublished, isMultiFile);
 641   return ret;
 642 }
 643
 644 void SALOMEDS_Study::SetStudyLock(const std::string& theLockerID)
 645 {
 646   if (_isLocal) {
 647     SALOMEDS::Locker lock;
 648     _local_impl->SetStudyLock(theLockerID.c_str());
 649   }
 650   else _corba_impl->SetStudyLock((char*)theLockerID.c_str());
 651 }
 652
 653 bool SALOMEDS_Study::IsStudyLocked()
 654 {
 655   bool isLocked;
 656   if (_isLocal) {
 657     SALOMEDS::Locker lock;
 658     isLocked = _local_impl->IsStudyLocked();
 659   }
 660   else isLocked = _corba_impl->IsStudyLocked();
 661   return isLocked;
 662 }
 663
 664 void SALOMEDS_Study::UnLockStudy(const std::string& theLockerID)
 665 {
 666   if(_isLocal) _local_impl->UnLockStudy(theLockerID.c_str());
 667   else _corba_impl->UnLockStudy((char*)theLockerID.c_str());
 668 }
 669
 670 std::vector<std::string> SALOMEDS_Study::GetLockerID()
 671 {
 672   std::vector<std::string> aVector;
 673   int aLength, i;
 674   if (_isLocal) {
 675     SALOMEDS::Locker lock;
 676     aVector = _local_impl->GetLockerID();
 677   }
 678   else {
 679     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetLockerID();
 680     aLength = aSeq->length();
 681     for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
 682   }
 683   return aVector;
 684 }
 685
 686
 687 void SALOMEDS_Study::SetReal(const std::string& theVarName, const double theValue)
 688 {
 689   if (_isLocal) {
 690     SALOMEDS::Locker lock;
 691     _local_impl->SetVariable(theVarName,
 692                              theValue,
 693                              SALOMEDSImpl_GenericVariable::REAL_VAR);
 694   }
 695   else
 696     _corba_impl->SetReal((char*)theVarName.c_str(),theValue);
 697 }
 698
 699 void SALOMEDS_Study::SetInteger(const std::string& theVarName, const int theValue)
 700 {
 701   if (_isLocal) {
 702     SALOMEDS::Locker lock;
 703     _local_impl->SetVariable(theVarName,
 704                              theValue,
 705                              SALOMEDSImpl_GenericVariable::INTEGER_VAR);
 706   }
 707   else
 708     _corba_impl->SetInteger((char*)theVarName.c_str(),theValue);
 709 }
 710
 711 void SALOMEDS_Study::SetBoolean(const std::string& theVarName, const bool theValue)
 712 {
 713   if (_isLocal) {
 714     SALOMEDS::Locker lock;
 715     _local_impl->SetVariable(theVarName,
 716                              theValue,
 717                              SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
 718   }
 719   else
 720     _corba_impl->SetBoolean((char*)theVarName.c_str(),theValue);
 721 }
 722
 723 void SALOMEDS_Study::SetString(const std::string& theVarName, const std::string& theValue)
 724 {
 725   if (_isLocal) {
 726     SALOMEDS::Locker lock;
 727     _local_impl->SetStringVariable(theVarName,
 728                                    theValue,
 729                                    SALOMEDSImpl_GenericVariable::STRING_VAR);
 730   }
 731   else
 732     _corba_impl->SetString((char*)theVarName.c_str(),(char*)theValue.c_str());
 733 }
 734
 735 void SALOMEDS_Study::SetStringAsDouble(const std::string& theVarName, const double theValue)
 736 {
 737   if (_isLocal) {
 738     SALOMEDS::Locker lock;
 739     _local_impl->SetStringVariableAsDouble(theVarName,
 740                                            theValue,
 741                                            SALOMEDSImpl_GenericVariable::STRING_VAR);
 742   }
 743   else
 744     _corba_impl->SetStringAsDouble((char*)theVarName.c_str(),theValue);
 745 }
 746
 747 double SALOMEDS_Study::GetReal(const std::string& theVarName)
 748 {
 749   double aResult;
 750   if (_isLocal) {
 751     SALOMEDS::Locker lock;
 752     aResult = _local_impl->GetVariableValue(theVarName);
 753   }
 754   else
 755     aResult = _corba_impl->GetReal((char*)theVarName.c_str());
 756   return aResult;
 757 }
 758
 759 int SALOMEDS_Study::GetInteger(const std::string& theVarName)
 760 {
 761   int aResult;
 762   if (_isLocal) {
 763     SALOMEDS::Locker lock;
 764     aResult = (int) _local_impl->GetVariableValue(theVarName);
 765   }
 766   else
 767     aResult = _corba_impl->GetInteger((char*)theVarName.c_str());
 768   return aResult;
 769 }
 770
 771 bool SALOMEDS_Study::GetBoolean(const std::string& theVarName)
 772 {
 773   bool aResult;
 774   if (_isLocal) {
 775     SALOMEDS::Locker lock;
 776     aResult = (bool) _local_impl->GetVariableValue(theVarName);
 777   }
 778   else
 779     aResult = _corba_impl->GetBoolean((char*)theVarName.c_str());
 780   return aResult;
 781 }
 782
 783 std::string SALOMEDS_Study::GetString(const std::string& theVarName)
 784 {
 785   std::string aResult;
 786   if (_isLocal) {
 787     SALOMEDS::Locker lock;
 788     aResult = _local_impl->GetStringVariableValue(theVarName);
 789   }
 790   else
 791     aResult = _corba_impl->GetString((char*)theVarName.c_str());
 792   return aResult;
 793 }
 794
 795 bool SALOMEDS_Study::IsReal(const std::string& theVarName)
 796 {
 797   bool aResult;
 798   if (_isLocal) {
 799     SALOMEDS::Locker lock;
 800     aResult = _local_impl->IsTypeOf(theVarName,
 801                                    SALOMEDSImpl_GenericVariable::REAL_VAR);
 802   }
 803   else
 804     aResult = _corba_impl->IsReal((char*)theVarName.c_str());
 805   return aResult;
 806 }
 807
 808 bool SALOMEDS_Study::IsInteger(const std::string& theVarName)
 809 {
 810   bool aResult;
 811   if (_isLocal) {
 812     SALOMEDS::Locker lock;
 813     aResult = _local_impl->IsTypeOf(theVarName,
 814                                    SALOMEDSImpl_GenericVariable::INTEGER_VAR);
 815   }
 816   else
 817     aResult = _corba_impl->IsInteger((char*)theVarName.c_str());
 818   return aResult;
 819 }
 820
 821 bool SALOMEDS_Study::IsBoolean(const std::string& theVarName)
 822 {
 823   bool aResult;
 824   if (_isLocal) {
 825     SALOMEDS::Locker lock;
 826     aResult = _local_impl->IsTypeOf(theVarName,
 827                                    SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
 828   }
 829   else
 830     aResult = _corba_impl->IsBoolean((char*)theVarName.c_str());
 831   return aResult;
 832 }
 833
 834 bool SALOMEDS_Study::IsString(const std::string& theVarName)
 835 {
 836   bool aResult;
 837   if (_isLocal) {
 838     SALOMEDS::Locker lock;
 839     aResult = _local_impl->IsTypeOf(theVarName,
 840                                     SALOMEDSImpl_GenericVariable::STRING_VAR);
 841   }
 842   else
 843     aResult = _corba_impl->IsString((char*)theVarName.c_str());
 844   return aResult;
 845 }
 846
 847 bool SALOMEDS_Study::IsVariable(const std::string& theVarName)
 848 {
 849   bool aResult;
 850   if (_isLocal) {
 851     SALOMEDS::Locker lock;
 852     aResult = _local_impl->IsVariable(theVarName);
 853   }
 854   else
 855     aResult = _corba_impl->IsVariable((char*)theVarName.c_str());
 856   return aResult;
 857 }
 858
 859 std::vector<std::string> SALOMEDS_Study::GetVariableNames()
 860 {
 861   std::vector<std::string> aVector;
 862   if (_isLocal) {
 863     SALOMEDS::Locker lock;
 864     aVector = _local_impl->GetVariableNames();
 865   }
 866   else {
 867     SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetVariableNames();
 868     int aLength = aSeq->length();
 869     for (int i = 0; i < aLength; i++)
 870       aVector.push_back( std::string(aSeq[i].in()) );
 871   }
 872   return aVector;
 873 }
 874
 875 bool SALOMEDS_Study::RemoveVariable(const std::string& theVarName)
 876 {
 877   bool aResult;
 878   if (_isLocal) {
 879     SALOMEDS::Locker lock;
 880     aResult = _local_impl->RemoveVariable(theVarName);
 881   }
 882   else
 883     aResult = _corba_impl->RemoveVariable((char*)theVarName.c_str());
 884   return aResult;
 885 }
 886
 887 bool SALOMEDS_Study::RenameVariable(const std::string& theVarName, const std::string& theNewVarName)
 888 {
 889   bool aResult;
 890   if (_isLocal) {
 891     SALOMEDS::Locker lock;
 892     aResult = _local_impl->RenameVariable(theVarName, theNewVarName);
 893   }
 894   else
 895     aResult = _corba_impl->RenameVariable((char*)theVarName.c_str(), (char*)theNewVarName.c_str());
 896   return aResult;
 897 }
 898
 899 bool SALOMEDS_Study::IsVariableUsed(const std::string& theVarName)
 900 {
 901   bool aResult;
 902   if (_isLocal) {
 903     SALOMEDS::Locker lock;
 904     aResult = _local_impl->IsVariableUsed(theVarName);
 905   }
 906   else
 907     aResult = _corba_impl->IsVariableUsed((char*)theVarName.c_str());
 908   return aResult;
 909 }
 910
 911 std::vector< std::vector<std::string> > SALOMEDS_Study::ParseVariables(const std::string& theVars)
 912 {
 913   std::vector< std::vector<std::string> > aResult;
 914   if (_isLocal) {
 915     SALOMEDS::Locker lock;
 916     aResult = _local_impl->ParseVariables(theVars);
 917   }
 918   else {
 919     SALOMEDS::ListOfListOfStrings_var aSeq = _corba_impl->ParseVariables(theVars.c_str());
 920     for (int i = 0, n = aSeq->length(); i < n; i++) {
 921       std::vector<std::string> aVector;
 922       SALOMEDS::ListOfStrings aSection = aSeq[i];
 923       for (int j = 0, m = aSection.length(); j < m; j++) {
 924         aVector.push_back( std::string(aSection[j].in()) );
 925       }
 926       aResult.push_back( aVector );
 927     }
 928   }
 929   return aResult;
 930 }
 931
 932 std::string SALOMEDS_Study::ConvertObjectToIOR(CORBA::Object_ptr theObject)
 933 {
 934   return _orb->object_to_string(theObject);
 935 }
 936
 937 CORBA::Object_ptr SALOMEDS_Study::ConvertIORToObject(const std::string& theIOR)
 938 {
 939   return _orb->string_to_object(theIOR.c_str());
 940 }
 941
 942 void SALOMEDS_Study::init_orb()
 943 {
 944   ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
 945   ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
 946   _orb = init(0 , 0 ) ;
 947 }
 948
 949 SALOMEDS::Study_ptr SALOMEDS_Study::GetStudy()
 950 {
 951   if (_isLocal) {
 952     SALOMEDS::Locker lock;
 953
 954     if (!CORBA::is_nil(_corba_impl)) return SALOMEDS::Study::_duplicate(_corba_impl);
 955     std::string anIOR = _local_impl->GetTransientReference();
 956     SALOMEDS::Study_var aStudy;
 957     if (!_local_impl->IsError() && anIOR != "") {
 958       aStudy = SALOMEDS::Study::_narrow(_orb->string_to_object(anIOR.c_str()));
 959     }
 960     else {
 961       SALOMEDS_Study_i *aStudy_servant = new SALOMEDS_Study_i(_local_impl, _orb);
 962       aStudy = aStudy_servant->_this();
 963       _local_impl->SetTransientReference(_orb->object_to_string(aStudy));
 964     }
 965     _corba_impl = SALOMEDS::Study::_duplicate(aStudy);
 966     return aStudy._retn();
 967   }
 968   else {
 969     return SALOMEDS::Study::_duplicate(_corba_impl);
 970   }
 971
 972   return SALOMEDS::Study::_nil();
 973 }
 974
 975
 976 _PTR(AttributeParameter) SALOMEDS_Study::GetCommonParameters(const std::string& theID, int theSavePoint)
 977 {
 978   SALOMEDSClient_AttributeParameter* AP = NULL;
 979   if(theSavePoint >= 0) {
 980     if (_isLocal) {
 981       SALOMEDS::Locker lock;
 982       AP = new SALOMEDS_AttributeParameter(_local_impl->GetCommonParameters(theID.c_str(), theSavePoint));
 983     }
 984     else {
 985       AP = new SALOMEDS_AttributeParameter(_corba_impl->GetCommonParameters(theID.c_str(), theSavePoint));
 986     }
 987   }
 988   return _PTR(AttributeParameter)(AP);
 989 }
 990
 991 _PTR(AttributeParameter) SALOMEDS_Study::GetModuleParameters(const std::string& theID,
 992                                                              const std::string& theModuleName, int theSavePoint)
 993 {
 994   SALOMEDSClient_AttributeParameter* AP = NULL;
 995   if(theSavePoint > 0) {
 996     if (_isLocal) {
 997       SALOMEDS::Locker lock;
 998       AP = new SALOMEDS_AttributeParameter(_local_impl->GetModuleParameters(theID.c_str(), theModuleName.c_str(), theSavePoint));
 999     }
1000     else {
1001       AP = new SALOMEDS_AttributeParameter(_corba_impl->GetModuleParameters(theID.c_str(), theModuleName.c_str(), theSavePoint));
1002     }
1003   }
1004   return _PTR(AttributeParameter)(AP);
1005 }
1006
1007 void SALOMEDS_Study::attach(SALOMEDS::Observer_ptr theObserver,bool modify)
1008 {
1009   if(CORBA::is_nil(_corba_impl)) GetStudy(); //If CORBA implementation is null then retrieve it
1010   _corba_impl->attach(theObserver,modify);
1011 }
1012
1013 void SALOMEDS_Study::detach(SALOMEDS::Observer_ptr theObserver)
1014 {
1015   if(CORBA::is_nil(_corba_impl)) GetStudy(); //If CORBA implementation is null then retrieve it
1016   _corba_impl->detach(theObserver);
1017 }