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     aSO  = _impl->FindObjectIOR(_orb->object_to_string(theObject));
 279   }
 280
 281   if(aSO.IsNull()) return CORBA::string_dup(aPath.ToCString());
 282
 283   aPath = _impl->GetObjectPath(aSO);
 284   return  CORBA::string_dup(aPath.ToCString());
 285 }
 286
 287
 288 //============================================================================
 289 /*! Function : SetContext
 290  *  Purpose  : Sets the current context
 291  */
 292 //============================================================================
 293 void SALOMEDS_Study_i::SetContext(const char* thePath)
 294 {
 295   SALOMEDS::Locker lock;
 296
 297   _impl->SetContext(TCollection_AsciiString((char*)thePath));
 298   if(_impl->IsError() && _impl->GetErrorCode() == "InvalidContext")
 299     throw SALOMEDS::Study::StudyInvalidContext();
 300 }
 301
 302 //============================================================================
 303 /*! Function : GetContext
 304  *  Purpose  : Gets the current context
 305  */
 306 //============================================================================
 307 char* SALOMEDS_Study_i::GetContext()
 308 {
 309   SALOMEDS::Locker lock;
 310
 311   if(!_impl->HasCurrentContext()) throw SALOMEDS::Study::StudyInvalidContext();
 312   return CORBA::string_dup(_impl->GetContext().ToCString());
 313 }
 314
 315 //============================================================================
 316 /*! Function : GetObjectNames
 317  *  Purpose  : method to get all object names in the given context (or in the current context, if 'theContext' is empty)
 318  */
 319 //============================================================================
 320 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetObjectNames(const char* theContext)
 321 {
 322   SALOMEDS::Locker lock;
 323
 324   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 325
 326   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 327     throw SALOMEDS::Study::StudyInvalidContext();
 328
 329   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 330     _impl->GetObjectNames(TCollection_AsciiString((char*)theContext));
 331   if (_impl->GetErrorCode() == "InvalidContext")
 332     throw SALOMEDS::Study::StudyInvalidContext();
 333
 334   int aLength = aSeq->Length();
 335   aResult->length(aLength);
 336   for (int anIndex = 1; anIndex <= aLength; anIndex++) {
 337     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 338   }
 339
 340   return aResult._retn();
 341 }
 342
 343 //============================================================================
 344 /*! Function : GetDirectoryNames
 345  *  Purpose  : method to get all directory names in the given context (or in the current context, if 'theContext' is empty)
 346  */
 347 //============================================================================
 348 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetDirectoryNames(const char* theContext)
 349 {
 350   SALOMEDS::Locker lock;
 351
 352   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 353
 354   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 355     throw SALOMEDS::Study::StudyInvalidContext();
 356
 357   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 358     _impl->GetDirectoryNames(TCollection_AsciiString((char*)theContext));
 359   if (_impl->GetErrorCode() == "InvalidContext")
 360     throw SALOMEDS::Study::StudyInvalidContext();
 361
 362   int aLength = aSeq->Length();
 363   aResult->length(aLength);
 364   for (int anIndex = 1; anIndex <= aLength; anIndex++) {
 365     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 366   }
 367
 368   return aResult._retn();
 369 }
 370
 371 //============================================================================
 372 /*! Function : GetFileNames
 373  *  Purpose  : method to get all file names in the given context (or in the current context, if 'theContext' is empty)
 374  */
 375 //============================================================================
 376 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetFileNames(const char* theContext)
 377 {
 378   SALOMEDS::Locker lock;
 379
 380   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 381
 382   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 383     throw SALOMEDS::Study::StudyInvalidContext();
 384
 385   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 386     _impl->GetFileNames(TCollection_AsciiString((char*)theContext));
 387   if (_impl->GetErrorCode() == "InvalidContext")
 388     throw SALOMEDS::Study::StudyInvalidContext();
 389
 390   int aLength = aSeq->Length();
 391   aResult->length(aLength);
 392   for (int anIndex = 1; anIndex <= aLength; anIndex++) {
 393     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 394   }
 395
 396   return aResult._retn();
 397 }
 398
 399 //============================================================================
 400 /*! Function : GetComponentNames
 401  *  Purpose  : method to get all components names
 402  */
 403 //============================================================================
 404 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetComponentNames(const char* theContext)
 405 {
 406   SALOMEDS::Locker lock;
 407
 408   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
 409
 410   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
 411     throw SALOMEDS::Study::StudyInvalidContext();
 412
 413   Handle(TColStd_HSequenceOfAsciiString) aSeq =
 414     _impl->GetComponentNames(TCollection_AsciiString((char*)theContext));
 415
 416   int aLength = aSeq->Length();
 417   aResult->length(aLength);
 418   for(int anIndex = 1; anIndex <= aLength; anIndex++) {
 419     aResult[anIndex-1] = CORBA::string_dup(TCollection_AsciiString(aSeq->Value(anIndex)).ToCString());
 420   }
 421
 422   return aResult._retn();
 423 }
 424
 425 //============================================================================
 426 /*! Function : NewChildIterator
 427  *  Purpose  : Create a ChildIterator from an SObject
 428  */
 429 //============================================================================
 430 SALOMEDS::ChildIterator_ptr SALOMEDS_Study_i::NewChildIterator(SALOMEDS::SObject_ptr theSO)
 431 {
 432   SALOMEDS::Locker lock;
 433
 434   Handle(SALOMEDSImpl_SObject) aSO = _impl->GetSObject(theSO->GetID());
 435   Handle(SALOMEDSImpl_ChildIterator) anItr = new SALOMEDSImpl_ChildIterator(aSO);
 436
 437   //Create iterator
 438   SALOMEDS_ChildIterator_i* it_servant = new SALOMEDS_ChildIterator_i(anItr, _orb);
 439   SALOMEDS::ChildIterator_var it = SALOMEDS::ChildIterator::_narrow(it_servant->_this());
 440
 441   return it;
 442 }
 443
 444
 445 //============================================================================
 446 /*! Function : NewComponentIterator
 447  *  Purpose  : Create a SComponentIterator
 448  */
 449 //============================================================================
 450 SALOMEDS::SComponentIterator_ptr SALOMEDS_Study_i::NewComponentIterator()
 451 {
 452   SALOMEDS::Locker lock;
 453   SALOMEDS_SComponentIterator_i* _it = new SALOMEDS_SComponentIterator_i(_impl->NewComponentIterator(), _orb);
 454   _it->Init();
 455   return _it->_this();
 456 }
 457
 458
 459 //============================================================================
 460 /*! Function : NewBuilder
 461  *  Purpose  : Create a StudyBuilder
 462  */
 463 //============================================================================
 464 SALOMEDS::StudyBuilder_ptr SALOMEDS_Study_i::NewBuilder()
 465 {
 466   SALOMEDS::Locker lock;
 467   return _builder->_this();
 468 }
 469
 470 //============================================================================
 471 /*! Function : Name
 472  *  Purpose  : get study name
 473  */
 474 //============================================================================
 475 char* SALOMEDS_Study_i::Name()
 476 {
 477   SALOMEDS::Locker lock;
 478   return CORBA::string_dup(_impl->Name().ToCString());
 479 }
 480
 481 //============================================================================
 482 /*! Function : Name
 483  *  Purpose  : set study name
 484  */
 485 //============================================================================
 486 void SALOMEDS_Study_i::Name(const char* name)
 487 {
 488   SALOMEDS::Locker lock;
 489   _impl->Name(TCollection_AsciiString((char*)name));
 490 }
 491
 492 //============================================================================
 493 /*! Function : IsSaved
 494  *  Purpose  : get if study has been saved
 495  */
 496 //============================================================================
 497 CORBA::Boolean  SALOMEDS_Study_i::IsSaved()
 498 {
 499   SALOMEDS::Locker lock;
 500   return _impl->IsSaved();
 501 }
 502
 503 //============================================================================
 504 /*! Function : IsSaved
 505  *  Purpose  : set if study has been saved
 506  */
 507 //============================================================================
 508 void SALOMEDS_Study_i::IsSaved(CORBA::Boolean save)
 509 {
 510   SALOMEDS::Locker lock;
 511   _impl->IsSaved(save);
 512 }
 513
 514 //============================================================================
 515 /*! Function : IsModified
 516  *  Purpose  : Detect if a Study has been modified since it has been saved
 517  */
 518 //============================================================================
 519 CORBA::Boolean  SALOMEDS_Study_i::IsModified()
 520 {
 521   SALOMEDS::Locker lock;
 522   return _impl->IsModified();
 523 }
 524
 525 //============================================================================
 526 /*! Function : URL
 527  *  Purpose  : get URL of the study (persistent reference of the study)
 528  */
 529 //============================================================================
 530 char* SALOMEDS_Study_i::URL()
 531 {
 532   SALOMEDS::Locker lock;
 533   return CORBA::string_dup(_impl->URL().ToCString());
 534 }
 535
 536 //============================================================================
 537 /*! Function : URL
 538  *  Purpose  : set URL of the study (persistent reference of the study)
 539  */
 540 //============================================================================
 541 void SALOMEDS_Study_i::URL(const char* url)
 542 {
 543   SALOMEDS::Locker lock;
 544   _impl->URL(TCollection_AsciiString((char*)url));
 545 }
 546
 547
 548 CORBA::Short SALOMEDS_Study_i::StudyId()
 549 {
 550   SALOMEDS::Locker lock;
 551   return _impl->StudyId();
 552 }
 553
 554 void SALOMEDS_Study_i::StudyId(CORBA::Short id)
 555 {
 556   SALOMEDS::Locker lock;
 557   _impl->StudyId(id);
 558 }
 559
 560 void SALOMEDS_Study_i::UpdateIORLabelMap(const char* anIOR,const char* anEntry)
 561 {
 562   SALOMEDS::Locker lock;
 563   _impl->UpdateIORLabelMap(TCollection_AsciiString((char*)anIOR), TCollection_AsciiString((char*)anEntry));
 564 }
 565
 566 SALOMEDS::Study_ptr SALOMEDS_Study_i::GetStudy(const TDF_Label theLabel, CORBA::ORB_ptr orb)
 567 {
 568   SALOMEDS::Locker lock;
 569
 570   Handle(SALOMEDSImpl_AttributeIOR) Att;
 571   if (theLabel.Root().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID(),Att)){
 572     char* IOR = CORBA::string_dup(TCollection_AsciiString(Att->Value()).ToCString());
 573     CORBA::Object_var obj = orb->string_to_object(IOR);
 574     SALOMEDS::Study_ptr aStudy = SALOMEDS::Study::_narrow(obj) ;
 575     ASSERT(!CORBA::is_nil(aStudy));
 576     return SALOMEDS::Study::_duplicate(aStudy);
 577   } else {
 578     MESSAGE("GetStudy: Problem to get study");
 579   }
 580   return SALOMEDS::Study::_nil();
 581 }
 582
 583 void SALOMEDS_Study_i::IORUpdated(const Handle(SALOMEDSImpl_AttributeIOR) theAttribute)
 584 {
 585   SALOMEDS::Locker lock;
 586   SALOMEDSImpl_Study::IORUpdated(theAttribute);
 587 }
 588
 589 SALOMEDS::Study::ListOfSObject* SALOMEDS_Study_i::FindDependances(SALOMEDS::SObject_ptr anObject)
 590 {
 591   SALOMEDS::Locker lock;
 592
 593   SALOMEDS::GenericAttribute_ptr aTarget;
 594   if (anObject->FindAttribute(aTarget,"AttributeTarget")) {
 595     return SALOMEDS::AttributeTarget::_narrow(aTarget)->Get();
 596   }
 597   SALOMEDS::Study::ListOfSObject* aList = new SALOMEDS::Study::ListOfSObject;
 598   aList->length(0);
 599   return aList;
 600 }
 601
 602
 603 SALOMEDS::AttributeStudyProperties_ptr SALOMEDS_Study_i::GetProperties()
 604 {
 605   SALOMEDS::Locker lock;
 606
 607   Handle(SALOMEDSImpl_AttributeStudyProperties) anAttr = _impl->GetProperties();
 608   SALOMEDS_AttributeStudyProperties_i* SP = new SALOMEDS_AttributeStudyProperties_i(anAttr, _orb);
 609   return SP->AttributeStudyProperties::_this();
 610 }
 611
 612 char* SALOMEDS_Study_i::GetLastModificationDate()
 613 {
 614   SALOMEDS::Locker lock;
 615   return CORBA::string_dup(_impl->GetLastModificationDate().ToCString());
 616 }
 617
 618 SALOMEDS::ListOfDates* SALOMEDS_Study_i::GetModificationsDate()
 619 {
 620   SALOMEDS::Locker lock;
 621
 622   Handle(TColStd_HSequenceOfAsciiString) aSeq = _impl->GetModificationsDate();
 623   int aLength = aSeq->Length();
 624   SALOMEDS::ListOfDates_var aDates = new SALOMEDS::ListOfDates;
 625   aDates->length(aLength);
 626
 627   for(int anIndex = 1; anIndex <= aLength; anIndex++) {
 628     aDates[anIndex-1] = CORBA::string_dup(aSeq->Value(anIndex).ToCString());
 629   }
 630   return aDates._retn();
 631 }
 632
 633
 634
 635 //============================================================================
 636 /*! Function : GetUseCaseBuilder
 637  *  Purpose  : Returns a UseCase builder
 638  */
 639 //============================================================================
 640 SALOMEDS::UseCaseBuilder_ptr SALOMEDS_Study_i::GetUseCaseBuilder()
 641 {
 642   SALOMEDS::Locker lock;
 643   SALOMEDS_UseCaseBuilder_i* UCBuilder = new SALOMEDS_UseCaseBuilder_i(_impl->GetUseCaseBuilder(), _orb);
 644   return UCBuilder->_this();
 645 }
 646
 647
 648 //============================================================================
 649 /*! Function : Close
 650  *  Purpose  :
 651  */
 652 //============================================================================
 653 void SALOMEDS_Study_i::Close()
 654 {
 655   SALOMEDS::Locker lock;
 656
 657   RemovePostponed(-1);
 658
 659   SALOMEDS::SComponentIterator_var itcomponent = NewComponentIterator();
 660
 661   for (; itcomponent->More(); itcomponent->Next()) {
 662     SALOMEDS::SComponent_var sco = itcomponent->Value();
 663
 664     MESSAGE ( "Look for an engine for data type :"<< sco->ComponentDataType());
 665     // if there is an associated Engine call its method for closing
 666     CORBA::String_var IOREngine;
 667     if (sco->ComponentIOR(IOREngine)) {
 668       // we have found the associated engine to write the data
 669       MESSAGE ( "We have found an engine for data type :"<< sco->ComponentDataType());
 670       CORBA::Object_var obj = _orb->string_to_object(IOREngine);
 671       if (!CORBA::is_nil(obj)) {
 672         SALOMEDS::Driver_var anEngine = SALOMEDS::Driver::_narrow(obj) ;
 673
 674         if (!anEngine->_is_nil()) {
 675           SALOMEDS::unlock();
 676           anEngine->Close(sco);
 677           SALOMEDS::lock();
 678         }
 679       }
 680     }
 681   }
 682   _impl->Close();
 683 }
 684
 685 //============================================================================
 686 /*! Function : AddPostponed
 687  *  Purpose  :
 688  */
 689  //============================================================================
 690 void SALOMEDS_Study_i::AddPostponed(const char* theIOR)
 691 {
 692   SALOMEDS::Locker lock;
 693
 694   CORBA::Object_var obj = _orb->string_to_object(theIOR);
 695   if (!CORBA::is_nil(obj)) {
 696     SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj) ;
 697     if (!CORBA::is_nil(aGeneric)) _impl->AddPostponed((char*)theIOR);
 698   }
 699 }
 700
 701 void SALOMEDS_Study_i::AddCreatedPostponed(const char* theIOR)
 702 {
 703   SALOMEDS::Locker lock;
 704
 705   CORBA::Object_var obj = _orb->string_to_object(theIOR);
 706   if (!CORBA::is_nil(obj)) {
 707     SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj) ;
 708     if (!CORBA::is_nil(aGeneric)) _impl->AddCreatedPostponed((char*)theIOR);
 709   }
 710 }
 711
 712 //============================================================================
 713 /*! Function : RemovePostponed
 714  *  Purpose  :
 715  */
 716 //============================================================================
 717 #ifndef WNT
 718 void SALOMEDS_Study_i::RemovePostponed(const CORBA::Long theUndoLimit)
 719 #else
 720 void SALOMEDS_Study_i::RemovePostponed(CORBA::Long theUndoLimit)
 721 #endif
 722 {
 723   SALOMEDS::Locker lock;
 724
 725   Handle(TColStd_HSequenceOfAsciiString) aSeq = _impl->RemovePostponed(theUndoLimit);
 726   int aLegth = aSeq->Length();
 727   for(int i = 1; i <= aLegth; i++) {
 728     TCollection_AsciiString anIOR = aSeq->Value(i);
 729     //mkr : fix for bug IPAL9408 : check the length of anIOR
 730     //                             before take value from it
 731     if ( !anIOR.IsEmpty() && anIOR.Value(1) == 'c') {
 732       CORBA::Object_var obj = _orb->string_to_object(anIOR.Split(1).ToCString());
 733       SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
 734       if (!CORBA::is_nil(aGeneric)) aGeneric->Destroy();
 735     }
 736     else if ( !anIOR.IsEmpty() && anIOR.Value(1) == 'd') {
 737       CORBA::Object_var obj = _orb->string_to_object(anIOR.Split(1).ToCString());
 738       SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
 739       if (!CORBA::is_nil(aGeneric)) aGeneric->Destroy();
 740     }
 741     else {
 742       try {
 743         CORBA::Object_var obj = _orb->string_to_object(anIOR.ToCString());
 744         SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
 745         if (!CORBA::is_nil(aGeneric)) aGeneric->Destroy();
 746       } catch (...) {}
 747     }
 748   }
 749 }
 750
 751 //============================================================================
 752 /*! Function : UndoPostponed
 753  *  Purpose  :
 754  */
 755 //============================================================================
 756 #ifndef WNT
 757 void SALOMEDS_Study_i::UndoPostponed(const CORBA::Long theWay)
 758 #else
 759 void SALOMEDS_Study_i::UndoPostponed(CORBA::Long theWay)
 760 #endif
 761 {
 762   SALOMEDS::Locker lock;
 763
 764   _impl->UndoPostponed(theWay);
 765 }
 766
 767
 768 //============================================================================
 769 /*! Function : DumpStudy
 770  *  Purpose  :
 771  */
 772 //============================================================================
 773 CORBA::Boolean SALOMEDS_Study_i::DumpStudy(const char* thePath,
 774                                            const char* theBaseName,
 775                                            CORBA::Boolean isPublished)
 776 {
 777   SALOMEDS::Locker lock;
 778
 779   TCollection_AsciiString aPath((char*)thePath), aBaseName((char*)theBaseName);
 780   SALOMEDS_DriverFactory_i* factory = new SALOMEDS_DriverFactory_i(_orb);
 781   CORBA::Boolean ret = _impl->DumpStudy(aPath, aBaseName, isPublished, factory);
 782   delete factory;
 783   return ret;
 784 }
 785
 786 //============================================================================
 787 /*! Function : GetCommonParameters
 788  *  Purpose  :
 789  */
 790 //============================================================================
 791 SALOMEDS::AttributeParameter_ptr SALOMEDS_Study_i::GetCommonParameters(const char* theID, CORBA::Long theSavePoint)
 792 {
 793   SALOMEDS::Locker lock;
 794
 795   Handle(SALOMEDSImpl_AttributeParameter) anAttr = _impl->GetCommonParameters(theID, theSavePoint);
 796   SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
 797   return SP->AttributeParameter::_this();
 798 }
 799
 800 //============================================================================
 801 /*! Function : GetCommonModuleParameters
 802  *  Purpose  :
 803  */
 804 //============================================================================
 805 SALOMEDS::AttributeParameter_ptr SALOMEDS_Study_i::GetModuleParameters(const char* theID,
 806                                                                        const char* theModuleName,
 807                                                                        CORBA::Long theSavePoint)
 808 {
 809   SALOMEDS::Locker lock;
 810
 811   Handle(SALOMEDSImpl_AttributeParameter) anAttr = _impl->GetModuleParameters(theID, theModuleName, theSavePoint);
 812   SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
 813   return SP->AttributeParameter::_this();
 814 }
 815
 816 //============================================================================
 817 /*! Function : SetStudyLock
 818  *  Purpose  :
 819  */
 820 //============================================================================
 821 void SALOMEDS_Study_i::SetStudyLock(const char* theLockerID)
 822 {
 823   SALOMEDS::Locker lock;
 824   _impl->SetStudyLock(theLockerID);
 825 }
 826
 827 //============================================================================
 828 /*! Function : IsStudyLocked
 829  *  Purpose  :
 830  */
 831 //============================================================================
 832 bool SALOMEDS_Study_i::IsStudyLocked()
 833 {
 834   SALOMEDS::Locker lock;
 835   return _impl->IsStudyLocked();
 836 }
 837
 838 //============================================================================
 839 /*! Function : UnLockStudy
 840  *  Purpose  :
 841  */
 842 //============================================================================
 843 void SALOMEDS_Study_i::UnLockStudy()
 844 {
 845   SALOMEDS::Locker lock;
 846   _impl->UnLockStudy();
 847 }
 848
 849 //============================================================================
 850 /*! Function : GetLockerID
 851  *  Purpose  :
 852  */
 853 //============================================================================
 854 char* SALOMEDS_Study_i::GetLockerID()
 855 {
 856   SALOMEDS::Locker lock;
 857   return CORBA::string_dup(_impl->GetLockerID());
 858 }
 859
 860 //============================================================================
 861 /*! Function : GetDefaultScript
 862  *  Purpose  :
 863  */
 864 //============================================================================
 865 char* SALOMEDS_Study_i::GetDefaultScript(const char* theModuleName, const char* theShift)
 866 {
 867   SALOMEDS::Locker lock;
 868
 869   string script = SALOMEDSImpl_IParameters::getDefaultScript(_impl, theModuleName, theShift);
 870   return CORBA::string_dup(script.c_str());
 871 }
 872
 873 //===========================================================================
 874 //   PRIVATE FUNCTIONS
 875 //===========================================================================
 876 CORBA::Long SALOMEDS_Study_i::GetLocalImpl(const char* theHostname, CORBA::Long thePID, CORBA::Boolean& isLocal)
 877 {
 878 #ifdef WIN32
 879   long pid = (long)_getpid();
 880 #else
 881   long pid = (long)getpid();
 882 #endif
 883   isLocal = (strcmp(theHostname, GetHostname().c_str()) == 0 && pid == thePID)?1:0;
 884   SALOMEDSImpl_Study* local_impl = _impl.operator->();
 885   return ((long)local_impl);
 886 }