1 // Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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.
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
18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
20 // File : SALOMEDS_Study.cxx
21 // Author : Sergey RUIN
26 #include "utilities.h"
28 #include "SALOMEDS_Study.hxx"
30 #include "SALOMEDS.hxx"
31 #include "SALOMEDS_SComponent.hxx"
32 #include "SALOMEDS_SObject.hxx"
33 #include "SALOMEDS_StudyBuilder.hxx"
34 #include "SALOMEDS_ChildIterator.hxx"
35 #include "SALOMEDS_SComponentIterator.hxx"
36 #include "SALOMEDS_AttributeStudyProperties.hxx"
37 #include "SALOMEDS_AttributeParameter.hxx"
38 #include "SALOMEDS_UseCaseBuilder.hxx"
40 #include "SALOMEDSImpl_SComponent.hxx"
41 #include "SALOMEDSImpl_SObject.hxx"
42 #include "SALOMEDSImpl_StudyBuilder.hxx"
43 #include "SALOMEDSImpl_ChildIterator.hxx"
44 #include "SALOMEDSImpl_SComponentIterator.hxx"
45 #include "SALOMEDSImpl_AttributeStudyProperties.hxx"
46 #include "SALOMEDSImpl_AttributeParameter.hxx"
47 #include "SALOMEDSImpl_UseCaseBuilder.hxx"
49 #include "SALOMEDS_Driver_i.hxx"
50 #include "SALOMEDS_Study_i.hxx"
52 #include <TCollection_AsciiString.hxx>
53 #include <TColStd_HSequenceOfAsciiString.hxx>
54 #include <TColStd_HSequenceOfTransient.hxx>
56 #include "Utils_ORB_INIT.hxx"
57 #include "Utils_SINGLETON.hxx"
62 #include <sys/types.h>
70 SALOMEDS_Study::SALOMEDS_Study(const Handle(SALOMEDSImpl_Study)& theStudy)
73 _local_impl = theStudy;
74 _corba_impl = SALOMEDS::Study::_nil();
78 SALOMEDS_Study::SALOMEDS_Study(SALOMEDS::Study_ptr theStudy)
81 long pid = (long)_getpid();
83 long pid = (long)getpid();
86 long addr = theStudy->GetLocalImpl(GetHostname().c_str(), pid, _isLocal);
88 _local_impl = ((SALOMEDSImpl_Study*)(addr));
89 _corba_impl = SALOMEDS::Study::_duplicate(theStudy);
93 _corba_impl = SALOMEDS::Study::_duplicate(theStudy);
99 SALOMEDS_Study::~SALOMEDS_Study()
103 std::string SALOMEDS_Study::GetPersistentReference()
107 SALOMEDS::Locker lock;
108 aRef = _local_impl->GetPersistentReference().ToCString();
110 else aRef = _corba_impl->GetPersistentReference();
114 std::string SALOMEDS_Study::GetTransientReference()
118 SALOMEDS::Locker lock;
119 aRef = _local_impl->GetTransientReference().ToCString();
121 else aRef = _corba_impl->GetTransientReference();
125 bool SALOMEDS_Study::IsEmpty()
129 SALOMEDS::Locker lock;
130 ret = _local_impl->IsEmpty();
132 else ret = _corba_impl->IsEmpty();
136 _PTR(SComponent) SALOMEDS_Study::FindComponent (const std::string& aComponentName)
138 SALOMEDSClient_SComponent* aSCO = NULL;
140 SALOMEDS::Locker lock;
142 Handle(SALOMEDSImpl_SComponent) aSCO_impl =
143 _local_impl->FindComponent((char*)aComponentName.c_str());
144 if (aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
145 aSCO = new SALOMEDS_SComponent(aSCO_impl);
148 SALOMEDS::SComponent_var aSCO_impl = _corba_impl->FindComponent((char*)aComponentName.c_str());
149 if (CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
150 aSCO = new SALOMEDS_SComponent(aSCO_impl);
152 return _PTR(SComponent)(aSCO);
155 _PTR(SComponent) SALOMEDS_Study::FindComponentID(const std::string& aComponentID)
157 SALOMEDSClient_SComponent* aSCO = NULL;
159 SALOMEDS::Locker lock;
161 Handle(SALOMEDSImpl_SComponent) aSCO_impl =
162 _local_impl->FindComponentID((char*)aComponentID.c_str());
163 if (aSCO_impl.IsNull()) return _PTR(SComponent)(aSCO);
164 aSCO = new SALOMEDS_SComponent(aSCO_impl);
167 SALOMEDS::SComponent_var aSCO_impl = _corba_impl->FindComponentID((char*)aComponentID.c_str());
168 if(CORBA::is_nil(aSCO_impl)) return _PTR(SComponent)(aSCO);
169 aSCO = new SALOMEDS_SComponent(aSCO_impl);
171 return _PTR(SComponent)(aSCO);
174 _PTR(SObject) SALOMEDS_Study::FindObject(const std::string& anObjectName)
176 SALOMEDSClient_SObject* aSO = NULL;
179 SALOMEDS::Locker lock;
181 Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObject((char*)anObjectName.c_str());
182 if (aSO_impl.IsNull()) return _PTR(SObject)(aSO);
183 Handle(SALOMEDSImpl_SComponent) aSCO_impl = Handle(SALOMEDSImpl_SComponent)::DownCast(aSO_impl);
184 if (!aSCO_impl.IsNull()) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
185 aSO = new SALOMEDS_SObject(aSO_impl);
188 SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObject((char*)anObjectName.c_str());
189 if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
190 SALOMEDS::SComponent_var aSCO_impl = SALOMEDS::SComponent::_narrow(aSO_impl);
191 if (!CORBA::is_nil(aSCO_impl)) return _PTR(SObject)(new SALOMEDS_SComponent(aSCO_impl));
192 aSO = new SALOMEDS_SObject(aSO_impl);
195 return _PTR(SObject)(aSO);
198 std::vector<_PTR(SObject)> SALOMEDS_Study::FindObjectByName(const std::string& anObjectName,
199 const std::string& aComponentName)
201 std::vector<_PTR(SObject)> aVector;
205 SALOMEDS::Locker lock;
207 Handle(TColStd_HSequenceOfTransient) aSeq =
208 _local_impl->FindObjectByName((char*)anObjectName.c_str(), (char*)aComponentName.c_str());
209 aLength = aSeq->Length();
210 for (i = 1; i<= aLength; i++)
211 aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject
212 (Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i)))));
215 SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindObjectByName((char*)anObjectName.c_str(),
216 (char*)aComponentName.c_str());
217 aLength = aSeq->length();
218 for (i = 0; i< aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
224 _PTR(SObject) SALOMEDS_Study::FindObjectID(const std::string& anObjectID)
226 SALOMEDSClient_SObject* aSO = NULL;
228 SALOMEDS::Locker lock;
230 Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObjectID((char*)anObjectID.c_str());
231 if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
232 return _PTR(SObject)(new SALOMEDS_SObject(aSO_impl));
235 SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectID((char*)anObjectID.c_str());
236 if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
237 return _PTR(SObject)(new SALOMEDS_SObject(aSO_impl));
239 return _PTR(SObject)(aSO);
242 _PTR(SObject) SALOMEDS_Study::CreateObjectID(const std::string& anObjectID)
244 SALOMEDSClient_SObject* aSO = NULL;
246 SALOMEDS::Locker lock;
247 Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->CreateObjectID((char*)anObjectID.c_str());
248 if(aSO_impl.IsNull()) return _PTR(SObject)(aSO);
249 aSO = new SALOMEDS_SObject(aSO_impl);
252 SALOMEDS::SObject_var aSO_impl = _corba_impl->CreateObjectID((char*)anObjectID.c_str());
253 if(CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
254 aSO = new SALOMEDS_SObject(aSO_impl);
256 return _PTR(SObject)(aSO);
259 _PTR(SObject) SALOMEDS_Study::FindObjectIOR(const std::string& anObjectIOR)
261 SALOMEDSClient_SObject* aSO = NULL;
263 SALOMEDS::Locker lock;
265 Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObjectIOR((char*)anObjectIOR.c_str());
266 if (aSO_impl.IsNull()) return _PTR(SObject)(aSO);
267 aSO = new SALOMEDS_SObject(aSO_impl);
270 SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectIOR((char*)anObjectIOR.c_str());
271 if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
272 aSO = new SALOMEDS_SObject(aSO_impl);
274 return _PTR(SObject)(aSO);
277 _PTR(SObject) SALOMEDS_Study::FindObjectByPath(const std::string& thePath)
279 SALOMEDSClient_SObject* aSO = NULL;
281 SALOMEDS::Locker lock;
283 Handle(SALOMEDSImpl_SObject) aSO_impl = _local_impl->FindObjectByPath((char*)thePath.c_str());
284 if (aSO_impl.IsNull()) return _PTR(SObject)(aSO);
285 aSO = new SALOMEDS_SObject(aSO_impl);
288 SALOMEDS::SObject_var aSO_impl = _corba_impl->FindObjectByPath((char*)thePath.c_str());
289 if (CORBA::is_nil(aSO_impl)) return _PTR(SObject)(aSO);
290 aSO = new SALOMEDS_SObject(aSO_impl);
292 return _PTR(SObject)(aSO);
295 std::string SALOMEDS_Study::GetObjectPath(const _PTR(SObject)& theSO)
297 if(!theSO) return "";
298 SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
301 SALOMEDS::Locker lock;
302 aPath = _local_impl->GetObjectPath(aSO->GetLocalImpl()).ToCString();
304 else aPath = _corba_impl->GetObjectPath(aSO->GetCORBAImpl());
308 void SALOMEDS_Study::SetContext(const std::string& thePath)
311 SALOMEDS::Locker lock;
312 _local_impl->SetContext((char*)thePath.c_str());
314 else _corba_impl->SetContext((char*)thePath.c_str());
317 std::string SALOMEDS_Study::GetContext()
321 SALOMEDS::Locker lock;
322 aPath = _local_impl->GetContext().ToCString();
324 else aPath = _corba_impl->GetContext();
328 std::vector<std::string> SALOMEDS_Study::GetObjectNames(const std::string& theContext)
330 std::vector<std::string> aVector;
333 SALOMEDS::Locker lock;
335 Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetObjectNames((char*)theContext.c_str());
336 aLength = aSeq->Length();
337 for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
340 SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetObjectNames((char*)theContext.c_str());
341 aLength = aSeq->length();
342 for (i = 0; i < aLength; i++) aVector.push_back(std::string((std::string)aSeq[i].in()));
347 std::vector<std::string> SALOMEDS_Study::GetDirectoryNames(const std::string& theContext)
349 std::vector<std::string> aVector;
352 SALOMEDS::Locker lock;
354 Handle(TColStd_HSequenceOfAsciiString) aSeq =
355 _local_impl->GetDirectoryNames((char*)theContext.c_str());
356 aLength = aSeq->Length();
357 for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
360 SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetDirectoryNames((char*)theContext.c_str());
361 aLength = aSeq->length();
362 for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
367 std::vector<std::string> SALOMEDS_Study::GetFileNames(const std::string& theContext)
369 std::vector<std::string> aVector;
372 SALOMEDS::Locker lock;
374 Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetFileNames((char*)theContext.c_str());
375 aLength = aSeq->Length();
376 for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
379 SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetFileNames((char*)theContext.c_str());
380 aLength = aSeq->length();
382 for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
387 std::vector<std::string> SALOMEDS_Study::GetComponentNames(const std::string& theContext)
389 std::vector<std::string> aVector;
392 SALOMEDS::Locker lock;
394 Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetComponentNames((char*)theContext.c_str());
395 aLength = aSeq->Length();
396 for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
399 SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetComponentNames((char*)theContext.c_str());
400 aLength = aSeq->length();
401 for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
406 _PTR(ChildIterator) SALOMEDS_Study::NewChildIterator(const _PTR(SObject)& theSO)
408 SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
409 SALOMEDSClient_ChildIterator* aCI = NULL;
411 SALOMEDS::Locker lock;
413 Handle(SALOMEDSImpl_ChildIterator) aCIimpl = _local_impl->NewChildIterator(aSO->GetLocalImpl());
414 aCI = new SALOMEDS_ChildIterator(aCIimpl);
417 SALOMEDS::ChildIterator_var aCIimpl = _corba_impl->NewChildIterator(aSO->GetCORBAImpl());
418 aCI = new SALOMEDS_ChildIterator(aCIimpl);
421 return _PTR(ChildIterator)(aCI);
424 _PTR(SComponentIterator) SALOMEDS_Study::NewComponentIterator()
426 SALOMEDSClient_SComponentIterator* aCI = NULL;
428 SALOMEDS::Locker lock;
430 SALOMEDSImpl_SComponentIterator aCIimpl = _local_impl->NewComponentIterator();
431 aCI = new SALOMEDS_SComponentIterator(aCIimpl);
434 SALOMEDS::SComponentIterator_var aCIimpl = _corba_impl->NewComponentIterator();
435 aCI = new SALOMEDS_SComponentIterator(aCIimpl);
438 return _PTR(SComponentIterator)(aCI);
441 _PTR(StudyBuilder) SALOMEDS_Study::NewBuilder()
443 SALOMEDSClient_StudyBuilder* aSB = NULL;
445 SALOMEDS::Locker lock;
447 Handle(SALOMEDSImpl_StudyBuilder) aSBimpl = _local_impl->NewBuilder();
448 aSB = new SALOMEDS_StudyBuilder(aSBimpl);
451 SALOMEDS::StudyBuilder_var aSBimpl = _corba_impl->NewBuilder();
452 aSB = new SALOMEDS_StudyBuilder(aSBimpl);
455 return _PTR(StudyBuilder)(aSB);
458 std::string SALOMEDS_Study::Name()
462 SALOMEDS::Locker lock;
463 aName = _local_impl->Name().ToCString();
465 else aName = _corba_impl->Name();
469 void SALOMEDS_Study::Name(const std::string& theName)
472 SALOMEDS::Locker lock;
473 _local_impl->Name((char*)theName.c_str());
475 else _corba_impl->Name((char*)theName.c_str());
478 bool SALOMEDS_Study::IsSaved()
482 SALOMEDS::Locker lock;
483 isSaved = _local_impl->IsSaved();
485 else isSaved = _corba_impl->IsSaved();
489 void SALOMEDS_Study::IsSaved(bool save)
492 SALOMEDS::Locker lock;
493 _local_impl->IsSaved(save);
495 else _corba_impl->IsSaved(save);
498 bool SALOMEDS_Study::IsModified()
502 SALOMEDS::Locker lock;
503 isModified = _local_impl->IsModified();
505 else isModified = _corba_impl->IsModified();
509 std::string SALOMEDS_Study::URL()
513 SALOMEDS::Locker lock;
514 aURL = _local_impl->URL().ToCString();
516 else aURL = _corba_impl->URL();
520 void SALOMEDS_Study::URL(const std::string& url)
523 SALOMEDS::Locker lock;
524 _local_impl->URL((char*)url.c_str());
526 else _corba_impl->URL((char*)url.c_str());
529 int SALOMEDS_Study::StudyId()
533 SALOMEDS::Locker lock;
534 anID = _local_impl->StudyId();
536 else anID = _corba_impl->StudyId();
540 void SALOMEDS_Study::StudyId(int id)
543 SALOMEDS::Locker lock;
544 _local_impl->StudyId(id);
546 else _corba_impl->StudyId(id);
549 std::vector<_PTR(SObject)> SALOMEDS_Study::FindDependances(const _PTR(SObject)& theSO)
551 std::vector<_PTR(SObject)> aVector;
552 SALOMEDS_SObject* aSO = dynamic_cast<SALOMEDS_SObject*>(theSO.get());
555 SALOMEDS::Locker lock;
557 Handle(TColStd_HSequenceOfTransient) aSeq = _local_impl->FindDependances(aSO->GetLocalImpl());
558 if (!aSeq.IsNull()) {
559 aLength = aSeq->Length();
560 for (i = 1; i <= aLength; i++)
561 aVector.push_back(_PTR(SObject)(
562 new SALOMEDS_SObject(Handle(SALOMEDSImpl_SObject)::DownCast(aSeq->Value(i)))));
566 SALOMEDS::Study::ListOfSObject_var aSeq = _corba_impl->FindDependances(aSO->GetCORBAImpl());
567 aLength = aSeq->length();
568 for (i = 0; i < aLength; i++) aVector.push_back(_PTR(SObject)(new SALOMEDS_SObject(aSeq[i])));
573 _PTR(AttributeStudyProperties) SALOMEDS_Study::GetProperties()
575 SALOMEDSClient_AttributeStudyProperties* aProp;
577 SALOMEDS::Locker lock;
578 aProp = new SALOMEDS_AttributeStudyProperties(_local_impl->GetProperties());
580 else aProp = new SALOMEDS_AttributeStudyProperties(_corba_impl->GetProperties());
581 return _PTR(AttributeStudyProperties)(aProp);
584 std::string SALOMEDS_Study::GetLastModificationDate()
588 SALOMEDS::Locker lock;
589 aDate = _local_impl->GetLastModificationDate().ToCString();
591 else aDate = _corba_impl->GetLastModificationDate();
595 std::vector<std::string> SALOMEDS_Study::GetModificationsDate()
597 std::vector<std::string> aVector;
600 SALOMEDS::Locker lock;
602 Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetModificationsDate();
603 aLength = aSeq->Length();
604 for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
607 SALOMEDS::ListOfDates_var aSeq = _corba_impl->GetModificationsDate();
608 aLength = aSeq->length();
609 for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
614 _PTR(UseCaseBuilder) SALOMEDS_Study::GetUseCaseBuilder()
616 SALOMEDSClient_UseCaseBuilder* aUB = NULL;
618 SALOMEDS::Locker lock;
620 Handle(SALOMEDSImpl_UseCaseBuilder) aUBimpl = _local_impl->GetUseCaseBuilder();
621 aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
624 SALOMEDS::UseCaseBuilder_var aUBimpl = _corba_impl->GetUseCaseBuilder();
625 aUB = new SALOMEDS_UseCaseBuilder(aUBimpl);
628 return _PTR(UseCaseBuilder)(aUB);
631 void SALOMEDS_Study::Close()
634 SALOMEDS::Locker lock;
635 _local_impl->Close();
637 else _corba_impl->Close();
640 void SALOMEDS_Study::EnableUseCaseAutoFilling(bool isEnabled)
642 if(_isLocal) _local_impl->EnableUseCaseAutoFilling(isEnabled);
643 else _corba_impl->EnableUseCaseAutoFilling(isEnabled);
646 bool SALOMEDS_Study::DumpStudy(const string& thePath, const string& theBaseName, bool isPublished)
648 //SRN: Pure CORBA DumpStudy as it does more cleaning than the local one
649 if(CORBA::is_nil(_corba_impl)) GetStudy(); //If CORBA implementation is null then retrieve it
650 bool ret = _corba_impl->DumpStudy(thePath.c_str(), theBaseName.c_str(), isPublished);
654 void SALOMEDS_Study::SetStudyLock(const string& theLockerID)
657 SALOMEDS::Locker lock;
658 _local_impl->SetStudyLock((char*)theLockerID.c_str());
660 else _corba_impl->SetStudyLock((char*)theLockerID.c_str());
663 bool SALOMEDS_Study::IsStudyLocked()
667 SALOMEDS::Locker lock;
668 isLocked = _local_impl->IsStudyLocked();
670 else isLocked = _corba_impl->IsStudyLocked();
674 void SALOMEDS_Study::UnLockStudy(const string& theLockerID)
676 if(_isLocal) _local_impl->UnLockStudy((char*)theLockerID.c_str());
677 else _corba_impl->UnLockStudy((char*)theLockerID.c_str());
680 vector<string> SALOMEDS_Study::GetLockerID()
682 std::vector<std::string> aVector;
685 SALOMEDS::Locker lock;
687 Handle(TColStd_HSequenceOfAsciiString) aSeq = _local_impl->GetLockerID();
688 aLength = aSeq->Length();
689 for (i = 1; i <= aLength; i++) aVector.push_back(aSeq->Value(i).ToCString());
692 SALOMEDS::ListOfStrings_var aSeq = _corba_impl->GetLockerID();
693 aLength = aSeq->length();
694 for (i = 0; i < aLength; i++) aVector.push_back((char*)aSeq[i].in());
699 std::string SALOMEDS_Study::ConvertObjectToIOR(CORBA::Object_ptr theObject)
701 return _orb->object_to_string(theObject);
704 CORBA::Object_ptr SALOMEDS_Study::ConvertIORToObject(const std::string& theIOR)
706 return _orb->string_to_object(theIOR.c_str());
709 void SALOMEDS_Study::init_orb()
711 ORB_INIT &init = *SINGLETON_<ORB_INIT>::Instance() ;
712 ASSERT(SINGLETON_<ORB_INIT>::IsAlreadyExisting());
713 _orb = init(0 , 0 ) ;
716 SALOMEDS::Study_ptr SALOMEDS_Study::GetStudy()
719 SALOMEDS::Locker lock;
721 if (!CORBA::is_nil(_corba_impl)) return SALOMEDS::Study::_duplicate(_corba_impl);
722 std::string anIOR = _local_impl->GetTransientReference().ToCString();
723 SALOMEDS::Study_var aStudy;
724 if (!_local_impl->IsError() && anIOR != "") {
725 aStudy = SALOMEDS::Study::_narrow(_orb->string_to_object(anIOR.c_str()));
728 SALOMEDS_Study_i *aStudy_servant = new SALOMEDS_Study_i(_local_impl, _orb);
729 aStudy = aStudy_servant->_this();
730 _local_impl->SetTransientReference(_orb->object_to_string(aStudy));
732 _corba_impl = SALOMEDS::Study::_duplicate(aStudy);
733 return aStudy._retn();
736 return SALOMEDS::Study::_duplicate(_corba_impl);
739 return SALOMEDS::Study::_nil();
743 _PTR(AttributeParameter) SALOMEDS_Study::GetCommonParameters(const string& theID, int theSavePoint)
745 SALOMEDSClient_AttributeParameter* AP = NULL;
746 if(theSavePoint >= 0) {
748 SALOMEDS::Locker lock;
749 AP = new SALOMEDS_AttributeParameter(_local_impl->GetCommonParameters(theID.c_str(), theSavePoint));
752 AP = new SALOMEDS_AttributeParameter(_corba_impl->GetCommonParameters(theID.c_str(), theSavePoint));
755 return _PTR(AttributeParameter)(AP);
758 _PTR(AttributeParameter) SALOMEDS_Study::GetModuleParameters(const string& theID,
759 const string& theModuleName, int theSavePoint)
761 SALOMEDSClient_AttributeParameter* AP = NULL;
762 if(theSavePoint > 0) {
764 SALOMEDS::Locker lock;
765 AP = new SALOMEDS_AttributeParameter(_local_impl->GetModuleParameters(theID.c_str(), theModuleName.c_str(), theSavePoint));
768 AP = new SALOMEDS_AttributeParameter(_corba_impl->GetModuleParameters(theID.c_str(), theModuleName.c_str(), theSavePoint));
771 return _PTR(AttributeParameter)(AP);