-// Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
// Module : SALOME
//
#include "utilities.h"
+#include <sstream>
#include "SALOMEDS_Study_i.hxx"
#include "SALOMEDS_StudyManager_i.hxx"
#include "SALOMEDS_UseCaseIterator_i.hxx"
#include "DF_Attribute.hxx"
#include "Basics_Utils.hxx"
+#include "SALOME_KernelServices.hxx"
#ifdef WIN32
#include <process.h>
_builder = new SALOMEDS_StudyBuilder_i(_impl->NewBuilder(), _orb);
_notifier = new SALOMEDS::Notifier(_orb);
_genObjRegister = new SALOMEDS::GenObjRegister(_orb);
+ _closed = false;
theImpl->setNotifier(_notifier);
theImpl->setGenObjRegister( _genObjRegister );
+
+ // Notify GUI that study was created
+ SALOME_NamingService *aNamingService = KERNEL::getNamingService();
+ CORBA::Object_var obj = aNamingService->Resolve("/Kernel/Session");
+ SALOME::Session_var aSession = SALOME::Session::_narrow(obj);
+ if ( !CORBA::is_nil(aSession) ) {
+ std::stringstream ss;
+ ss << "studyCreated:" << theImpl->StudyId();
+ std::string str = ss.str();
+ SALOMEDS::unlock();
+ aSession->emitMessageOneWay(str.c_str());
+ SALOMEDS::lock();
+ }
}
//============================================================================
char* SALOMEDS_Study_i::GetPersistentReference()
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
return CORBA::string_dup(_impl->GetPersistentReference().c_str());
}
//============================================================================
char* SALOMEDS_Study_i::GetTransientReference()
{
SALOMEDS::Locker lock;
- return CORBA::string_dup(_impl->GetTransientReference().c_str());
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+ return CORBA::string_dup(_impl->GetTransientReference().c_str());
}
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsEmpty()
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
return _impl->IsEmpty();
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::SComponent_var sco;
+
SALOMEDSImpl_SComponent aCompImpl = _impl->FindComponent(std::string(aComponentName));
- if(aCompImpl.IsNull()) return SALOMEDS::SComponent::_nil();
+ if (!aCompImpl.IsNull())
+ sco = SALOMEDS_SComponent_i::New(aCompImpl, _orb);
- SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aCompImpl, _orb);
return sco._retn();
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::SComponent_var sco;
+
SALOMEDSImpl_SComponent aCompImpl = _impl->FindComponentID(std::string((char*)aComponentID));
- if(aCompImpl.IsNull()) return SALOMEDS::SComponent::_nil();
+ if (!aCompImpl.IsNull())
+ sco = SALOMEDS_SComponent_i::New(aCompImpl, _orb);
- SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aCompImpl, _orb);
return sco._retn();
}
{
SALOMEDS::Locker lock;
- SALOMEDSImpl_SObject aSO = _impl->FindObject(std::string((char*)anObjectName));
- if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::SObject_var so;
- if(aSO.IsComponent()) {
- SALOMEDSImpl_SComponent aSCO = aSO;
- SALOMEDS::SComponent_var sco = SALOMEDS_SComponent_i::New (aSCO, _orb);
- return sco._retn();
+ SALOMEDSImpl_SObject aSO = _impl->FindObject(std::string((char*)anObjectName));
+ if (!aSO.IsNull()) {
+ if (aSO.IsComponent()) {
+ SALOMEDSImpl_SComponent aSCO = aSO;
+ so = SALOMEDS_SComponent_i::New(aSCO, _orb);
+ }
+ else {
+ so = SALOMEDS_SObject_i::New(aSO, _orb);
+ }
}
-
- SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
-
- return so._retn();
+
+ return so._retn();
}
//============================================================================
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::SObject_var so;
+
SALOMEDSImpl_SObject aSO = _impl->FindObjectID(std::string((char*)anObjectID));
- if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
- SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
+ if (!aSO.IsNull())
+ so = SALOMEDS_SObject_i::New(aSO, _orb);
+
return so._retn();
}
{
SALOMEDS::Locker lock;
- if(!anObjectID || strlen(anObjectID) == 0) return SALOMEDS::SObject::_nil();
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
- SALOMEDSImpl_SObject aSO = _impl->CreateObjectID((char*)anObjectID);
- if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
+ SALOMEDS::SObject_var so;
+
+ if (anObjectID && strlen(anObjectID) > 0) {
+ SALOMEDSImpl_SObject aSO = _impl->CreateObjectID((char*)anObjectID);
+ if (!aSO.IsNull())
+ so = SALOMEDS_SObject_i::New(aSO, _orb);
+ }
- SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
return so._retn();
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
std::vector<SALOMEDSImpl_SObject> aSeq = _impl->FindObjectByName(std::string((char*)anObjectName),
- std::string((char*)aComponentName));
+ std::string((char*)aComponentName));
+
+ SALOMEDS::Study::ListOfSObject_var listSO = new SALOMEDS::Study::ListOfSObject;
int aLength = aSeq.size();
- SALOMEDS::Study::ListOfSObject_var listSO = new SALOMEDS::Study::ListOfSObject ;
listSO->length(aLength);
- for(int i = 0; i<aLength; i++) {
- SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSeq[i], _orb);
- listSO[i] = so ;
+ for (int i = 0; i < aLength; i++) {
+ SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New(aSeq[i], _orb);
+ listSO[i] = so;
}
- return listSO._retn() ;
+
+ return listSO._retn();
}
//============================================================================
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::SObject_var so;
+
SALOMEDSImpl_SObject aSO = _impl->FindObjectIOR(std::string((char*)anObjectIOR));
- if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
+ if (!aSO.IsNull())
+ so = SALOMEDS_SObject_i::New(aSO, _orb);
- SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
return so._retn();
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::SObject_var so;
+
SALOMEDSImpl_SObject aSO = _impl->FindObjectByPath(std::string((char*)thePath));
- if(aSO.IsNull()) return SALOMEDS::SObject::_nil();
+ if (!aSO.IsNull())
+ so = SALOMEDS_SObject_i::New (aSO, _orb);
- SALOMEDS::SObject_var so = SALOMEDS_SObject_i::New (aSO, _orb);
return so._retn();
}
{
SALOMEDS::Locker lock;
- std::string aPath("");
- if(CORBA::is_nil(theObject)) return CORBA::string_dup(aPath.c_str());
- SALOMEDSImpl_SObject aSO;
- SALOMEDS::SObject_var aSObj = SALOMEDS::SObject::_narrow(theObject);
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
- if(!CORBA::is_nil(aSObj)) {
- aSO = _impl->FindObjectID(aSObj->GetID());
- }
- else {
- aSO = _impl->FindObjectIOR(_orb->object_to_string(theObject));
+ std::string aPath = "";
+
+ if (!CORBA::is_nil(theObject)) {
+ SALOMEDS::SObject_var aSObj = SALOMEDS::SObject::_narrow(theObject);
+ SALOMEDSImpl_SObject aSO;
+
+ if (!CORBA::is_nil(aSObj)) {
+ aSO = _impl->FindObjectID(aSObj->GetID());
+ }
+ else {
+ aSO = _impl->FindObjectIOR(_orb->object_to_string(theObject));
+ }
+
+ if (!aSO.IsNull()) {
+ aPath = _impl->GetObjectPath(aSO);
+ }
}
-
- if(aSO.IsNull()) return CORBA::string_dup(aPath.c_str());
-
- aPath = _impl->GetObjectPath(aSO);
- return CORBA::string_dup(aPath.c_str());
+
+ return CORBA::string_dup(aPath.c_str());
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->SetContext(std::string((char*)thePath));
- if(_impl->IsError() && _impl->GetErrorCode() == "InvalidContext")
+ if (_impl->IsError() && _impl->GetErrorCode() == "InvalidContext")
throw SALOMEDS::Study::StudyInvalidContext();
}
{
SALOMEDS::Locker lock;
- if(!_impl->HasCurrentContext()) throw SALOMEDS::Study::StudyInvalidContext();
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ if (!_impl->HasCurrentContext()) throw SALOMEDS::Study::StudyInvalidContext();
+
return CORBA::string_dup(_impl->GetContext().c_str());
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
throw SALOMEDS::Study::StudyInvalidContext();
-
+
std::vector<std::string> aSeq = _impl->GetObjectNames(std::string((char*)theContext));
if (_impl->GetErrorCode() == "InvalidContext")
throw SALOMEDS::Study::StudyInvalidContext();
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
throw SALOMEDS::Study::StudyInvalidContext();
-
+
std::vector<std::string> aSeq = _impl->GetDirectoryNames(std::string((char*)theContext));
if (_impl->GetErrorCode() == "InvalidContext")
throw SALOMEDS::Study::StudyInvalidContext();
for (int anIndex = 0; anIndex < aLength; anIndex++) {
aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
}
-
+
return aResult._retn();
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
if (strlen(theContext) == 0 && !_impl->HasCurrentContext())
throw SALOMEDS::Study::StudyInvalidContext();
-
+
std::vector<std::string> aSeq = _impl->GetFileNames(std::string((char*)theContext));
if (_impl->GetErrorCode() == "InvalidContext")
throw SALOMEDS::Study::StudyInvalidContext();
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
std::vector<std::string> aSeq = _impl->GetComponentNames(std::string((char*)theContext));
{
SALOMEDS::Locker lock;
- CORBA::String_var anID=theSO->GetID();
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ CORBA::String_var anID = theSO->GetID();
SALOMEDSImpl_SObject aSO = _impl->GetSObject(anID.in());
SALOMEDSImpl_ChildIterator anItr(aSO);
-
- //Create iterator
SALOMEDS_ChildIterator_i* it_servant = new SALOMEDS_ChildIterator_i(anItr, _orb);
+ SALOMEDS::ChildIterator_var it = it_servant->_this();
- return it_servant->_this();
+ return it._retn();
}
SALOMEDS::SComponentIterator_ptr SALOMEDS_Study_i::NewComponentIterator()
{
SALOMEDS::Locker lock;
- SALOMEDS_SComponentIterator_i* _it = new SALOMEDS_SComponentIterator_i(_impl->NewComponentIterator(), _orb);
- _it->Init();
- return _it->_this();
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS_SComponentIterator_i* it_servant = new SALOMEDS_SComponentIterator_i(_impl->NewComponentIterator(), _orb);
+ it_servant->Init();
+ SALOMEDS::SComponentIterator_var it = it_servant->_this();
+
+ return it._retn();
}
SALOMEDS::StudyBuilder_ptr SALOMEDS_Study_i::NewBuilder()
{
SALOMEDS::Locker lock;
- return _builder->_this();
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::StudyBuilder_var sb = SALOMEDS::StudyBuilder::_duplicate(_builder->_this());
+
+ return sb._retn();
}
//============================================================================
char* SALOMEDS_Study_i::Name()
{
SALOMEDS::Locker lock;
+ // Name is specified as IDL attribute: user exception cannot be raised
return CORBA::string_dup(_impl->Name().c_str());
}
void SALOMEDS_Study_i::Name(const char* name)
{
SALOMEDS::Locker lock;
+ // Name is specified as IDL attribute: user exception cannot be raised
_impl->Name(std::string(name));
}
* Purpose : get if study has been saved
*/
//============================================================================
-CORBA::Boolean SALOMEDS_Study_i::IsSaved()
+CORBA::Boolean SALOMEDS_Study_i::IsSaved()
{
SALOMEDS::Locker lock;
- return _impl->IsSaved();
+ // IsSaved is specified as IDL attribute: user exception cannot be raised
+ return (!_closed) ? _impl->IsSaved() : false;
}
//============================================================================
void SALOMEDS_Study_i::IsSaved(CORBA::Boolean save)
{
SALOMEDS::Locker lock;
- _impl->IsSaved(save);
+ // IsSaved is specified as IDL attribute: user exception cannot be raised
+ if (!_closed)
+ _impl->IsSaved(save);
}
//============================================================================
* Purpose : Detect if a Study has been modified since it has been saved
*/
//============================================================================
-CORBA::Boolean SALOMEDS_Study_i::IsModified()
+CORBA::Boolean SALOMEDS_Study_i::IsModified()
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsModified();
}
* Purpose : Sets a Modified flag of a Study to True
*/
//============================================================================
-void SALOMEDS_Study_i::Modified()
+void SALOMEDS_Study_i::Modified()
{
SALOMEDS::Locker lock;
- return _impl->Modify();
-}
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ _impl->Modify();
+}
//============================================================================
/*! Function : URL
char* SALOMEDS_Study_i::URL()
{
SALOMEDS::Locker lock;
+ // URL is specified as IDL attribute: user exception cannot be raised
return CORBA::string_dup(_impl->URL().c_str());
}
void SALOMEDS_Study_i::URL(const char* url)
{
SALOMEDS::Locker lock;
+ // URL is specified as IDL attribute: user exception cannot be raised
_impl->URL(std::string((char*)url));
}
-
CORBA::Short SALOMEDS_Study_i::StudyId()
{
SALOMEDS::Locker lock;
+ // StudyId is specified as IDL attribute: user exception cannot be raised
return _impl->StudyId();
}
void SALOMEDS_Study_i::StudyId(CORBA::Short id)
{
SALOMEDS::Locker lock;
+ // StudyId is specified as IDL attribute: user exception cannot be raised
_impl->StudyId(id);
}
-void SALOMEDS_Study_i::UpdateIORLabelMap(const char* anIOR,const char* anEntry)
+void SALOMEDS_Study_i::UpdateIORLabelMap(const char* anIOR, const char* anEntry)
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->UpdateIORLabelMap(std::string((char*)anIOR), std::string((char*)anEntry));
}
if (_mapOfStudies.find(aStudyImpl) != _mapOfStudies.end())
return _mapOfStudies[aStudyImpl];
else
- {
- SALOMEDS_Study_i *Study_servant = new SALOMEDS_Study_i(aStudyImpl, orb);
- _mapOfStudies[aStudyImpl]=Study_servant;
- return Study_servant;
- }
+ {
+ SALOMEDS_Study_i *Study_servant = new SALOMEDS_Study_i(aStudyImpl, orb);
+ _mapOfStudies[aStudyImpl]=Study_servant;
+ return Study_servant;
+ }
}
void SALOMEDS_Study_i::IORUpdated(SALOMEDSImpl_AttributeIOR* theAttribute)
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::GenericAttribute_ptr aTarget;
if (anObject->FindAttribute(aTarget,"AttributeTarget")) {
return SALOMEDS::AttributeTarget::_narrow(aTarget)->Get();
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDSImpl_AttributeStudyProperties* anAttr = _impl->GetProperties();
SALOMEDS_AttributeStudyProperties_i* SP = new SALOMEDS_AttributeStudyProperties_i(anAttr, _orb);
- return SP->AttributeStudyProperties::_this();
+ SALOMEDS::AttributeStudyProperties_var aProp = SP->_this();
+ return aProp._retn();
}
char* SALOMEDS_Study_i::GetLastModificationDate()
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return CORBA::string_dup(_impl->GetLastModificationDate().c_str());
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ SALOMEDS::ListOfDates_var aDates = new SALOMEDS::ListOfDates;
+
std::vector<std::string> aSeq = _impl->GetModificationsDate();
+
int aLength = aSeq.size();
- SALOMEDS::ListOfDates_var aDates = new SALOMEDS::ListOfDates;
aDates->length(aLength);
-
- for(int anIndex = 0; anIndex < aLength; anIndex++) {
+ for (int anIndex = 0; anIndex < aLength; anIndex++) {
aDates[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
}
+
return aDates._retn();
}
-
-
//============================================================================
/*! Function : GetUseCaseBuilder
* Purpose : Returns a UseCase builder
SALOMEDS::UseCaseBuilder_ptr SALOMEDS_Study_i::GetUseCaseBuilder()
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS_UseCaseBuilder_i* UCBuilder = new SALOMEDS_UseCaseBuilder_i(_impl->GetUseCaseBuilder(), _orb);
- return UCBuilder->_this();
+ SALOMEDS::UseCaseBuilder_var uc = UCBuilder->_this();
+ return uc._retn();
}
{
SALOMEDS::Locker lock;
- RemovePostponed(-1);
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+ RemovePostponed(-1);
+
SALOMEDS::SComponentIterator_var itcomponent = NewComponentIterator();
for (; itcomponent->More(); itcomponent->Next()) {
SALOMEDS::SComponent_var sco = itcomponent->Value();
// we have found the associated engine to write the data
MESSAGE ( "We have found an engine for data type :"<< compodatatype);
//_narrow can throw a corba exception
- try
- {
- CORBA::Object_var obj = _orb->string_to_object(IOREngine);
- if (!CORBA::is_nil(obj))
- {
- SALOMEDS::Driver_var anEngine = SALOMEDS::Driver::_narrow(obj) ;
- if (!anEngine->_is_nil())
- {
- SALOMEDS::unlock();
- anEngine->Close(sco);
- SALOMEDS::lock();
- }
- }
- }
- catch (CORBA::Exception&)
- {/*pass*/ }
+ try {
+ CORBA::Object_var obj = _orb->string_to_object(IOREngine);
+ if (!CORBA::is_nil(obj)) {
+ SALOMEDS::Driver_var anEngine = SALOMEDS::Driver::_narrow(obj) ;
+ if (!anEngine->_is_nil()) {
+ SALOMEDS::unlock();
+ anEngine->Close(sco);
+ SALOMEDS::lock();
+ }
+ }
+ }
+ catch (CORBA::Exception&) {
+ }
}
sco->UnRegister();
}
-
+
//Does not need any more this iterator
itcomponent->UnRegister();
-
-
+
+ // Notify GUI that study is closed
+ SALOME_NamingService *aNamingService = KERNEL::getNamingService();
+ CORBA::Object_ptr obj = aNamingService->Resolve("/Kernel/Session");
+ SALOME::Session_var aSession = SALOME::Session::_narrow(obj);
+ if ( !CORBA::is_nil(aSession) ) {
+ std::stringstream ss;
+ ss << "studyClosed:" << _impl->StudyId();
+ std::string str = ss.str();
+ SALOMEDS::unlock();
+ aSession->emitMessageOneWay(str.c_str());
+ SALOMEDS::lock();
+ }
+
_impl->Close();
+ _closed = true;
}
//============================================================================
* Purpose :
*/
//============================================================================
-#ifndef WIN32
-void SALOMEDS_Study_i::RemovePostponed(const CORBA::Long /*theUndoLimit*/)
-#else
void SALOMEDS_Study_i::RemovePostponed(CORBA::Long /*theUndoLimit*/)
-#endif
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
std::vector<std::string> anIORs = _impl->GetIORs();
int i, aSize = (int)anIORs.size();
-
- for(i = 0; i < aSize; i++) {
+
+ for (i = 0; i < aSize; i++) {
try {
CORBA::Object_var obj = _orb->string_to_object(anIORs[i].c_str());
SALOME::GenericObj_var aGeneric = SALOME::GenericObj::_narrow(obj);
- //rnv: To avoid double deletion of the Salome Generic Objects:
- //rnv: 1. First decrement of the reference count in the SALOMEDSImpl_AttributeIOR::~SALOMEDSImpl_AttributeIOR();
- //rnv: 2. Second decrement of the reference count in the next string : aGeneric->UnRegister();
+ //rnv: To avoid double deletion of the Salome Generic Objects:
+ //rnv: 1. First decrement of the reference count in the SALOMEDSImpl_AttributeIOR::~SALOMEDSImpl_AttributeIOR();
+ //rnv: 2. Second decrement of the reference count in the next string : aGeneric->UnRegister();
//if (!CORBA::is_nil(aGeneric)) aGeneric->UnRegister();
} catch (...) {}
}
* Purpose :
*/
//============================================================================
-#ifndef WIN32
-void SALOMEDS_Study_i::UndoPostponed(const CORBA::Long theWay)
-#else
void SALOMEDS_Study_i::UndoPostponed(CORBA::Long theWay)
-#endif
{
SALOMEDS::Locker lock;
//Not implemented
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
std::string aPath((char*)thePath), aBaseName((char*)theBaseName);
SALOMEDS_DriverFactory_i* factory = new SALOMEDS_DriverFactory_i(_orb);
- CORBA::Boolean ret = _impl->DumpStudy(aPath, aBaseName, isPublished, isMultiFile, factory);
+ bool ret = _impl->DumpStudy(aPath, aBaseName, isPublished, isMultiFile, factory);
delete factory;
+
return ret;
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDSImpl_AttributeParameter* anAttr = _impl->GetCommonParameters(theID, theSavePoint);
SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
- return SP->AttributeParameter::_this();
+ SALOMEDS::AttributeParameter_var aParam = SP->_this();
+
+ return aParam._retn();
}
//============================================================================
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDSImpl_AttributeParameter* anAttr = _impl->GetModuleParameters(theID, theModuleName, theSavePoint);
SALOMEDS_AttributeParameter_i* SP = new SALOMEDS_AttributeParameter_i(anAttr, _orb);
- return SP->AttributeParameter::_this();
+ SALOMEDS::AttributeParameter_var aParam = SP->_this();
+
+ return aParam._retn();
}
//============================================================================
void SALOMEDS_Study_i::SetStudyLock(const char* theLockerID)
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->SetStudyLock(theLockerID);
}
bool SALOMEDS_Study_i::IsStudyLocked()
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsStudyLocked();
}
void SALOMEDS_Study_i::UnLockStudy(const char* theLockerID)
{
SALOMEDS::Locker lock;
+
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->UnLockStudy(theLockerID);
}
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
std::vector<std::string> aSeq = _impl->GetLockerID();
for(int anIndex = 0; anIndex < aLength; anIndex++) {
aResult[anIndex] = CORBA::string_dup(aSeq[anIndex].c_str());
}
+
return aResult._retn();
}
//============================================================================
//============================================================================
void SALOMEDS_Study_i::SetReal(const char* theVarName, CORBA::Double theValue)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+
_impl->SetVariable(std::string(theVarName),
- theValue,
- SALOMEDSImpl_GenericVariable::REAL_VAR);
- if(_notifier)
+ theValue,
+ SALOMEDSImpl_GenericVariable::REAL_VAR);
+ if (_notifier)
_notifier->modifyNB_Notification(theVarName);
}
//============================================================================
void SALOMEDS_Study_i::SetInteger(const char* theVarName, CORBA::Long theValue)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->SetVariable(std::string(theVarName),
- theValue,
- SALOMEDSImpl_GenericVariable::INTEGER_VAR);
- if(_notifier)
+ theValue,
+ SALOMEDSImpl_GenericVariable::INTEGER_VAR);
+ if (_notifier)
_notifier->modifyNB_Notification(theVarName);
}
//============================================================================
void SALOMEDS_Study_i::SetBoolean(const char* theVarName, CORBA::Boolean theValue)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->SetVariable(std::string(theVarName),
- theValue,
- SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
- if(_notifier)
+ theValue,
+ SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
+ if (_notifier)
_notifier->modifyNB_Notification(theVarName);
}
//============================================================================
void SALOMEDS_Study_i::SetString(const char* theVarName, const char* theValue)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->SetStringVariable(std::string(theVarName),
- theValue,
- SALOMEDSImpl_GenericVariable::STRING_VAR);
- if(_notifier)
+ theValue,
+ SALOMEDSImpl_GenericVariable::STRING_VAR);
+ if (_notifier)
_notifier->modifyNB_Notification(theVarName);
}
//============================================================================
void SALOMEDS_Study_i::SetStringAsDouble(const char* theVarName, CORBA::Double theValue)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->SetStringVariableAsDouble(std::string(theVarName),
- theValue,
- SALOMEDSImpl_GenericVariable::STRING_VAR);
+ theValue,
+ SALOMEDSImpl_GenericVariable::STRING_VAR);
}
//============================================================================
//============================================================================
CORBA::Double SALOMEDS_Study_i::GetReal(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->GetVariableValue(std::string(theVarName));
}
//============================================================================
CORBA::Long SALOMEDS_Study_i::GetInteger(const char* theVarName)
{
- return (int)_impl->GetVariableValue(std::string(theVarName));
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ return (long)_impl->GetVariableValue(std::string(theVarName));
}
//============================================================================
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::GetBoolean(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return (bool)_impl->GetVariableValue(std::string(theVarName));
}
//============================================================================
char* SALOMEDS_Study_i::GetString(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return CORBA::string_dup(_impl->GetStringVariableValue(std::string(theVarName)).c_str());
}
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsReal(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsTypeOf(std::string(theVarName),
- SALOMEDSImpl_GenericVariable::REAL_VAR);
+ SALOMEDSImpl_GenericVariable::REAL_VAR);
}
//============================================================================
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsInteger(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsTypeOf(std::string(theVarName),
- SALOMEDSImpl_GenericVariable::INTEGER_VAR);
+ SALOMEDSImpl_GenericVariable::INTEGER_VAR);
}
//============================================================================
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsBoolean(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsTypeOf(std::string(theVarName),
- SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
+ SALOMEDSImpl_GenericVariable::BOOLEAN_VAR);
}
//============================================================================
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsString(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsTypeOf(std::string(theVarName),
- SALOMEDSImpl_GenericVariable::STRING_VAR);
+ SALOMEDSImpl_GenericVariable::STRING_VAR);
}
//============================================================================
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsVariable(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsVariable(std::string(theVarName));
}
//============================================================================
SALOMEDS::ListOfStrings* SALOMEDS_Study_i::GetVariableNames()
{
- std::vector<std::string> aVarNames = _impl->GetVariableNames();
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
SALOMEDS::ListOfStrings_var aResult = new SALOMEDS::ListOfStrings;
-
+
+ std::vector<std::string> aVarNames = _impl->GetVariableNames();
+
int aLen = aVarNames.size();
aResult->length(aLen);
-
for (int anInd = 0; anInd < aLen; anInd++)
aResult[anInd] = CORBA::string_dup(aVarNames[anInd].c_str());
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::RemoveVariable(const char* theVarName)
{
- CORBA::Boolean res = _impl->RemoveVariable(std::string(theVarName));
- if(res && _notifier)
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ bool res = _impl->RemoveVariable(std::string(theVarName));
+ if (res && _notifier)
_notifier->modifyNB_Notification(theVarName);
+
return res;
}
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::RenameVariable(const char* theVarName, const char* theNewVarName)
{
- CORBA::Boolean res = _impl->RenameVariable(std::string(theVarName), std::string(theNewVarName));
- if(res && _notifier)
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
+ bool res = _impl->RenameVariable(std::string(theVarName), std::string(theNewVarName));
+ if (res && _notifier)
_notifier->modifyNB_Notification(theVarName);
+
return res;
}
//============================================================================
CORBA::Boolean SALOMEDS_Study_i::IsVariableUsed(const char* theVarName)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
return _impl->IsVariableUsed(std::string(theVarName));
}
//============================================================================
SALOMEDS::ListOfListOfStrings* SALOMEDS_Study_i::ParseVariables(const char* theVarName)
{
- std::vector< std::vector<std::string> > aSections = _impl->ParseVariables(std::string(theVarName));
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
SALOMEDS::ListOfListOfStrings_var aResult = new SALOMEDS::ListOfListOfStrings;
+ std::vector< std::vector<std::string> > aSections = _impl->ParseVariables(std::string(theVarName));
+
int aSectionsLen = aSections.size();
aResult->length(aSectionsLen);
{
SALOMEDS::Locker lock;
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
std::string script = SALOMEDSImpl_IParameters::getDefaultScript(_impl, theModuleName, theShift);
return CORBA::string_dup(script.c_str());
}
//============================================================================
void SALOMEDS_Study_i::EnableUseCaseAutoFilling(CORBA::Boolean isEnabled)
{
+ if (_closed)
+ throw SALOMEDS::Study::StudyInvalidReference();
+
_impl->EnableUseCaseAutoFilling(isEnabled);
SALOMEDSImpl_StudyBuilder* builder = _builder->GetImpl();
- if(builder) {
- if(isEnabled) {
+ if (builder) {
+ if (isEnabled) {
builder->SetOnAddSObject(_impl->GetCallback());
builder->SetOnRemoveSObject(_impl->GetCallback());
}
* Purpose : This function attach an observer to the study
*/
//============================================================================
-void SALOMEDS_Study_i::attach(SALOMEDS::Observer_ptr theObs,CORBA::Boolean modify)
+void SALOMEDS_Study_i::attach(SALOMEDS::Observer_ptr theObs, CORBA::Boolean modify)
{
- if(_notifier)
- static_cast<SALOMEDS::Notifier*>(_notifier)->attach(theObs,modify);
+ if (_notifier)
+ static_cast<SALOMEDS::Notifier*>(_notifier)->attach(theObs, modify);
}
//============================================================================
void SALOMEDS_Study_i::detach(SALOMEDS::Observer_ptr theObs)
{
- if(_notifier)
+ if (_notifier)
static_cast<SALOMEDS::Notifier*>(_notifier)->detach(theObs);
}