src/SALOMEDS/SALOMEDS_Study_i.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_i.cxx
  21 //  Author : Sergey RUIN
  22 //  Module : SALOME
  23
  24
  25 #include "utilities.h"
  26 #include "SALOMEDS_Study_i.hxx"
  27 #include "SALOMEDS_UseCaseIterator_i.hxx"
  28 #include "SALOMEDS_GenericAttribute_i.hxx"
  29 #include "SALOMEDS_AttributeStudyProperties_i.hxx"
  30 #include "SALOMEDS_AttributeParameter_i.hxx"
  31 #include "SALOMEDS_ChildIterator_i.hxx"
  32 #include "SALOMEDS_Driver_i.hxx"
  33 #include "SALOMEDS.hxx"
  34
  35 #include "SALOMEDSImpl_SObject.hxx"
  36 #include "SALOMEDSImpl_SComponent.hxx"
  37 #include "SALOMEDSImpl_UseCaseBuilder.hxx"
  38 #include "SALOMEDSImpl_AttributeStudyProperties.hxx"
  39 #include "SALOMEDSImpl_AttributeParameter.hxx"
  40 #include "SALOMEDSImpl_ChildIterator.hxx"
  41 #include "SALOMEDSImpl_IParameters.hxx"
  42
  43 #include <TColStd_SequenceOfExtendedString.hxx>
  44 #include <TColStd_HSequenceOfAsciiString.hxx>
  45 #include <TColStd_HSequenceOfTransient.hxx>
  46 #include <TCollection_AsciiString.hxx>
  47 #include <TCollection_ExtendedString.hxx>
  48
  49 #include <TDF_Label.hxx>
  50 #include <TDF_Attribute.hxx>
  51
  52 #ifdef WIN32
  53 #include <process.h>
  54 #else
  55 #include <sys/types.h>
  56 #include <unistd.h>
  57 #endif
  58
  59 #include "OpUtil.hxx"
  60
  61 using namespace std;
  62
  63 //============================================================================
  64 /*! Function : SALOMEDS_Study_i
  65  *  Purpose  : SALOMEDS_Study_i constructor
  66  */
  67 //============================================================================
  68 SALOMEDS_Study_i::SALOMEDS_Study_i(const Handle(SALOMEDSImpl_Study) theImpl,
  69                                    CORBA::ORB_ptr orb)
  70 {
  71   _orb = CORBA::ORB::_duplicate(orb);
  72   _impl = theImpl;
  73
  74   _builder = new SALOMEDS_StudyBuilder_i(_impl->NewBuilder(), _orb);
  75 }
  76
  77 //============================================================================
  78 /*! Function : ~SALOMEDS_Study_i
  79  *  Purpose  : SALOMEDS_Study_i destructor
  80  */
  81 //============================================================================
  82 SALOMEDS_Study_i::~SALOMEDS_Study_i()
  83 {
  84 }
  85
  86 //============================================================================
  87 /*! Function : GetPersistentReference
  88  *  Purpose  : Get persistent reference of study (idem URL())
  89  */
  90 //============================================================================
  91 char* SALOMEDS_Study_i::GetPersistentReference()
  92 {
  93   SALOMEDS::Locker lock;
  94   return CORBA::string_dup(_impl->GetPersistentReference().ToCString());
  95 }
  96 //============================================================================
  97 /*! Function : GetTransientReference
  98  *  Purpose  : Get IOR of the Study (registred in OCAF document in doc->Root)
  99  */
 100 //============================================================================
 101 char* SALOMEDS_Study_i::GetTransientReference()
 102 {
 103   SALOMEDS::Locker lock;
 104   return CORBA::string_dup(_impl->GetTransientReference().ToCString());
 105 }
 106
 107 //============================================================================
 108 /*! Function : IsEmpty
 109  *  Purpose  : Detect if study is empty
 110  */
 111 //============================================================================
 112 CORBA::Boolean SALOMEDS_Study_i::IsEmpty()
 113 {
 114   SALOMEDS::Locker lock;
 115   return _impl->IsEmpty();
 116 }
 117
 118 //============================================================================
 119 /*! Function : FindComponent
 120  *  Purpose  : Find a Component with ComponentDataType = aComponentName
 121  */
 122 //============================================================================
 123 SALOMEDS::SComponent_ptr SALOMEDS_Study_i::FindComponent (const char* aComponentName)
 124 {
 125   SALOMEDS::Locker lock;
 126
 127   Handle(SALOMEDSImpl_SComponent) aCompImpl = _impl->FindComponent(TCollection_AsciiString((char*)aComponentName));
 128   if(aCompImpl.IsNull()) return SALOMEDS::SComponent::_nil();
 129
 130   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aCompImpl, _orb);
 131   return sco._retn();
 132 }
 133
 134 //============================================================================
 135 /*! Function : FindComponentID
 136  *  Purpose  : Find a Component from it's ID
 137  */
 138 //============================================================================
 139 SALOMEDS::SComponent_ptr SALOMEDS_Study_i::FindComponentID(const char* aComponentID)
 140 {
 141   SALOMEDS::Locker lock;
 142
 143   Handle(SALOMEDSImpl_SComponent) aCompImpl = _impl->FindComponentID(TCollection_AsciiString((char*)aComponentID));
 144   if(aCompImpl.IsNull()) return SALOMEDS::SComponent::_nil();
 145
 146   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aCompImpl, _orb);
 147   return sco._retn();
 148 }
 149
 150 //============================================================================
 151 /*! Function : FindObject
 152  *  Purpose  : Find an Object with SALOMEDS::Name = anObjectName
 153  */
 154 //============================================================================
 155 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObject(const char* anObjectName)
 156 {
 157   SALOMEDS::Locker lock;
 158
 159   Handle(SALOMEDSImpl_SObject) aSO = _impl->FindObject(TCollection_AsciiString((char*)anObjectName));
 160   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
 161
 162   if(aSO->DynamicType() == STANDARD_TYPE(SALOMEDSImpl_SComponent)) {
 163     Handle(SALOMEDSImpl_SComponent) aSCO = Handle(SALOMEDSImpl_SComponent)::DownCast(aSO);
 164     SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aSCO, _orb);
 165     return sco._retn();
 166   }
 167
 168   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 169
 170  return so._retn();
 171 }
 172
 173 //============================================================================
 174 /*! Function : FindObjectID
 175  *  Purpose  : Find an Object with ID = anObjectID
 176  */
 177 //============================================================================
 178 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObjectID(const char* anObjectID)
 179 {
 180   SALOMEDS::Locker lock;
 181
 182   Handle(SALOMEDSImpl_SObject) aSO = _impl->FindObjectID(TCollection_AsciiString((char*)anObjectID));
 183   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
 184   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 185   return so._retn();
 186 }
 187
 188 //============================================================================
 189 /*! Function : CreateObjectID
 190  *  Purpose  : Creates an Object with ID = anObjectID
 191  */
 192 //============================================================================
 193 SALOMEDS::SObject_ptr SALOMEDS_Study_i::CreateObjectID(const char* anObjectID)
 194 {
 195   SALOMEDS::Locker lock;
 196
 197   Handle(SALOMEDSImpl_SObject) aSO = _impl->CreateObjectID((char*)anObjectID);
 198   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
 199
 200   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 201   return so._retn();
 202 }
 203
 204 //============================================================================
 205 /*! Function : FindObjectByName
 206  *  Purpose  : Find Objects with SALOMEDS::Name = anObjectName in a Component
 207  *           : with ComponentDataType = aComponentName
 208  */
 209 //============================================================================
 210 SALOMEDS::Study::ListOfSObject* SALOMEDS_Study_i::FindObjectByName( const char* anObjectName,
 211                                                                     const char* aComponentName )
 212 {
 213   SALOMEDS::Locker lock;
 214
 215   Handle(TColStd_HSequenceOfTransient) aSeq = _impl->FindObjectByName(TCollection_AsciiString((char*)anObjectName),
 216                                                                       TCollection_AsciiString((char*)aComponentName));
 217   int aLength = aSeq->Length();
 218   SALOMEDS::Study::ListOfSObject_var listSO = new SALOMEDS::Study::ListOfSObject ;
 219   listSO->length(aLength);
 220   for(int i = 1; i<=aLength; i++) {
 221     Handle(SALOMEDSImpl_SObject) aSO = Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i));
 222     SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 223     listSO[i-1] = so ;
 224   }
 225   return listSO._retn() ;
 226 }
 227
 228 //============================================================================
 229 /*! Function : FindObjectIOR
 230  *  Purpose  : Find an Object with IOR = anObjectIOR
 231  */
 232 //============================================================================
 233 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObjectIOR(const char* anObjectIOR)
 234 {
 235   SALOMEDS::Locker lock;
 236
 237   Handle(SALOMEDSImpl_SObject) aSO = _impl->FindObjectIOR(TCollection_AsciiString((char*)anObjectIOR));
 238   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
 239
 240   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 241   return so._retn();
 242 }
 243
 244 //============================================================================
 245 /*! Function : FindObjectByPath
 246  *  Purpose  : Find an Object by its path = thePath
 247  */
 248 //============================================================================
 249 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObjectByPath(const char* thePath)
 250 {
 251   SALOMEDS::Locker lock;
 252
 253   Handle(SALOMEDSImpl_SObject) aSO = _impl->FindObjectByPath(TCollection_AsciiString((char*)thePath));
 254   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
 255
 256   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
 257   return so._retn();
 258 }
 259
 260 //============================================================================
 261 /*! Function : GetObjectPath
 262  *  Purpose  :
 263  */
 264 //============================================================================
 265 char* SALOMEDS_Study_i::GetObjectPath(CORBA::Object_ptr theObject)
 266 {
 267   SALOMEDS::Locker lock;
 268
 269   TCollection_AsciiString aPath("");
 270   if(CORBA::is_nil(theObject)) return CORBA::string_dup(aPath.ToCString());
 271   Handle(SALOMEDSImpl_SObject) aSO;
 272   SALOMEDS::SObject_var aSObj = SALOMEDS::SObject::_narrow(theObject);
 273
 274   if(!CORBA::is_nil(aSObj)) {
 275     aSO = _impl->FindObjectID(aSObj->GetID());
 276   }
 277   else {
 278     CORBA::String_var objStr = _orb->object_to_string(theObject);
 279     TCollection_AsciiString anAscii((char *)objStr.in());
 280     aSO  = _impl->FindObjectIOR(anAscii);
 281   }
 282
 283   if(aSO.IsNull()) return CORBA::string_dup(aPath.ToCString());
 284
 285   aPath = _impl->GetObjectPath(aSO);
 286   return  CORBA::string_dup(aPath.ToCString());
 287 }
 288
 289
 290 //============================================================================
 291 /*! Function : SetContext
 292  *  Purpose  : Sets the current context
 293  */
 294 //============================================================================
 295 void SALOMEDS_Study_i::SetContext(const char* thePath)
 296 {
 297   SALOMEDS::Locker lock;
 298
 299   _impl->SetContext(TCollection_AsciiString((char*)thePath));
 300   if(_impl->IsError() && _impl->GetErrorCode() == "InvalidContext")
 301     throw SALOMEDS::Study::StudyInvalidContext();
 302 }
 303
 304 //============================================================================
 305 /*! Function : GetContext
 306  *  Purpose  : Gets the current context
 307  */
 308 //============================================================================
 309 char* SALOMEDS_Study_i::GetContext()
 310 {
 311   SALOMEDS::Locker lock;
 312
 313   if(!_impl->HasCurrentContext()) throw SALOMEDS::Study::StudyInvalidContext();
 314   return CORBA::string_dup(_impl->GetContext().ToCString());
 315 }
 316
 317 //============================================================================
 318 /*! Function : GetObjectNames
 319  *  Purpose  : method to get all object names in the given context (or in the current context, if 'theContext' is empty)
 320  */
 321 //============================================================================
 322 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetObjectNames(const char* theContext)
 323 {
 324   SALOMEDS::Locker lock;
 325
 326   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 327
 328   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 329     throw SALOMEDS::Study::StudyInvalidContext();
 330
 331   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 332     _impl->GetObjectNames(TCollection_AsciiString((char*)theContext));
 333   if (_impl->GetErrorCode() == "InvalidContext")
 334     throw SALOMEDS::Study::StudyInvalidContext();
 335
 336   int aLength = aSeq->Length();
 337   aResult->length(aLength);
 338   for (int anIndex = 1; anIndex <= aLength; anIndex++) {
 339     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 340   }
 341
 342   return aResult._retn();
 343 }
 344
 345 //============================================================================
 346 /*! Function : GetDirectoryNames
 347  *  Purpose  : method to get all directory names in the given context (or in the current context, if 'theContext' is empty)
 348  */
 349 //============================================================================
 350 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetDirectoryNames(const char* theContext)
 351 {
 352   SALOMEDS::Locker lock;
 353
 354   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 355
 356   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 357     throw SALOMEDS::Study::StudyInvalidContext();
 358
 359   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 360     _impl->GetDirectoryNames(TCollection_AsciiString((char*)theContext));
 361   if (_impl->GetErrorCode() == "InvalidContext")
 362     throw SALOMEDS::Study::StudyInvalidContext();
 363
 364   int aLength = aSeq->Length();
 365   aResult->length(aLength);
 366   for (int anIndex = 1; anIndex <= aLength; anIndex++) {
 367     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 368   }
 369
 370   return aResult._retn();
 371 }
 372
 373 //============================================================================
 374 /*! Function : GetFileNames
 375  *  Purpose  : method to get all file names in the given context (or in the current context, if 'theContext' is empty)
 376  */
 377 //============================================================================
 378 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetFileNames(const char* theContext)
 379 {
 380   SALOMEDS::Locker lock;
 381
 382   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 383
 384   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 385     throw SALOMEDS::Study::StudyInvalidContext();
 386
 387   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 388     _impl->GetFileNames(TCollection_AsciiString((char*)theContext));
 389   if (_impl->GetErrorCode() == "InvalidContext")
 390     throw SALOMEDS::Study::StudyInvalidContext();
 391
 392   int aLength = aSeq->Length();
 393   aResult->length(aLength);
 394   for (int anIndex = 1; anIndex <= aLength; anIndex++) {
 395     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 396   }
 397
 398   return aResult._retn();
 399 }
 400
 401 //============================================================================
 402 /*! Function : GetComponentNames
 403  *  Purpose  : method to get all components names
 404  */
 405 //============================================================================
 406 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetComponentNames(const char* theContext)
 407 {
 408   SALOMEDS::Locker lock;
 409
 410   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 411
 412   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 413     throw SALOMEDS::Study::StudyInvalidContext();
 414
 415   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 416     _impl->GetComponentNames(TCollection_AsciiString((char*)theContext));
 417
 418   int aLength = aSeq->Length();
 419   aResult->length(aLength);
 420   for(int anIndex = 1; anIndex <= aLength; anIndex++) {
 421     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 422   }
 423
 424   return aResult._retn();
 425 }
 426
 427 //============================================================================
 428 /*! Function : NewChildIterator
 429  *  Purpose  : Create a ChildIterator from an SObject
 430  */
 431 //============================================================================
 432 SALOMEDS::ChildIterator_ptr SALOMEDS_Study_i::NewChildIterator(SALOMEDS::SObject_ptr theSO)
 433 {
 434   SALOMEDS::Locker lock;
 435
 436   Handle(SALOMEDSImpl_SObject) aSO = _impl->GetSObject(theSO->GetID());
 437   Handle(SALOMEDSImpl_ChildIterator) anItr = new SALOMEDSImpl_ChildIterator(aSO);
 438
 439   //Create iterator
 440   SALOMEDS_ChildIterator_i* it_servant = new SALOMEDS_ChildIterator_i(anItr, _orb);
 441   SALOMEDS::ChildIterator_var it = SALOMEDS::ChildIterator::_narrow(it_servant->_this());
 442
 443   return it;
 444 }
 445
 446
 447 //============================================================================
 448 /*! Function : NewComponentIterator
 449  *  Purpose  : Create a SComponentIterator
 450  */
 451 //============================================================================
 452 SALOMEDS::SComponentIterator_ptr SALOMEDS_Study_i::NewComponentIterator()
 453 {
 454   SALOMEDS::Locker lock;
 455   SALOMEDS_SComponentIterator_i* _it = new SALOMEDS_SComponentIterator_i(_impl->NewComponentIterator(), _orb);
 456   _it->Init();
 457   return _it->_this();
 458 }
 459
 460
 461 //============================================================================
 462 /*! Function : NewBuilder
 463  *  Purpose  : Create a StudyBuilder
 464  */
 465 //============================================================================
 466 SALOMEDS::StudyBuilder_ptr SALOMEDS_Study_i::NewBuilder()
 467 {
 468   SALOMEDS::Locker lock;
 469   return _builder->_this();
 470 }
 471
 472 //============================================================================
 473 /*! Function : Name
 474  *  Purpose  : get study name
 475  */
 476 //============================================================================
 477 char* SALOMEDS_Study_i::Name()
 478 {
 479   SALOMEDS::Locker lock;
 480   return CORBA::string_dup(_impl->Name().ToCString());
 481 }
 482
 483 //============================================================================
 484 /*! Function : Name
 485  *  Purpose  : set study name
 486  */
 487 //============================================================================
 488 void SALOMEDS_Study_i::Name(const char* name)
 489 {
 490   SALOMEDS::Locker lock;
 491   _impl->Name(TCollection_AsciiString((char*)name));
 492 }
 493
 494 //============================================================================
 495 /*! Function : IsSaved
 496  *  Purpose  : get if study has been saved
 497  */
 498 //============================================================================
 499 CORBA::Boolean  SALOMEDS_Study_i::IsSaved()
 500 {
 501   SALOMEDS::Locker lock;
 502   return _impl->IsSaved();
 503 }
 504
 505 //============================================================================
 506 /*! Function : IsSaved
 507  *  Purpose  : set if study has been saved
 508  */
 509 //============================================================================
 510 void SALOMEDS_Study_i::IsSaved(CORBA::Boolean save)
 511 {
 512   SALOMEDS::Locker lock;
 513   _impl->IsSaved(save);
 514 }
 515
 516 //============================================================================
 517 /*! Function : IsModified
 518  *  Purpose  : Detect if a Study has been modified since it has been saved
 519  */
 520 //============================================================================
 521 CORBA::Boolean  SALOMEDS_Study_i::IsModified()
 522 {
 523   SALOMEDS::Locker lock;
 524   return _impl->IsModified();
 525 }
 526
 527 //============================================================================
 528 /*! Function : URL
 529  *  Purpose  : get URL of the study (persistent reference of the study)
 530  */
 531 //============================================================================
 532 char* SALOMEDS_Study_i::URL()
 533 {
 534   SALOMEDS::Locker lock;
 535   return CORBA::string_dup(_impl->URL().ToCString());
 536 }
 537
 538 //============================================================================
 539 /*! Function : URL
 540  *  Purpose  : set URL of the study (persistent reference of the study)
 541  */
 542 //============================================================================
 543 void SALOMEDS_Study_i::URL(const char* url)
 544 {
 545   SALOMEDS::Locker lock;
 546   _impl->URL(TCollection_AsciiString((char*)url));
 547 }
 548
 549
 550 CORBA::Short SALOMEDS_Study_i::StudyId()
 551 {
 552   SALOMEDS::Locker lock;
 553   return _impl->StudyId();
 554 }
 555
 556 void SALOMEDS_Study_i::StudyId(CORBA::Short id)
 557 {
 558   SALOMEDS::Locker lock;
 559   _impl->StudyId(id);
 560 }
 561
 562 void SALOMEDS_Study_i::UpdateIORLabelMap(const char* anIOR,const char* anEntry)
 563 {
 564   SALOMEDS::Locker lock;
 565   _impl->UpdateIORLabelMap(TCollection_AsciiString((char*)anIOR), TCollection_AsciiString((char*)anEntry));
 566 }
 567
 568 SALOMEDS::Study_ptr SALOMEDS_Study_i::GetStudy(const TDF_Label theLabel, CORBA::ORB_ptr orb)
 569 {
 570   SALOMEDS::Locker lock;
 571
 572   Handle(SALOMEDSImpl_AttributeIOR) Att;
 573   if (theLabel.Root().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID(),Att)){
 574     char* IOR = CORBA::string_dup(TCollection_AsciiString(Att->Value()).ToCString());
 575     CORBA::Object_var obj = orb->string_to_object(IOR);
 576     SALOMEDS::Study_ptr aStudy = SALOMEDS::Study::_narrow(obj) ;
 577     ASSERT(!CORBA::is_nil(aStudy));
 578     return SALOMEDS::Study::_duplicate(aStudy);
 579   } else {
 580     MESSAGE("GetStudy: Problem to get study");
 581   }
 582   return SALOMEDS::Study::_nil();
 583 }
 584
 585 void SALOMEDS_Study_i::IORUpdated(const Handle(SALOMEDSImpl_AttributeIOR) theAttribute)
 586 {
 587   SALOMEDS::Locker lock;
 588   SALOMEDSImpl_Study::IORUpdated(theAttribute);
 589 }
 590
 591 SALOMEDS::Study::ListOfSObject* SALOMEDS_Study_i::FindDependances(SALOMEDS::SObject_ptr anObject)
 592 {
 593   SALOMEDS::Locker lock;
 594
 595   SALOMEDS::GenericAttribute_ptr aTarget;
 596   if (anObject->FindAttribute(aTarget,"AttributeTarget")) {
 597     return SALOMEDS::AttributeTarget::_narrow(aTarget)->Get();
 598   }
 599   SALOMEDS::Study::ListOfSObject* aList = new SALOMEDS::Study::ListOfSObject;
 600   aList->length(0);
 601   return aList;
 602 }
 603
 604
 605 SALOMEDS::AttributeStudyProperties_ptr SALOMEDS_Study_i::GetProperties()
 606 {
 607   SALOMEDS::Locker lock;
 608
 609   Handle(SALOMEDSImpl_AttributeStudyProperties) anAttr = _impl->GetProperties();
 610   SALOMEDS_AttributeStudyProperties_i* SP = new SALOMEDS_AttributeStudyProperties_i(anAttr, _orb);
 611   return SP->AttributeStudyProperties::_this();
 612 }
 613
 614 char* SALOMEDS_Study_i::GetLastModificationDate()
 615 {
 616   SALOMEDS::Locker lock;
 617   return CORBA::string_dup(_impl->GetLastModificationDate().ToCString());
 618 }
 619
 620 SALOMEDS::ListOfDates* SALOMEDS_Study_i::GetModificationsDate()
 621 {
 622   SALOMEDS::Locker lock;
 623
 624   Handle(TColStd_HSequenceOfAsciiString) aSeq = _impl->GetModificationsDate();
 625   int aLength = aSeq->Length();
 626   SALOMEDS::ListOfDates_var aDates = new SALOMEDS::ListOfDates;
 627   aDates->length(aLength);
 628
 629   for(int anIndex = 1; anIndex <= aLength; anIndex++) {
 630     aDates[anIndex-1] = CORBA::string_dup(aSeq->Value(anIndex).ToCString());
 631   }
 632   return aDates._retn();
 633 }
 634
 635
 636
 637 //============================================================================
 638 /*! Function : GetUseCaseBuilder
 639  *  Purpose  : Returns a UseCase builder
 640  */
 641 //============================================================================
 642 SALOMEDS::UseCaseBuilder_ptr SALOMEDS_Study_i::GetUseCaseBuilder()
 643 {
 644   SALOMEDS::Locker lock;
 645   SALOMEDS_UseCaseBuilder_i* UCBuilder = new SALOMEDS_UseCaseBuilder_i(_impl->GetUseCaseBuilder(), _orb);
 646   return UCBuilder->_this();
 647 }
 648
 649
 650 //============================================================================
 651 /*! Function : Close
 652  *  Purpose  :
 653  */
 654 //============================================================================
 655 void SALOMEDS_Study_i::Close()
 656 {
 657   SALOMEDS::Locker lock;
 658
 659   RemovePostponed(-1);
 660
 661   SALOMEDS::SComponentIterator_var itcomponent = NewComponentIterator();
 662
 663   for (; itcomponent->More(); itcomponent->Next()) {
 664     SALOMEDS::SComponent_var sco = itcomponent->Value();
 665
 666     MESSAGE ( "Look for an engine for data type :"<< sco->ComponentDataType());
 667     // if there is an associated Engine call its method for closing
 668     CORBA::String_var IOREngine;
 669     if (sco->ComponentIOR(IOREngine)) {
 670       // we have found the associated engine to write the data
 671       MESSAGE ( "We have found an engine for data type :"<< sco->ComponentDataType());
 672       CORBA::Object_var obj = _orb->string_to_object(IOREngine);
 673       if (!CORBA::is_nil(obj)) {
 674         SALOMEDS::Driver_var anEngine = SALOMEDS::Driver::_narrow(obj) ;
 675
 676         if (!anEngine->_is_nil()) {
 677           SALOMEDS::unlock();
 678           anEngine->Close(sco);
 679           SALOMEDS::lock();
 680         }
 681       }
 682     }
 683   }
 684   _impl->Close();
 685 }
 686
 687 //============================================================================
 688 /*! Function : AddPostponed
 689  *  Purpose  :
 690  */
 691  //============================================================================
 692 void SALOMEDS_Study_i::AddPostponed(const char* theIOR)
 693 {
 694   SALOMEDS::Locker lock;
 695
 696   CORBA::Object_var obj = _orb->string_to_object(theIOR);
 697   if (!CORBA::is_nil(obj)) {
 698     SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj) ;
 699     if (!CORBA::is_nil(aGeneric)) _impl->AddPostponed((char*)theIOR);
 700   }
 701 }
 702
 703 void SALOMEDS_Study_i::AddCreatedPostponed(const char* theIOR)
 704 {
 705   SALOMEDS::Locker lock;
 706
 707   CORBA::Object_var obj = _orb->string_to_object(theIOR);
 708   if (!CORBA::is_nil(obj)) {
 709     SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj) ;
 710     if (!CORBA::is_nil(aGeneric)) _impl->AddCreatedPostponed((char*)theIOR);
 711   }
 712 }
 713
 714 //============================================================================
 715 /*! Function : RemovePostponed
 716  *  Purpose  :
 717  */
 718 //============================================================================
 719 #ifndef WNT
 720 void SALOMEDS_Study_i::RemovePostponed(const CORBA::Long theUndoLimit)
 721 #else
 722 void SALOMEDS_Study_i::RemovePostponed(CORBA::Long theUndoLimit)
 723 #endif
 724 {
 725   SALOMEDS::Locker lock;
 726
 727   Handle(TColStd_HSequenceOfAsciiString) aSeq = _impl->RemovePostponed(theUndoLimit);
 728   int aLegth = aSeq->Length();
 729   for(int i = 1; i <= aLegth; i++) {
 730     TCollection_AsciiString anIOR = aSeq->Value(i);
 731     //mkr : fix for bug IPAL9408 : check the length of anIOR
 732     //                             before take value from it
 733     if ( !anIOR.IsEmpty() && anIOR.Value(1) == 'c') {
 734       CORBA::Object_var obj = _orb->string_to_object(anIOR.Split(1).ToCString());
 735       SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
 736       if (!CORBA::is_nil(aGeneric)) aGeneric->Destroy();
 737     }
 738     else if ( !anIOR.IsEmpty() && anIOR.Value(1) == 'd') {
 739       CORBA::Object_var obj = _orb->string_to_object(anIOR.Split(1).ToCString());
 740       SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
 741       if (!CORBA::is_nil(aGeneric)) aGeneric->Destroy();
 742     }
 743     else {
 744       try {
 745         CORBA::Object_var obj = _orb->string_to_object(anIOR.ToCString());
 746         SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
 747         if (!CORBA::is_nil(aGeneric)) aGeneric->Destroy();
 748       } catch (...) {}
 749     }
 750   }
 751 }
 752
 753 //============================================================================
 754 /*! Function : UndoPostponed
 755  *  Purpose  :
 756  */
 757 //============================================================================
 758 #ifndef WNT
 759 void SALOMEDS_Study_i::UndoPostponed(const CORBA::Long theWay)
 760 #else
 761 void SALOMEDS_Study_i::UndoPostponed(CORBA::Long theWay)
 762 #endif
 763 {
 764   SALOMEDS::Locker lock;
 765
 766   _impl->UndoPostponed(theWay);
 767 }
 768
 769
 770 //============================================================================
 771 /*! Function : DumpStudy
 772  *  Purpose  :
 773  */
 774 //============================================================================
 775 CORBA::Boolean SALOMEDS_Study_i::DumpStudy(const char* thePath,
 776                                            const char* theBaseName,
 777                                            CORBA::Boolean isPublished)
 778 {
 779   SALOMEDS::Locker lock;
 780
 781   TCollection_AsciiString aPath((char*)thePath), aBaseName((char*)theBaseName);
 782   SALOMEDS_DriverFactory_i* factory = new SALOMEDS_DriverFactory_i(_orb);
 783   CORBA::Boolean ret = _impl->DumpStudy(aPath, aBaseName, isPublished, factory);
 784   delete factory;
 785   return ret;
 786 }
 787
 788 //============================================================================
 789 /*! Function : GetCommonParameters
 790  *  Purpose  :
 791  */
 792 //============================================================================
 793 SALOMEDS::AttributeParameter_ptr SALOMEDS_Study_i::GetCommonParameters(const char* theID, CORBA::Long theSavePoint)
 794 {
 795   SALOMEDS::Locker lock;
 796
 797   Handle(SALOMEDSImpl_AttributeParameter) anAttr = _impl->GetCommonParameters(theID, theSavePoint);
 798   SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
 799   return SP->AttributeParameter::_this();
 800 }
 801
 802 //============================================================================
 803 /*! Function : GetCommonModuleParameters
 804  *  Purpose  :
 805  */
 806 //============================================================================
 807 SALOMEDS::AttributeParameter_ptr SALOMEDS_Study_i::GetModuleParameters(const char* theID,
 808                                                                        const char* theModuleName,
 809                                                                        CORBA::Long theSavePoint)
 810 {
 811   SALOMEDS::Locker lock;
 812
 813   Handle(SALOMEDSImpl_AttributeParameter) anAttr = _impl->GetModuleParameters(theID, theModuleName, theSavePoint);
 814   SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
 815   return SP->AttributeParameter::_this();
 816 }
 817
 818 //============================================================================
 819 /*! Function : SetStudyLock
 820  *  Purpose  :
 821  */
 822 //============================================================================
 823 void SALOMEDS_Study_i::SetStudyLock(const char* theLockerID)
 824 {
 825   SALOMEDS::Locker lock;
 826   _impl->SetStudyLock(theLockerID);
 827 }
 828
 829 //============================================================================
 830 /*! Function : IsStudyLocked
 831  *  Purpose  :
 832  */
 833 //============================================================================
 834 bool SALOMEDS_Study_i::IsStudyLocked()
 835 {
 836   SALOMEDS::Locker lock;
 837   return _impl->IsStudyLocked();
 838 }
 839
 840 //============================================================================
 841 /*! Function : UnLockStudy
 842  *  Purpose  :
 843  */
 844 //============================================================================
 845 void SALOMEDS_Study_i::UnLockStudy(const char* theLockerID)
 846 {
 847   SALOMEDS::Locker lock;
 848   _impl->UnLockStudy(theLockerID);
 849 }
 850
 851 //============================================================================
 852 /*! Function : GetLockerID
 853  *  Purpose  :
 854  */
 855 //============================================================================
 856 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetLockerID()
 857 {
 858   SALOMEDS::Locker lock;
 859
 860   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 861
 862   Handle(TColStd_HSequenceOfAsciiString) aSeq = _impl->GetLockerID();
 863
 864   int aLength = aSeq->Length();
 865   aResult->length(aLength);
 866   for(int anIndex = 1; anIndex <= aLength; anIndex++) {
 867     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 868   }
 869   return aResult._retn();
 870 }
 871
 872 //============================================================================
 873 /*! Function : GetDefaultScript
 874  *  Purpose  :
 875  */
 876 //============================================================================
 877 char* SALOMEDS_Study_i::GetDefaultScript(const char* theModuleName, const char* theShift)
 878 {
 879   SALOMEDS::Locker lock;
 880
 881   string script = SALOMEDSImpl_IParameters::getDefaultScript(_impl, theModuleName, theShift);
 882   return CORBA::string_dup(script.c_str());
 883 }
 884
 885 //===========================================================================
 886 //   PRIVATE FUNCTIONS
 887 //===========================================================================
 888 CORBA::LongLong SALOMEDS_Study_i::GetLocalImpl(const char* theHostname, CORBA::Long thePID, CORBA::Boolean& isLocal)
 889 {
 890 #ifdef WIN32
 891   long pid = (long)_getpid();
 892 #else
 893   long pid = (long)getpid();
 894 #endif
 895   isLocal = (strcmp(theHostname, GetHostname().c_str()) == 0 && pid == thePID)?1:0;
 896   SALOMEDSImpl_Study* local_impl = _impl.operator->();
 897   return ((CORBA::LongLong)local_impl);
 898 }