Back to index

salome-kernel  6.5.0
SALOMEDS_Study_i.cxx
Go to the documentation of this file.
00001 // Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
00002 //
00003 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
00004 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
00005 //
00006 // This library is free software; you can redistribute it and/or
00007 // modify it under the terms of the GNU Lesser General Public
00008 // License as published by the Free Software Foundation; either
00009 // version 2.1 of the License.
00010 //
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
00014 // Lesser General Public License for more details.
00015 //
00016 // You should have received a copy of the GNU Lesser General Public
00017 // License along with this library; if not, write to the Free Software
00018 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
00019 //
00020 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
00021 //
00022 
00023 //  File   : SALOMEDS_Study_i.cxx
00024 //  Author : Sergey RUIN
00025 //  Module : SALOME
00026 //
00027 #include "utilities.h"
00028 #include "SALOMEDS_Study_i.hxx"
00029 #include "SALOMEDS_StudyManager_i.hxx"
00030 #include "SALOMEDS_UseCaseIterator_i.hxx"
00031 #include "SALOMEDS_GenericAttribute_i.hxx"
00032 #include "SALOMEDS_AttributeStudyProperties_i.hxx"
00033 #include "SALOMEDS_AttributeParameter_i.hxx"
00034 #include "SALOMEDS_ChildIterator_i.hxx"
00035 #include "SALOMEDS_Driver_i.hxx"
00036 #include "SALOMEDS.hxx"
00037 
00038 #include "SALOMEDSImpl_SObject.hxx"
00039 #include "SALOMEDSImpl_SComponent.hxx"
00040 #include "SALOMEDSImpl_UseCaseBuilder.hxx"
00041 #include "SALOMEDSImpl_AttributeStudyProperties.hxx"
00042 #include "SALOMEDSImpl_AttributeParameter.hxx"
00043 #include "SALOMEDSImpl_ChildIterator.hxx"
00044 #include "SALOMEDSImpl_IParameters.hxx"
00045 #include "SALOMEDSImpl_Callback.hxx"
00046 
00047 #include "DF_Label.hxx"
00048 #include "DF_Attribute.hxx"
00049 
00050 #include "Basics_Utils.hxx"
00051 
00052 #ifdef WIN32
00053 #include <process.h>
00054 #else
00055 #include <sys/types.h>
00056 #include <unistd.h>
00057 #endif
00058 
00059 class Notifier: public SALOMEDSImpl_AbstractCallback
00060 {
00061 public:
00062 Notifier(CORBA::ORB_ptr orb)
00063 {
00064   _orb = CORBA::ORB::_duplicate(orb);
00065 }
00066 
00067 //============================================================================
00071 //============================================================================
00072 
00073   virtual bool addSO_Notification(const SALOMEDSImpl_SObject& theSObject)
00074     {
00075       std::string anID=theSObject.GetID();
00076       const char* cID=anID.c_str();
00077       for (ObsListIter it (myObservers.begin()); it != myObservers.end(); ++it)
00078         {
00079           it->first->notifyObserverID(cID,1);
00080         }
00081       return true; // NGE return always true but can be modified if needed
00082     }
00083 
00084 //============================================================================
00088 //============================================================================
00089 
00090   virtual bool removeSO_Notification(const SALOMEDSImpl_SObject& theSObject)
00091     {
00092       std::string anID=theSObject.GetID();
00093       const char* cID=anID.c_str();
00094       for (ObsListIter it (myObservers.begin()); it != myObservers.end(); ++it)
00095         {
00096           it->first->notifyObserverID(cID,2);
00097         }
00098       return true; // NGE return always true but can be modified if needed
00099     }
00100 
00101 //============================================================================
00105 //============================================================================
00106 
00107   virtual bool modifySO_Notification(const SALOMEDSImpl_SObject& theSObject, int reason)
00108     {
00109       for (ObsListIter it (myObservers.begin()); it != myObservers.end(); ++it)
00110         {
00111           if(it->second)
00112             {
00113               std::string anID=theSObject.GetID();
00114               const char* cID=anID.c_str();
00115               it->first->notifyObserverID(cID,reason);
00116             }
00117         }
00118       return true; // NGE return always true but can be modified if needed
00119     }
00120 
00121 //============================================================================
00125 //============================================================================
00126 
00127   virtual void attach(SALOMEDS::Observer_ptr theObs, bool modify)
00128     {
00129       myObservers.push_back(std::pair< SALOMEDS::Observer_var, bool > (SALOMEDS::Observer::_duplicate(theObs),modify));
00130     }
00131 
00132 private:
00133     typedef std::list< std::pair< SALOMEDS::Observer_var, bool > > ObsList;
00134     typedef ObsList::iterator ObsListIter;
00135     ObsList myObservers;
00136     CORBA::ORB_var                    _orb;
00137 };
00138 
00139 
00140 std::map<SALOMEDSImpl_Study* , SALOMEDS_Study_i*> SALOMEDS_Study_i::_mapOfStudies;
00141 
00142 //============================================================================
00146 //============================================================================
00147 SALOMEDS_Study_i::SALOMEDS_Study_i(SALOMEDSImpl_Study* theImpl,
00148                                    CORBA::ORB_ptr orb)
00149 {
00150   _orb = CORBA::ORB::_duplicate(orb);
00151   _impl = theImpl;
00152   _notifier = new Notifier(_orb);
00153   theImpl->setNotifier(_notifier);
00154 
00155   _builder = new SALOMEDS_StudyBuilder_i(_impl->NewBuilder(), _orb);  
00156 }
00157   
00158 //============================================================================
00162 //============================================================================
00163 SALOMEDS_Study_i::~SALOMEDS_Study_i()
00164 {
00165   //delete the builder servant
00166   PortableServer::POA_var poa=_builder->_default_POA();
00167   PortableServer::ObjectId_var anObjectId = poa->servant_to_id(_builder);
00168   poa->deactivate_object(anObjectId.in());
00169   _builder->_remove_ref();
00170   
00171   //delete implementation
00172   delete _impl;
00173   _mapOfStudies.erase(_impl);
00174 }  
00175 
00176 //============================================================================
00180 //============================================================================
00181 char* SALOMEDS_Study_i::GetPersistentReference()
00182 {
00183   SALOMEDS::Locker lock; 
00184   return CORBA::string_dup(_impl->GetPersistentReference().c_str());
00185 }
00186 //============================================================================
00190 //============================================================================
00191 char* SALOMEDS_Study_i::GetTransientReference()
00192 {
00193   SALOMEDS::Locker lock; 
00194   return CORBA::string_dup(_impl->GetTransientReference().c_str()); 
00195 }
00196 
00197 //============================================================================
00201 //============================================================================
00202 CORBA::Boolean SALOMEDS_Study_i::IsEmpty()
00203 {
00204   SALOMEDS::Locker lock; 
00205   return _impl->IsEmpty();
00206 }
00207 
00208 //============================================================================
00212 //============================================================================
00213 SALOMEDS::SComponent_ptr SALOMEDS_Study_i::FindComponent (const char* aComponentName)
00214 {
00215   SALOMEDS::Locker lock; 
00216   
00217   SALOMEDSImpl_SComponent aCompImpl = _impl->FindComponent(std::string(aComponentName));
00218   if(aCompImpl.IsNull()) return SALOMEDS::SComponent::_nil();
00219 
00220   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aCompImpl, _orb);
00221   return sco._retn();
00222 }
00223 
00224 //============================================================================
00228 //============================================================================
00229 SALOMEDS::SComponent_ptr SALOMEDS_Study_i::FindComponentID(const char* aComponentID)
00230 {
00231   SALOMEDS::Locker lock; 
00232   
00233   SALOMEDSImpl_SComponent aCompImpl = _impl->FindComponentID(std::string((char*)aComponentID));
00234   if(aCompImpl.IsNull()) return SALOMEDS::SComponent::_nil();
00235 
00236   SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aCompImpl, _orb);
00237   return sco._retn();
00238 }
00239 
00240 //============================================================================
00244 //============================================================================
00245 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObject(const char* anObjectName)
00246 {
00247   SALOMEDS::Locker lock; 
00248 
00249   SALOMEDSImpl_SObject aSO = _impl->FindObject(std::string((char*)anObjectName));
00250   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
00251 
00252   if(aSO.IsComponent()) {
00253     SALOMEDSImpl_SComponent aSCO = aSO;
00254     SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aSCO, _orb);
00255     return sco._retn();
00256   }
00257    
00258   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
00259  
00260  return so._retn();
00261 }
00262 
00263 //============================================================================
00267 //============================================================================
00268 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObjectID(const char* anObjectID)
00269 {
00270   SALOMEDS::Locker lock; 
00271 
00272   SALOMEDSImpl_SObject aSO = _impl->FindObjectID(std::string((char*)anObjectID));
00273   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
00274   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
00275   return so._retn();
00276 }
00277 
00278 //============================================================================
00282 //============================================================================
00283 SALOMEDS::SObject_ptr SALOMEDS_Study_i::CreateObjectID(const char* anObjectID)
00284 {
00285   SALOMEDS::Locker lock; 
00286 
00287   if(!anObjectID || strlen(anObjectID) == 0) return SALOMEDS::SObject::_nil();
00288 
00289   SALOMEDSImpl_SObject aSO = _impl->CreateObjectID((char*)anObjectID);
00290   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
00291 
00292   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
00293   return so._retn();
00294 }
00295 
00296 //============================================================================
00301 //============================================================================
00302 SALOMEDS::Study::ListOfSObject* SALOMEDS_Study_i::FindObjectByName( const char* anObjectName,
00303                                                                     const char* aComponentName )
00304 {
00305   SALOMEDS::Locker lock; 
00306 
00307   std::vector<SALOMEDSImpl_SObject> aSeq = _impl->FindObjectByName(std::string((char*)anObjectName),
00308                                                                std::string((char*)aComponentName));
00309   int aLength = aSeq.size();
00310   SALOMEDS::Study::ListOfSObject_var listSO = new SALOMEDS::Study::ListOfSObject ;
00311   listSO->length(aLength);
00312   for(int i = 0; i<aLength; i++) {
00313     SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSeq[i], _orb);
00314     listSO[i] = so ;
00315   }
00316   return listSO._retn() ;
00317 }
00318 
00319 //============================================================================
00323 //============================================================================
00324 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObjectIOR(const char* anObjectIOR)
00325 {
00326   SALOMEDS::Locker lock; 
00327 
00328   SALOMEDSImpl_SObject aSO = _impl->FindObjectIOR(std::string((char*)anObjectIOR));
00329   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
00330 
00331   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
00332   return so._retn();
00333 }
00334 
00335 //============================================================================
00339 //============================================================================
00340 SALOMEDS::SObject_ptr SALOMEDS_Study_i::FindObjectByPath(const char* thePath)
00341 {
00342   SALOMEDS::Locker lock; 
00343 
00344   SALOMEDSImpl_SObject aSO = _impl->FindObjectByPath(std::string((char*)thePath));
00345   if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
00346 
00347   SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
00348   return so._retn();
00349 }
00350 
00351 //============================================================================
00355 //============================================================================
00356 char* SALOMEDS_Study_i::GetObjectPath(CORBA::Object_ptr theObject)
00357 {
00358   SALOMEDS::Locker lock; 
00359 
00360   std::string aPath("");
00361   if(CORBA::is_nil(theObject)) return CORBA::string_dup(aPath.c_str());
00362   SALOMEDSImpl_SObject aSO;
00363   SALOMEDS::SObject_var aSObj = SALOMEDS::SObject::_narrow(theObject);
00364 
00365   if(!CORBA::is_nil(aSObj)) {
00366     aSO = _impl->FindObjectID(aSObj->GetID());
00367   }
00368   else {
00369     aSO  = _impl->FindObjectIOR(_orb->object_to_string(theObject));
00370   }
00371    
00372   if(aSO.IsNull()) return CORBA::string_dup(aPath.c_str());
00373   
00374   aPath = _impl->GetObjectPath(aSO);
00375   return  CORBA::string_dup(aPath.c_str());
00376 }
00377 
00378 
00379 //============================================================================
00383 //============================================================================
00384 void SALOMEDS_Study_i::SetContext(const char* thePath) 
00385 {
00386   SALOMEDS::Locker lock; 
00387 
00388   _impl->SetContext(std::string((char*)thePath));
00389   if(_impl->IsError() && _impl->GetErrorCode() == "InvalidContext") 
00390     throw SALOMEDS::Study::StudyInvalidContext();  
00391 }
00392 
00393 //============================================================================
00397 //============================================================================
00398 char* SALOMEDS_Study_i::GetContext() 
00399 {
00400   SALOMEDS::Locker lock; 
00401   
00402   if(!_impl->HasCurrentContext()) throw SALOMEDS::Study::StudyInvalidContext();   
00403   return CORBA::string_dup(_impl->GetContext().c_str());
00404 }
00405 
00406 //============================================================================
00410 //============================================================================
00411 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetObjectNames(const char* theContext) 
00412 {
00413   SALOMEDS::Locker lock; 
00414 
00415   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
00416 
00417   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
00418     throw SALOMEDS::Study::StudyInvalidContext();
00419 
00420   std::vector<std::string> aSeq = _impl->GetObjectNames(std::string((char*)theContext));
00421   if (_impl->GetErrorCode() == "InvalidContext")
00422     throw SALOMEDS::Study::StudyInvalidContext();
00423 
00424   int aLength = aSeq.size();
00425   aResult->length(aLength);
00426   for (int anIndex = 0; anIndex < aLength; anIndex++) {
00427     aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
00428   }
00429 
00430   return aResult._retn();
00431 }
00432 
00433 //============================================================================
00437 //============================================================================
00438 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetDirectoryNames(const char* theContext) 
00439 {
00440   SALOMEDS::Locker lock; 
00441 
00442   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
00443 
00444   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
00445     throw SALOMEDS::Study::StudyInvalidContext();
00446 
00447   std::vector<std::string> aSeq = _impl->GetDirectoryNames(std::string((char*)theContext));
00448   if (_impl->GetErrorCode() == "InvalidContext")
00449     throw SALOMEDS::Study::StudyInvalidContext();
00450 
00451   int aLength = aSeq.size();
00452   aResult->length(aLength);
00453   for (int anIndex = 0; anIndex < aLength; anIndex++) {
00454     aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
00455   }
00456 
00457   return aResult._retn();
00458 }
00459 
00460 //============================================================================
00464 //============================================================================
00465 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetFileNames(const char* theContext) 
00466 {
00467   SALOMEDS::Locker lock; 
00468 
00469   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
00470 
00471   if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
00472     throw SALOMEDS::Study::StudyInvalidContext();
00473 
00474   std::vector<std::string> aSeq = _impl->GetFileNames(std::string((char*)theContext));
00475   if (_impl->GetErrorCode() == "InvalidContext")
00476     throw SALOMEDS::Study::StudyInvalidContext();
00477 
00478   int aLength = aSeq.size();
00479   aResult->length(aLength);
00480   for (int anIndex = 0; anIndex < aLength; anIndex++) {
00481     aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
00482   }
00483 
00484   return aResult._retn();
00485 }
00486 
00487 //============================================================================
00492 //============================================================================
00493 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetComponentNames(const char* theContext) 
00494 {
00495   SALOMEDS::Locker lock; 
00496 
00497   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
00498 
00499   std::vector<std::string> aSeq = _impl->GetComponentNames(std::string((char*)theContext));
00500 
00501   int aLength = aSeq.size();
00502   aResult->length(aLength);
00503   for(int anIndex = 0; anIndex < aLength; anIndex++) {
00504     aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
00505   }
00506 
00507   return aResult._retn();
00508 }
00509 
00510 //============================================================================
00514 //============================================================================
00515 SALOMEDS::ChildIterator_ptr SALOMEDS_Study_i::NewChildIterator(SALOMEDS::SObject_ptr theSO)
00516 {
00517   SALOMEDS::Locker lock; 
00518 
00519   CORBA::String_var anID=theSO->GetID();
00520   SALOMEDSImpl_SObject aSO = _impl->GetSObject(anID.in());
00521   SALOMEDSImpl_ChildIterator anItr(aSO);
00522 
00523   //Create iterator
00524   SALOMEDS_ChildIterator_i* it_servant = new SALOMEDS_ChildIterator_i(anItr, _orb);
00525 
00526   return it_servant->_this();
00527 }
00528 
00529 
00530 //============================================================================
00534 //============================================================================
00535 SALOMEDS::SComponentIterator_ptr SALOMEDS_Study_i::NewComponentIterator()
00536 {
00537   SALOMEDS::Locker lock; 
00538   SALOMEDS_SComponentIterator_i* _it = new SALOMEDS_SComponentIterator_i(_impl->NewComponentIterator(), _orb);
00539   _it->Init();
00540   return _it->_this();
00541 }
00542 
00543 
00544 //============================================================================
00548 //============================================================================
00549 SALOMEDS::StudyBuilder_ptr SALOMEDS_Study_i::NewBuilder()
00550 {
00551   SALOMEDS::Locker lock; 
00552   return _builder->_this();
00553 }
00554  
00555 //============================================================================
00559 //============================================================================
00560 char* SALOMEDS_Study_i::Name()
00561 {
00562   SALOMEDS::Locker lock; 
00563   return CORBA::string_dup(_impl->Name().c_str());
00564 }
00565 
00566 //============================================================================
00570 //============================================================================
00571 void SALOMEDS_Study_i::Name(const char* name)
00572 {
00573   SALOMEDS::Locker lock;  
00574   _impl->Name(std::string((char*)name));
00575 }
00576 
00577 //============================================================================
00581 //============================================================================
00582 CORBA::Boolean  SALOMEDS_Study_i::IsSaved()
00583 {
00584   SALOMEDS::Locker lock; 
00585   return _impl->IsSaved();
00586 }
00587 
00588 //============================================================================
00592 //============================================================================
00593 void SALOMEDS_Study_i::IsSaved(CORBA::Boolean save)
00594 {
00595   SALOMEDS::Locker lock; 
00596   _impl->IsSaved(save);
00597 }
00598 
00599 //============================================================================
00603 //============================================================================
00604 CORBA::Boolean  SALOMEDS_Study_i::IsModified()
00605 {
00606   SALOMEDS::Locker lock; 
00607   return _impl->IsModified();
00608 }
00609 
00610 //============================================================================
00614 //============================================================================
00615 void  SALOMEDS_Study_i::Modified()
00616 {
00617   SALOMEDS::Locker lock; 
00618   return _impl->Modify();
00619 }
00620 
00621 
00622 //============================================================================
00626 //============================================================================
00627 char* SALOMEDS_Study_i::URL()
00628 {
00629   SALOMEDS::Locker lock; 
00630   return CORBA::string_dup(_impl->URL().c_str());
00631 }
00632 
00633 //============================================================================
00637 //============================================================================
00638 void SALOMEDS_Study_i::URL(const char* url)
00639 {
00640   SALOMEDS::Locker lock; 
00641   _impl->URL(std::string((char*)url));
00642 }
00643 
00644 
00645 CORBA::Short SALOMEDS_Study_i::StudyId()
00646 {
00647   SALOMEDS::Locker lock; 
00648   return _impl->StudyId();
00649 }
00650 
00651 void SALOMEDS_Study_i::StudyId(CORBA::Short id)
00652 { 
00653   SALOMEDS::Locker lock; 
00654   _impl->StudyId(id);
00655 }
00656 
00657 void SALOMEDS_Study_i::UpdateIORLabelMap(const char* anIOR,const char* anEntry) 
00658 {
00659   SALOMEDS::Locker lock; 
00660   _impl->UpdateIORLabelMap(std::string((char*)anIOR), std::string((char*)anEntry));
00661 }
00662 
00663 SALOMEDS::Study_ptr SALOMEDS_Study_i::GetStudy(const DF_Label& theLabel, CORBA::ORB_ptr orb) 
00664 {
00665   SALOMEDS::Locker lock; 
00666 
00667   SALOMEDSImpl_AttributeIOR* Att = NULL;
00668   if ((Att=(SALOMEDSImpl_AttributeIOR*)theLabel.Root().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID()))){
00669     char* IOR = CORBA::string_dup(Att->Value().c_str());
00670     CORBA::Object_var obj = orb->string_to_object(IOR);
00671     SALOMEDS::Study_ptr aStudy = SALOMEDS::Study::_narrow(obj) ;
00672     ASSERT(!CORBA::is_nil(aStudy));
00673     return SALOMEDS::Study::_duplicate(aStudy);
00674   } else {
00675     MESSAGE("GetStudy: Problem to get study");
00676   }
00677   return SALOMEDS::Study::_nil();
00678 }
00679 
00680 SALOMEDS_Study_i* SALOMEDS_Study_i::GetStudyServant(SALOMEDSImpl_Study* aStudyImpl, CORBA::ORB_ptr orb)
00681 {
00682   if (_mapOfStudies.find(aStudyImpl) != _mapOfStudies.end()) 
00683     return _mapOfStudies[aStudyImpl];
00684   else
00685     {
00686       SALOMEDS_Study_i *Study_servant = new SALOMEDS_Study_i(aStudyImpl, orb);
00687       _mapOfStudies[aStudyImpl]=Study_servant;
00688       return Study_servant;
00689     }
00690 }
00691 
00692 void SALOMEDS_Study_i::IORUpdated(SALOMEDSImpl_AttributeIOR* theAttribute) 
00693 {
00694   SALOMEDS::Locker lock; 
00695   SALOMEDSImpl_Study::IORUpdated(theAttribute);
00696 }
00697 
00698 SALOMEDS::Study::ListOfSObject* SALOMEDS_Study_i::FindDependances(SALOMEDS::SObject_ptr anObject) 
00699 {
00700   SALOMEDS::Locker lock; 
00701 
00702   SALOMEDS::GenericAttribute_ptr aTarget;
00703   if (anObject->FindAttribute(aTarget,"AttributeTarget")) {
00704     return SALOMEDS::AttributeTarget::_narrow(aTarget)->Get();
00705   }
00706   SALOMEDS::Study::ListOfSObject* aList = new SALOMEDS::Study::ListOfSObject;
00707   aList->length(0);
00708   return aList;
00709 }
00710 
00711 
00712 SALOMEDS::AttributeStudyProperties_ptr SALOMEDS_Study_i::GetProperties() 
00713 {
00714   SALOMEDS::Locker lock; 
00715   
00716   SALOMEDSImpl_AttributeStudyProperties* anAttr = _impl->GetProperties();
00717   SALOMEDS_AttributeStudyProperties_i* SP = new SALOMEDS_AttributeStudyProperties_i(anAttr, _orb);
00718   return SP->AttributeStudyProperties::_this();
00719 }
00720 
00721 char* SALOMEDS_Study_i::GetLastModificationDate() 
00722 {
00723   SALOMEDS::Locker lock; 
00724   return CORBA::string_dup(_impl->GetLastModificationDate().c_str());
00725 }
00726 
00727 SALOMEDS::ListOfDates* SALOMEDS_Study_i::GetModificationsDate() 
00728 {
00729   SALOMEDS::Locker lock; 
00730   
00731   std::vector<std::string> aSeq = _impl->GetModificationsDate();
00732   int aLength = aSeq.size();
00733   SALOMEDS::ListOfDates_var aDates = new SALOMEDS::ListOfDates;
00734   aDates->length(aLength);
00735 
00736   for(int anIndex = 0; anIndex < aLength; anIndex++) {
00737     aDates[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
00738   }
00739   return aDates._retn();
00740 }
00741 
00742 
00743 
00744 //============================================================================
00748 //============================================================================
00749 SALOMEDS::UseCaseBuilder_ptr SALOMEDS_Study_i::GetUseCaseBuilder() 
00750 {
00751   SALOMEDS::Locker lock; 
00752   SALOMEDS_UseCaseBuilder_i* UCBuilder = new SALOMEDS_UseCaseBuilder_i(_impl->GetUseCaseBuilder(), _orb);
00753   return UCBuilder->_this();
00754 }
00755 
00756 
00757 //============================================================================
00761 //============================================================================
00762 void SALOMEDS_Study_i::Close()
00763 {
00764   SALOMEDS::Locker lock; 
00765 
00766   RemovePostponed(-1);
00767 
00768   SALOMEDS::SComponentIterator_var itcomponent = NewComponentIterator();
00769   for (; itcomponent->More(); itcomponent->Next()) {
00770     SALOMEDS::SComponent_var sco = itcomponent->Value();
00771     CORBA::String_var compodatatype=sco->ComponentDataType();
00772     MESSAGE ( "Look for an engine for data type :"<< compodatatype);
00773     // if there is an associated Engine call its method for closing
00774     CORBA::String_var IOREngine;
00775     if (sco->ComponentIOR(IOREngine)) {
00776       // we have found the associated engine to write the data 
00777       MESSAGE ( "We have found an engine for data type :"<< compodatatype);
00778       //_narrow can throw a corba exception
00779       try
00780         {
00781           CORBA::Object_var obj = _orb->string_to_object(IOREngine);
00782           if (!CORBA::is_nil(obj)) 
00783             {
00784               SALOMEDS::Driver_var anEngine = SALOMEDS::Driver::_narrow(obj) ;
00785               if (!anEngine->_is_nil()) 
00786                 { 
00787                   SALOMEDS::unlock();
00788                   anEngine->Close(sco);
00789                   SALOMEDS::lock();
00790                 }
00791             }
00792         } 
00793       catch (CORBA::Exception&) 
00794         {/*pass*/ }
00795     }
00796     sco->UnRegister();
00797   }
00798 
00799   //Does not need any more this iterator
00800   itcomponent->UnRegister();
00801 
00802 
00803   _impl->Close();
00804 }
00805 
00806 //============================================================================
00810  //============================================================================
00811 void SALOMEDS_Study_i::AddPostponed(const char* theIOR) 
00812 {
00813   SALOMEDS::Locker lock; 
00814   //Not implemented
00815 }
00816 
00817 void SALOMEDS_Study_i::AddCreatedPostponed(const char* theIOR) 
00818 {
00819   SALOMEDS::Locker lock; 
00820   //Not implemented
00821 }
00822 
00823 //============================================================================
00827 //============================================================================
00828 #ifndef WIN32
00829 void SALOMEDS_Study_i::RemovePostponed(const CORBA::Long /*theUndoLimit*/) 
00830 #else
00831 void SALOMEDS_Study_i::RemovePostponed(CORBA::Long /*theUndoLimit*/) 
00832 #endif
00833 {  
00834   SALOMEDS::Locker lock; 
00835 
00836   std::vector<std::string> anIORs = _impl->GetIORs();
00837   int i, aSize = (int)anIORs.size();
00838 
00839   for(i = 0; i < aSize; i++) {
00840     try {
00841       CORBA::Object_var obj = _orb->string_to_object(anIORs[i].c_str());
00842       SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
00843          //rnv: To avoid double deletion of the Salome Generic Objects:
00844          //rnv: 1. First decrement of the reference count in the SALOMEDSImpl_AttributeIOR::~SALOMEDSImpl_AttributeIOR();
00845          //rnv: 2. Second decrement of the reference count in the next string : aGeneric->UnRegister();
00846       //if (!CORBA::is_nil(aGeneric)) aGeneric->UnRegister();
00847     } catch (...) {}
00848   }
00849 
00850   //Not implemented
00851 }
00852 
00853 //============================================================================
00857 //============================================================================
00858 #ifndef WIN32
00859 void SALOMEDS_Study_i::UndoPostponed(const CORBA::Long theWay) 
00860 #else
00861 void SALOMEDS_Study_i::UndoPostponed(CORBA::Long theWay) 
00862 #endif
00863 {
00864   SALOMEDS::Locker lock; 
00865   //Not implemented
00866 }
00867 
00868 
00869 //============================================================================
00873 //============================================================================
00874 CORBA::Boolean SALOMEDS_Study_i::DumpStudy(const char* thePath, 
00875                                            const char* theBaseName, 
00876                                            CORBA::Boolean isPublished,
00877                                            CORBA::Boolean isMultiFile)
00878 {
00879   SALOMEDS::Locker lock; 
00880 
00881   std::string aPath((char*)thePath), aBaseName((char*)theBaseName);
00882   SALOMEDS_DriverFactory_i* factory = new SALOMEDS_DriverFactory_i(_orb);
00883   CORBA::Boolean ret = _impl->DumpStudy(aPath, aBaseName, isPublished, isMultiFile, factory);
00884   delete factory;
00885   return ret;
00886 }
00887 
00888 //============================================================================
00892 //============================================================================
00893 SALOMEDS::AttributeParameter_ptr SALOMEDS_Study_i::GetCommonParameters(const char* theID, CORBA::Long theSavePoint)
00894 {
00895   SALOMEDS::Locker lock; 
00896   
00897   SALOMEDSImpl_AttributeParameter* anAttr = _impl->GetCommonParameters(theID, theSavePoint);
00898   SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
00899   return SP->AttributeParameter::_this();
00900 }
00901  
00902 //============================================================================
00906 //============================================================================
00907 SALOMEDS::AttributeParameter_ptr SALOMEDS_Study_i::GetModuleParameters(const char* theID, 
00908                                                                        const char* theModuleName, 
00909                                                                        CORBA::Long theSavePoint)
00910 {
00911   SALOMEDS::Locker lock; 
00912   
00913   SALOMEDSImpl_AttributeParameter* anAttr = _impl->GetModuleParameters(theID, theModuleName, theSavePoint);
00914   SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
00915   return SP->AttributeParameter::_this();
00916 }
00917 
00918 //============================================================================
00922 //============================================================================
00923 void SALOMEDS_Study_i::SetStudyLock(const char* theLockerID)
00924 {
00925   SALOMEDS::Locker lock; 
00926   _impl->SetStudyLock(theLockerID);
00927 }
00928 
00929 //============================================================================
00933 //============================================================================
00934 bool SALOMEDS_Study_i::IsStudyLocked()
00935 {
00936   SALOMEDS::Locker lock; 
00937   return _impl->IsStudyLocked();
00938 }
00939 
00940 //============================================================================
00944 //============================================================================
00945 void SALOMEDS_Study_i::UnLockStudy(const char* theLockerID)
00946 {
00947   SALOMEDS::Locker lock; 
00948   _impl->UnLockStudy(theLockerID);
00949 }
00950 
00951 //============================================================================
00955 //============================================================================
00956 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetLockerID()
00957 {
00958   SALOMEDS::Locker lock; 
00959 
00960   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
00961 
00962   std::vector<std::string> aSeq = _impl->GetLockerID();
00963 
00964   int aLength = aSeq.size();
00965   aResult->length(aLength);
00966   for(int anIndex = 0; anIndex < aLength; anIndex++) {
00967     aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
00968   }
00969   return aResult._retn();
00970 }
00971 //============================================================================
00975 //============================================================================
00976 void SALOMEDS_Study_i::SetReal(const char* theVarName, CORBA::Double theValue)
00977 {
00978   _impl->SetVariable(std::string(theVarName), 
00979                      theValue,
00980                      SALOMEDSImpl_GenericVariable::REAL_VAR);
00981 }
00982 
00983 //============================================================================
00987 //============================================================================
00988 void SALOMEDS_Study_i::SetInteger(const char* theVarName, CORBA::Long theValue)
00989 {
00990   _impl->SetVariable(std::string(theVarName), 
00991                      theValue,
00992                      SALOMEDSImpl_GenericVariable::INTEGER_VAR);
00993 }
00994 
00995 //============================================================================
00999 //============================================================================
01000 void SALOMEDS_Study_i::SetBoolean(const char* theVarName, CORBA::Boolean theValue)
01001 {
01002   _impl->SetVariable(std::string(theVarName), 
01003                      theValue,
01004                      SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
01005 }
01006 
01007 //============================================================================
01011 //============================================================================
01012 void SALOMEDS_Study_i::SetString(const char* theVarName, const char* theValue)
01013 {
01014   _impl->SetStringVariable(std::string(theVarName), 
01015                            theValue,
01016                            SALOMEDSImpl_GenericVariable::STRING_VAR);
01017 }
01018 
01019 //============================================================================
01023 //============================================================================
01024 void SALOMEDS_Study_i::SetStringAsDouble(const char* theVarName, CORBA::Double theValue)
01025 {
01026   _impl->SetStringVariableAsDouble(std::string(theVarName), 
01027                                    theValue,
01028                                    SALOMEDSImpl_GenericVariable::STRING_VAR);
01029 }
01030 
01031 //============================================================================
01035 //============================================================================
01036 CORBA::Double SALOMEDS_Study_i::GetReal(const char* theVarName)
01037 {
01038   return _impl->GetVariableValue(std::string(theVarName));
01039 }
01040 
01041 //============================================================================
01045 //============================================================================
01046 CORBA::Long SALOMEDS_Study_i::GetInteger(const char* theVarName)
01047 {
01048   return (int)_impl->GetVariableValue(std::string(theVarName));
01049 }
01050 
01051 //============================================================================
01055 //============================================================================
01056 CORBA::Boolean SALOMEDS_Study_i::GetBoolean(const char* theVarName)
01057 {
01058   return (bool)_impl->GetVariableValue(std::string(theVarName));
01059 }
01060 
01061 //============================================================================
01065 //============================================================================
01066 char* SALOMEDS_Study_i::GetString(const char* theVarName)
01067 {
01068   return CORBA::string_dup(_impl->GetStringVariableValue(std::string(theVarName)).c_str());
01069 }
01070 
01071 //============================================================================
01075 //============================================================================
01076 CORBA::Boolean SALOMEDS_Study_i::IsReal(const char* theVarName)
01077 {
01078   return _impl->IsTypeOf(std::string(theVarName),
01079                          SALOMEDSImpl_GenericVariable::REAL_VAR);
01080 }
01081 
01082 //============================================================================
01086 //============================================================================
01087 CORBA::Boolean SALOMEDS_Study_i::IsInteger(const char* theVarName)
01088 {
01089   return _impl->IsTypeOf(std::string(theVarName),
01090                          SALOMEDSImpl_GenericVariable::INTEGER_VAR);
01091 }
01092 
01093 //============================================================================
01097 //============================================================================
01098 CORBA::Boolean SALOMEDS_Study_i::IsBoolean(const char* theVarName)
01099 {
01100   return _impl->IsTypeOf(std::string(theVarName),
01101                          SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
01102 }
01103 
01104 //============================================================================
01108 //============================================================================
01109 CORBA::Boolean SALOMEDS_Study_i::IsString(const char* theVarName)
01110 {
01111   return _impl->IsTypeOf(std::string(theVarName),
01112                          SALOMEDSImpl_GenericVariable::STRING_VAR);
01113 }
01114 
01115 //============================================================================
01119 //============================================================================
01120 CORBA::Boolean SALOMEDS_Study_i::IsVariable(const char* theVarName)
01121 {
01122   return _impl->IsVariable(std::string(theVarName));
01123 }
01124 
01125 //============================================================================
01129 //============================================================================
01130 SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetVariableNames()
01131 {
01132   std::vector<std::string> aVarNames = _impl->GetVariableNames();
01133   SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
01134   
01135   int aLen = aVarNames.size();
01136   aResult->length(aLen);
01137   
01138   for (int anInd = 0; anInd < aLen; anInd++)
01139     aResult[anInd] = CORBA::string_dup(aVarNames[anInd].c_str());
01140   
01141   return aResult._retn();
01142 }
01143 
01144 //============================================================================
01148 //============================================================================
01149 CORBA::Boolean SALOMEDS_Study_i::RemoveVariable(const char* theVarName)
01150 {
01151   return _impl->RemoveVariable(std::string(theVarName));
01152 }
01153 
01154 //============================================================================
01158 //============================================================================
01159 CORBA::Boolean SALOMEDS_Study_i::RenameVariable(const char* theVarName, const char* theNewVarName)
01160 {
01161   return _impl->RenameVariable(std::string(theVarName), std::string(theNewVarName));
01162 }
01163 
01164 //============================================================================
01168 //============================================================================
01169 CORBA::Boolean SALOMEDS_Study_i::IsVariableUsed(const char* theVarName)
01170 {
01171   return _impl->IsVariableUsed(std::string(theVarName));
01172 }
01173 
01174 
01175 //============================================================================
01179 //============================================================================
01180 SALOMEDS::ListOfListOfStrings* SALOMEDS_Study_i::ParseVariables(const char* theVarName)
01181 {
01182   std::vector< std::vector<std::string> > aSections = _impl->ParseVariables(std::string(theVarName));
01183 
01184   SALOMEDS::ListOfListOfStrings_var aResult = new SALOMEDS::ListOfListOfStrings;
01185 
01186   int aSectionsLen = aSections.size();
01187   aResult->length(aSectionsLen);
01188 
01189   for (int aSectionInd = 0; aSectionInd < aSectionsLen; aSectionInd++) {
01190     std::vector<std::string> aVarNames = aSections[aSectionInd];
01191 
01192     SALOMEDS::ListOfStrings_var aList = new SALOMEDS::ListOfStrings;
01193 
01194     int aLen = aVarNames.size();
01195     aList->length(aLen);
01196 
01197     for (int anInd = 0; anInd < aLen; anInd++)
01198       aList[anInd] = CORBA::string_dup(aVarNames[anInd].c_str());
01199 
01200     aResult[aSectionInd] = aList;
01201   }
01202 
01203   return aResult._retn();
01204 }
01205 
01206 //============================================================================
01210 //============================================================================
01211 char* SALOMEDS_Study_i::GetDefaultScript(const char* theModuleName, const char* theShift)
01212 {
01213   SALOMEDS::Locker lock; 
01214 
01215   std::string script = SALOMEDSImpl_IParameters::getDefaultScript(_impl, theModuleName, theShift);
01216   return CORBA::string_dup(script.c_str());
01217 }
01218 
01219 //============================================================================
01223 //============================================================================
01224 void SALOMEDS_Study_i::EnableUseCaseAutoFilling(CORBA::Boolean isEnabled) 
01225 { 
01226   _impl->EnableUseCaseAutoFilling(isEnabled); 
01227   SALOMEDSImpl_StudyBuilder* builder = _builder->GetImpl();
01228   if(builder) {
01229     if(isEnabled) {
01230       builder->SetOnAddSObject(_impl->GetCallback());
01231       builder->SetOnRemoveSObject(_impl->GetCallback());
01232     }
01233     else {
01234       builder->SetOnAddSObject(NULL);
01235       builder->SetOnRemoveSObject(NULL);
01236     }
01237   }
01238 }
01239 
01240 //============================================================================
01244 //============================================================================
01245 void SALOMEDS_Study_i::attach(SALOMEDS::Observer_ptr theObs,CORBA::Boolean modify)
01246 {
01247   if(_notifier)
01248     _notifier->attach(theObs,modify);
01249 }
01250 
01251 //===========================================================================
01252 //   PRIVATE FUNCTIONS
01253 //===========================================================================
01254 CORBA::LongLong SALOMEDS_Study_i::GetLocalImpl(const char* theHostname, CORBA::Long thePID, CORBA::Boolean& isLocal)
01255 {
01256 #ifdef WIN32
01257   long pid = (long)_getpid();
01258 #else
01259   long pid = (long)getpid();
01260 #endif  
01261   isLocal = (strcmp(theHostname, Kernel_Utils::GetHostname().c_str()) == 0 && pid == thePID)?1:0;
01262   return reinterpret_cast<CORBA::LongLong>(_impl);
01263 }