X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FSALOMEDSImpl%2FSALOMEDSImpl_Study.cxx;h=5947c40304bdf72318f3b7771f2b406b864881bf;hb=f932433e7396f9be950f617c50c9b15db1a33be1;hp=ed054fb2ecb984c83154d96070ea83f389044640;hpb=e6bfea36374791cd31c274a2f97df90dc60ddaf3;p=modules%2Fyacs.git diff --git a/src/SALOMEDSImpl/SALOMEDSImpl_Study.cxx b/src/SALOMEDSImpl/SALOMEDSImpl_Study.cxx index ed054fb2e..5947c4030 100644 --- a/src/SALOMEDSImpl/SALOMEDSImpl_Study.cxx +++ b/src/SALOMEDSImpl/SALOMEDSImpl_Study.cxx @@ -1,44 +1,37 @@ -// Copyright (C) 2005 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, +// Copyright (C) 2007-2016 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 -// +// // This library is free software; you can redistribute it and/or // modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU // Lesser General Public License for more details. // -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + // File : SALOMEDSImpl_Study.cxx // Author : Sergey RUIN // Module : SALOME - - +// #include "SALOMEDSImpl_Study.hxx" +#include -using namespace std; +#include +#include -#include -#include - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include +#include "DF_Application.hxx" +#include "DF_ChildIterator.hxx" #include "SALOMEDSImpl_ChildNodeIterator.hxx" #include "SALOMEDSImpl_Attributes.hxx" @@ -47,37 +40,43 @@ using namespace std; #include "SALOMEDSImpl_StudyHandle.hxx" #include "SALOMEDSImpl_Tool.hxx" #include "SALOMEDSImpl_IParameters.hxx" +#include "SALOMEDSImpl_ScalarVariable.hxx" + +#include +#include +#include -IMPLEMENT_STANDARD_HANDLE( SALOMEDSImpl_Study, MMgt_TShared ) -IMPLEMENT_STANDARD_RTTIEXT( SALOMEDSImpl_Study, MMgt_TShared ) +// comment out the following define to enable \t symbols in in the python dump files +#define WITHOUT_TABS #define DIRECTORYID 16661 #define FILELOCALID 26662 #define FILEID "FILE: " +#define VARIABLE_SEPARATOR ':' +#define OPERATION_SEPARATOR '|' //============================================================================ /*! Function : SALOMEDSImpl_Study * Purpose : SALOMEDSImpl_Study constructor */ //============================================================================ -SALOMEDSImpl_Study::SALOMEDSImpl_Study(const Handle(TDocStd_Document)& doc, - const TCollection_AsciiString& study_name) +SALOMEDSImpl_Study::SALOMEDSImpl_Study(const DF_Document* doc, + const std::string& study_name) { - doc->SetUndoLimit(1); // mpv (IPAL9237): if there is no undo limit, operations mechanism couldn't work _name = study_name; - _doc = doc; + _doc = (DF_Document*)doc; _Saved = false ; _URL = ""; _StudyId = -1; - _autoFill = true; - myNbPostponed.Append(0); - myNbUndos = 0; + _autoFill = false; _errorCode = ""; _useCaseBuilder = new SALOMEDSImpl_UseCaseBuilder(_doc); _builder = new SALOMEDSImpl_StudyBuilder(this); _cb = new SALOMEDSImpl_Callback(_useCaseBuilder); + _notifier=0; + _genObjRegister=0; //Put on the root label a StudyHandle attribute to store the address of this object - //It will be used to retrieve the study object by TDF_Label that belongs to the study + //It will be used to retrieve the study object by DF_Label that belongs to the study SALOMEDSImpl_StudyHandle::Set(_doc->Main().Root(), this); } @@ -88,31 +87,35 @@ SALOMEDSImpl_Study::SALOMEDSImpl_Study(const Handle(TDocStd_Document)& doc, */ //============================================================================ SALOMEDSImpl_Study::~SALOMEDSImpl_Study() -{} +{ + delete _builder; + delete _cb; + delete _useCaseBuilder; +} //============================================================================ /*! Function : GetPersistentReference * Purpose : Get persistent reference of study (idem URL()) */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::GetPersistentReference() +std::string SALOMEDSImpl_Study::GetPersistentReference() { _errorCode = ""; return URL(); } //============================================================================ /*! Function : GetTransientReference - * Purpose : Get IOR of the Study (registred in OCAF document in doc->Root) + * Purpose : Get IOR of the Study (registred in Document in doc->Root) */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::GetTransientReference() +std::string SALOMEDSImpl_Study::GetTransientReference() { _errorCode = ""; - TCollection_AsciiString IOR = ""; + std::string IOR = ""; - Handle(SALOMEDSImpl_AttributeIOR) Att; - TDF_Label _lab = _doc->GetData()->Root(); - if (_lab.FindAttribute(SALOMEDSImpl_AttributeIOR::GetID(),Att)) { + SALOMEDSImpl_AttributeIOR* Att; + DF_Label _lab = _doc->Root(); + if ((Att=(SALOMEDSImpl_AttributeIOR*)_lab.FindAttribute(SALOMEDSImpl_AttributeIOR::GetID()))) { IOR = Att->Value(); } else { @@ -122,18 +125,18 @@ TCollection_AsciiString SALOMEDSImpl_Study::GetTransientReference() return IOR; } -void SALOMEDSImpl_Study::SetTransientReference(const TCollection_AsciiString& theIOR) +void SALOMEDSImpl_Study::SetTransientReference(const std::string& theIOR) { _errorCode = ""; - Handle(SALOMEDSImpl_AttributeStudyProperties) aProp = GetProperties(); + SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties(); int aLocked = aProp->IsLocked(); - if (aLocked) aProp->SetLocked(Standard_False); + if (aLocked) aProp->SetLocked(false); // Assign the value of the IOR in the study->root SALOMEDSImpl_AttributeIOR::Set(_doc->Main().Root(), theIOR); - if (aLocked) aProp->SetLocked(Standard_True); + if (aLocked) aProp->SetLocked(true); } //============================================================================ @@ -144,7 +147,7 @@ void SALOMEDSImpl_Study::SetTransientReference(const TCollection_AsciiString& th bool SALOMEDSImpl_Study::IsEmpty() { _errorCode = ""; - if (_doc.IsNull()) return true; + if (!_doc) return true; return _doc->IsEmpty(); } @@ -153,17 +156,17 @@ bool SALOMEDSImpl_Study::IsEmpty() * Purpose : Find a Component with ComponentDataType = aComponentName */ //============================================================================ -Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::FindComponent (const TCollection_AsciiString& aComponentName) +SALOMEDSImpl_SComponent SALOMEDSImpl_Study::FindComponent (const std::string& aComponentName) { _errorCode = ""; bool _find = false; - TCollection_AsciiString name; + std::string name; SALOMEDSImpl_SComponentIterator itcomp = NewComponentIterator(); - Handle(SALOMEDSImpl_SComponent) compo; + SALOMEDSImpl_SComponent compo; for (; itcomp.More(); itcomp.Next()) { - Handle(SALOMEDSImpl_SComponent) SC = itcomp.Value(); - name = SC->ComponentDataType(); + SALOMEDSImpl_SComponent SC = itcomp.Value(); + name = SC.ComponentDataType(); if(aComponentName == name) { _find = true; return SC; @@ -173,7 +176,7 @@ Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::FindComponent (const TCollec if(!_find) { _errorCode = "No component was found"; - return NULL; + return compo; } return compo; } @@ -183,31 +186,31 @@ Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::FindComponent (const TCollec * Purpose : Find a Component from it's ID */ //============================================================================ -Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::FindComponentID(const TCollection_AsciiString& aComponentID) +SALOMEDSImpl_SComponent SALOMEDSImpl_Study::FindComponentID(const std::string& aComponentID) { _errorCode = ""; // Iterate on each components defined in the study // Get the component ID and compare with aComponentID bool _find = false; - TCollection_AsciiString ID; - Handle(SALOMEDSImpl_SComponent) compo; + std::string ID; + SALOMEDSImpl_SComponent compo; SALOMEDSImpl_SComponentIterator itcomp = NewComponentIterator(); for (; itcomp.More(); itcomp.Next()) { - Handle(SALOMEDSImpl_SComponent) SC = itcomp.Value(); - ID = SC->GetID(); + SALOMEDSImpl_SComponent SC = itcomp.Value(); + ID = SC.GetID(); if(aComponentID == ID) { - // ComponentID found - _find = true; + // ComponentID found + _find = true; compo = SC; } } if(!_find) { _errorCode = "No component was found"; - compo = NULL; + compo = compo; } return compo; @@ -218,7 +221,7 @@ Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::FindComponentID(const TColle * Purpose : Find an Object with SALOMEDSImpl_Name = anObjectName */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObject(const TCollection_AsciiString& anObjectName) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObject(const std::string& anObjectName) { _errorCode = ""; @@ -226,23 +229,23 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObject(const TCollection_As // After testing the component name, iterate in all objects defined under // components (function _FindObject) bool _find = false; - Handle(SALOMEDSImpl_SObject) RefSO = NULL; + SALOMEDSImpl_SObject RefSO; SALOMEDSImpl_SComponentIterator it = NewComponentIterator(); for (; it.More();it.Next()){ if(!_find) { - Handle(SALOMEDSImpl_SComponent) SC = it.Value(); - if (SC->GetName() == anObjectName) - { - _find = true; - RefSO = SC; - - } - if (!_find) RefSO = _FindObject(SC, anObjectName, _find); + SALOMEDSImpl_SComponent SC = it.Value(); + if (SC.GetName() == anObjectName) + { + _find = true; + RefSO = SC; + + } + if (!_find) RefSO = _FindObject(SC, anObjectName, _find); } } - if(RefSO.IsNull()) _errorCode = "No object was found"; + if(!RefSO) _errorCode = "No object was found"; return RefSO; } @@ -251,17 +254,17 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObject(const TCollection_As * Purpose : Find an Object with ID = anObjectID */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObjectID(const TCollection_AsciiString& anObjectID) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObjectID(const std::string& anObjectID) { _errorCode = ""; + SALOMEDSImpl_SObject so; - // Convert aSO->GetID in TDF_Label. - TDF_Label Lab; - TDF_Tool::Label(_doc->Main().Data(), anObjectID, Lab); + // Convert aSO->GetID in DF_Label. + DF_Label Lab = DF_Label::Label(_doc->Main(), anObjectID, false); if (Lab.IsNull()) { _errorCode = "No label was found by ID"; - return NULL; + return so; } return GetSObject(Lab); @@ -272,17 +275,17 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObjectID(const TCollection_ * Purpose : Creates an Object with ID = anObjectID */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::CreateObjectID(const TCollection_AsciiString& anObjectID) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::CreateObjectID(const std::string& anObjectID) { _errorCode = ""; + SALOMEDSImpl_SObject so; - // Convert aSO->GetID in TDF_Label. - TDF_Label Lab; - TDF_Tool::Label(_doc->Main().Data(), anObjectID, Lab, Standard_True); + // Convert aSO->GetID in DF_Label. + DF_Label Lab = DF_Label::Label(_doc->Main(), anObjectID, true); if (Lab.IsNull()) { _errorCode = "Can not create a label"; - return NULL; + return so; } return GetSObject(Lab); @@ -294,38 +297,38 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::CreateObjectID(const TCollectio * : with ComponentDataType = aComponentName */ //============================================================================ -Handle(TColStd_HSequenceOfTransient) SALOMEDSImpl_Study::FindObjectByName(const TCollection_AsciiString& anObjectName, - const TCollection_AsciiString& aComponentName) +std::vector SALOMEDSImpl_Study::FindObjectByName(const std::string& anObjectName, + const std::string& aComponentName) { _errorCode = ""; - Handle(TColStd_HSequenceOfTransient) listSO = new TColStd_HSequenceOfTransient(); + std::vector listSO; - Handle(SALOMEDSImpl_SComponent) compo = FindComponent(aComponentName) ; - if ( compo.IsNull() ) { + SALOMEDSImpl_SComponent compo = FindComponent(aComponentName) ; + if ( !compo ) { _errorCode = "Can not find the component"; return listSO; } // Iterate on each object and subobject of the component // If objectName is found add it to the list of SObjects - TCollection_AsciiString childName ; + std::string childName ; - TCollection_AsciiString compoId = compo->GetID(); - Handle(SALOMEDSImpl_ChildIterator) it = NewChildIterator(compo); - for ( ; it->More(); it->Next() ) { + std::string compoId = compo.GetID(); + SALOMEDSImpl_ChildIterator it = NewChildIterator(compo); + for ( ; it.More(); it.Next() ) { - Handle(SALOMEDSImpl_SObject) CSO = it->Value(); - if ( CSO->GetName() == anObjectName ) { - /* add to list */ - listSO->Append(CSO) ; + SALOMEDSImpl_SObject CSO = it.Value(); + if ( CSO.GetName() == anObjectName ) { + /* add to list */ + listSO.push_back(CSO) ; } /* looks also for eventual children */ bool found = false ; CSO = _FindObject( CSO, anObjectName, found ) ; if( found) { - listSO->Append(CSO) ; + listSO.push_back(CSO) ; } } @@ -339,47 +342,25 @@ Handle(TColStd_HSequenceOfTransient) SALOMEDSImpl_Study::FindObjectByName(const * Purpose : Find an Object with IOR = anObjectIOR */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObjectIOR(const TCollection_AsciiString& anObjectIOR) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObjectIOR(const std::string& anObjectIOR) { _errorCode = ""; - // firstly searching in the datamap for optimization - if (myIORLabels.IsBound(anObjectIOR)) { - Handle(SALOMEDSImpl_SObject) aResult = GetSObject(myIORLabels.Find(anObjectIOR)); - // 11 oct 2002: forbidden attributes must be checked here - if (!aResult->GetLabel().IsAttribute(SALOMEDSImpl_AttributeIOR::GetID())) { - myIORLabels.UnBind(anObjectIOR); - } else - return aResult; - } - // Iterate to all components defined in the study - // After testing the component name, iterate in all objects defined under - // components (function _FindObject) - bool _find = false; - Handle(SALOMEDSImpl_SObject) RefSO = NULL; + SALOMEDSImpl_SObject aResult ; - SALOMEDSImpl_SComponentIterator it = NewComponentIterator(); - Handle(SALOMEDSImpl_SComponent) SC; - for (; it.More();it.Next()){ - if(!_find) - { - SC = it.Value(); - TCollection_AsciiString ior = SC->GetIOR(); - if (ior != "") - { - if (ior == anObjectIOR) - { - _find = true; - RefSO = SC; - } - } - if (!_find) - RefSO = _FindObjectIOR(SC, anObjectIOR, _find); - } + // searching in the datamap for optimization + std::map::iterator it=myIORLabels.find(anObjectIOR); + if (it != myIORLabels.end()) { + aResult = GetSObject(it->second); + // 11 oct 2002: forbidden attributes must be checked here + if (!aResult.GetLabel().IsAttribute(SALOMEDSImpl_AttributeIOR::GetID())) { + myIORLabels.erase(anObjectIOR); + aResult = SALOMEDSImpl_SObject(); + } } - if(RefSO.IsNull()) _errorCode = "No object was found"; - return RefSO; + if(!aResult) _errorCode = "No object was found"; + return aResult; } //============================================================================ @@ -387,61 +368,60 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObjectIOR(const TCollection * Purpose : Find an Object by its path = thePath */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObjectByPath(const TCollection_AsciiString& thePath) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::FindObjectByPath(const std::string& thePath) { _errorCode = ""; - TCollection_AsciiString aPath(thePath), aToken; - Handle(SALOMEDSImpl_SObject) aSO = NULL; - int i = 1, aLength = aPath.Length(); + std::string aPath(thePath), aToken; + SALOMEDSImpl_SObject aSO; + int aLength = aPath.size(); bool isRelative = false; if(aLength == 0) { //Empty path - return the current context return GetSObject(_current); } - if(aPath.Value(1) != '/') //Relative path + if(aPath[0] != '/') //Relative path isRelative = true; - TDF_ChildIterator anIterator; - TDF_Label aLabel; - Handle(SALOMEDSImpl_AttributeName) anAttr; + DF_ChildIterator anIterator; + DF_Label aLabel; + SALOMEDSImpl_AttributeName* anAttr; if(isRelative) { - if(_current.IsNull()) return NULL; - anIterator.Initialize(_current, Standard_False); + if(_current.IsNull()) return aSO; + anIterator.Init(_current, false); } else { - if(aPath.Length() == 1 && aPath.Value(1) == '/') { //Root + if(aPath.size() == 1 && aPath[0] == '/') { //Root return GetSObject(_doc->Main()); } - anIterator.Initialize(_doc->Main(), Standard_False); + anIterator.Init(_doc->Main(), false); } - while(i <= aLength) { + std::vector vs = SALOMEDSImpl_Tool::splitString(aPath, '/'); + for(int i = 0, len = vs.size(); iValue() == aToken) { - aToken = aPath.Token("/", i+1); //Check if it was the last part of the path - if(aToken.Length() == 0) { //The searched label is found (no part of the path is left) - return GetSObject(aLabel); - } - - anIterator.Initialize(aLabel, Standard_False); - break; - } + if((anAttr=(SALOMEDSImpl_AttributeName*)aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) { + if(anAttr->Value() == aToken) { + if(i == (len-1)) { //The searched label is found (no part of the path is left) + return GetSObject(aLabel); + } + + anIterator.Init(aLabel, false); + break; + } } } - i++; } - if(aSO.IsNull()) _errorCode = "No object was found"; + if(!aSO) _errorCode = "No object was found"; return aSO; } @@ -450,28 +430,28 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::FindObjectByPath(const TCollect * Purpose : */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::GetObjectPath(const Handle(SALOMEDSImpl_SObject)& theObject) +std::string SALOMEDSImpl_Study::GetObjectPath(const SALOMEDSImpl_SObject& theObject) { _errorCode = ""; - TCollection_AsciiString aPath(""); - if(theObject.IsNull()) { + std::string aPath(""); + if(!theObject) { _errorCode = "Null object"; - return aPath.ToCString(); + return aPath; } - TCollection_AsciiString aName = theObject->GetName(); - if(!aName.IsEmpty() && aName != "" ) { - TCollection_AsciiString aValue((char*)aName.ToCString()); - aValue.Prepend("/"); + std::string aName = theObject.GetName(); + if(!aName.empty() && aName != "" ) { + std::string aValue("/"); + aValue+=aName; aValue += aPath; aPath = aValue; - Handle(SALOMEDSImpl_SObject) aFather = theObject->GetFather(); - if(!aFather.IsNull()) { - aName = aFather->GetName(); - if(!aName.IsEmpty() && aName != "") { - aValue = (char*)GetObjectPath(aFather).ToCString(); - aPath = aValue + aPath; + SALOMEDSImpl_SObject aFather = theObject.GetFather(); + if(aFather) { + aName = aFather.GetName(); + if(!aName.empty() && aName != "") { + aValue = GetObjectPath(aFather); + aPath = aValue + aPath; } } } @@ -485,13 +465,13 @@ TCollection_AsciiString SALOMEDSImpl_Study::GetObjectPath(const Handle(SALOMEDSI * Purpose : */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::GetObjectPathByIOR(const TCollection_AsciiString& theIOR) +std::string SALOMEDSImpl_Study::GetObjectPathByIOR(const std::string& theIOR) { _errorCode = ""; - TCollection_AsciiString aPath; - Handle(SALOMEDSImpl_SObject) so = FindObjectIOR(theIOR); - if(so.IsNull()) { + std::string aPath; + SALOMEDSImpl_SObject so = FindObjectIOR(theIOR); + if(!so) { _errorCode = "No SObject was found by IOR"; return aPath; } @@ -505,19 +485,19 @@ TCollection_AsciiString SALOMEDSImpl_Study::GetObjectPathByIOR(const TCollection * Purpose : Sets the current context */ //============================================================================ -bool SALOMEDSImpl_Study::SetContext(const TCollection_AsciiString& thePath) +bool SALOMEDSImpl_Study::SetContext(const std::string& thePath) { _errorCode = ""; - if(thePath.IsEmpty()) { + if(thePath.empty()) { _errorCode = "InvalidPath"; return false; } - TCollection_AsciiString aPath(thePath), aContext(""); + std::string aPath(thePath), aContext(""); bool isInvalid = false; - Handle(SALOMEDSImpl_SObject) aSO; + SALOMEDSImpl_SObject aSO; - if(aPath.Value(1) != '/') { //Relative path + if(aPath[0] != '/') { //Relative path aContext = GetContext(); aContext += '/'; aContext += aPath; @@ -526,18 +506,18 @@ bool SALOMEDSImpl_Study::SetContext(const TCollection_AsciiString& thePath) aContext = aPath; try { - aSO = FindObjectByPath(aContext.ToCString()); + aSO = FindObjectByPath(aContext); } catch( ... ) { isInvalid = true; } - if(isInvalid || aSO.IsNull()) { + if(isInvalid || !aSO) { _errorCode = "InvalidContext"; return false; } - TDF_Label aLabel = aSO->GetLabel(); + DF_Label aLabel = aSO.GetLabel(); if(aLabel.IsNull()) { _errorCode = "InvalidContext"; return false; @@ -553,7 +533,7 @@ bool SALOMEDSImpl_Study::SetContext(const TCollection_AsciiString& thePath) * Purpose : Gets the current context */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::GetContext() +std::string SALOMEDSImpl_Study::GetContext() { _errorCode = ""; @@ -561,7 +541,7 @@ TCollection_AsciiString SALOMEDSImpl_Study::GetContext() _errorCode = "InvaidContext"; return ""; } - Handle(SALOMEDSImpl_SObject) so = GetSObject(_current); + SALOMEDSImpl_SObject so = GetSObject(_current); return GetObjectPath(so); } @@ -570,29 +550,31 @@ TCollection_AsciiString SALOMEDSImpl_Study::GetContext() * Purpose : method to get all object names in the given context (or in the current context, if 'theContext' is empty) */ //============================================================================ -Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetObjectNames(const TCollection_AsciiString& theContext) +std::vector SALOMEDSImpl_Study::GetObjectNames(const std::string& theContext) { _errorCode = ""; - Handle(TColStd_HSequenceOfAsciiString) aResultSeq = new TColStd_HSequenceOfAsciiString; - TDF_Label aLabel; - if (theContext.IsEmpty()) { - if(_current.IsNull()) { - _errorCode = "InvalidContext"; - return aResultSeq; - } + std::vector aResultSeq; + DF_Label aLabel; + if (theContext.empty()) { aLabel = _current; } else { - TDF_Label aTmp = _current; + DF_Label aTmp = _current; SetContext(theContext); aLabel = _current; _current = aTmp; } - TDF_ChildIterator anIter(aLabel, Standard_False); // iterate all subchildren at all sublevels - for(; anIter.More(); anIter.Next()) { - TDF_Label aLabel = anIter.Value(); - Handle(SALOMEDSImpl_AttributeName) aName; - if (aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID(), aName)) aResultSeq->Append(aName->Value()); + if (aLabel.IsNull()) { + _errorCode = "InvalidContext"; + return aResultSeq; + } + + DF_ChildIterator anIter (aLabel, true); // iterate all subchildren at all sublevels + for (; anIter.More(); anIter.Next()) { + DF_Label aLabel = anIter.Value(); + SALOMEDSImpl_AttributeName* aName; + if ((aName=(SALOMEDSImpl_AttributeName*)aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) + aResultSeq.push_back(aName->Value()); } return aResultSeq; @@ -603,34 +585,35 @@ Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetObjectNames(const * Purpose : method to get all directory names in the given context (or in the current context, if 'theContext' is empty) */ //============================================================================ -Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetDirectoryNames(const TCollection_AsciiString& theContext) +std::vector SALOMEDSImpl_Study::GetDirectoryNames(const std::string& theContext) { _errorCode = ""; - Handle(TColStd_HSequenceOfAsciiString) aResultSeq = new TColStd_HSequenceOfAsciiString; - TDF_Label aLabel; - if (theContext.IsEmpty()) { - if(_current.IsNull()) { - _errorCode = "InvalidContext"; - return aResultSeq; - } + std::vector aResultSeq; + DF_Label aLabel; + if (theContext.empty()) { aLabel = _current; } else { - TDF_Label aTmp = _current; + DF_Label aTmp = _current; SetContext(theContext); aLabel = _current; _current = aTmp; } - TDF_ChildIterator anIter(aLabel, Standard_False); // iterate first-level children at all sublevels - for(; anIter.More(); anIter.Next()) { - TDF_Label aLabel = anIter.Value(); - Handle(SALOMEDSImpl_AttributeLocalID) anID; - if (aLabel.FindAttribute(SALOMEDSImpl_AttributeLocalID::GetID(), anID)) { + if (aLabel.IsNull()) { + _errorCode = "InvalidContext"; + return aResultSeq; + } + + DF_ChildIterator anIter (aLabel, true); // iterate first-level children at all sublevels + for (; anIter.More(); anIter.Next()) { + DF_Label aLabel = anIter.Value(); + SALOMEDSImpl_AttributeLocalID* anID; + if ((anID=(SALOMEDSImpl_AttributeLocalID*)aLabel.FindAttribute(SALOMEDSImpl_AttributeLocalID::GetID()))) { if (anID->Value() == DIRECTORYID) { - Handle(SALOMEDSImpl_AttributeName) aName; - if (aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID(), aName)) { - aResultSeq->Append(aName->Value()); - } + SALOMEDSImpl_AttributeName* aName; + if ((aName=(SALOMEDSImpl_AttributeName*)aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) { + aResultSeq.push_back(aName->Value()); + } } } } @@ -643,36 +626,37 @@ Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetDirectoryNames(con * Purpose : method to get all file names in the given context (or in the current context, if 'theContext' is empty) */ //============================================================================ -Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetFileNames(const TCollection_AsciiString& theContext) +std::vector SALOMEDSImpl_Study::GetFileNames(const std::string& theContext) { _errorCode = ""; - Handle(TColStd_HSequenceOfAsciiString) aResultSeq = new TColStd_HSequenceOfAsciiString; - TDF_Label aLabel; - if (theContext.IsEmpty()) { - if(_current.IsNull()) { - _errorCode = "InvalidContext"; - return aResultSeq; - } + std::vector aResultSeq; + DF_Label aLabel; + if (theContext.empty()) { aLabel = _current; } else { - TDF_Label aTmp = _current; + DF_Label aTmp = _current; SetContext(theContext); aLabel = _current; _current = aTmp; } - TDF_ChildIterator anIter(aLabel, Standard_False); // iterate all subchildren at all sublevels - for(; anIter.More(); anIter.Next()) { - TDF_Label aLabel = anIter.Value(); - Handle(SALOMEDSImpl_AttributeLocalID) anID; - if (aLabel.FindAttribute(SALOMEDSImpl_AttributeLocalID::GetID(), anID)) { + if (aLabel.IsNull()) { + _errorCode = "InvalidContext"; + return aResultSeq; + } + + DF_ChildIterator anIter (aLabel, true); // iterate all subchildren at all sublevels + for (; anIter.More(); anIter.Next()) { + DF_Label aLabel = anIter.Value(); + SALOMEDSImpl_AttributeLocalID* anID; + if ((anID=(SALOMEDSImpl_AttributeLocalID*)aLabel.FindAttribute(SALOMEDSImpl_AttributeLocalID::GetID()))) { if (anID->Value() == FILELOCALID) { - Handle(SALOMEDSImpl_AttributePersistentRef) aName; - if(aLabel.FindAttribute(SALOMEDSImpl_AttributePersistentRef::GetID(), aName)) { - TCollection_ExtendedString aFileName = aName->Value(); - if(aFileName.Length() > 0) - aResultSeq->Append(aFileName.Split(strlen(FILEID))); - } + SALOMEDSImpl_AttributePersistentRef* aName; + if ((aName=(SALOMEDSImpl_AttributePersistentRef*)aLabel.FindAttribute(SALOMEDSImpl_AttributePersistentRef::GetID()))) { + std::string aFileName = aName->Value(); + if (aFileName.size() > 0) + aResultSeq.push_back(aFileName.substr(strlen(FILEID), aFileName.size())); + } } } } @@ -685,16 +669,17 @@ Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetFileNames(const TC * Purpose : method to get all components names */ //============================================================================ -Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetComponentNames(const TCollection_AsciiString& theContext) +std::vector SALOMEDSImpl_Study::GetComponentNames(const std::string& theContext) { _errorCode = ""; - Handle(TColStd_HSequenceOfAsciiString) aResultSeq = new TColStd_HSequenceOfAsciiString; - TDF_ChildIterator anIter(_doc->Main(), Standard_False); // iterate all subchildren at first level + std::vector aResultSeq; + DF_ChildIterator anIter(_doc->Main(), false); // iterate all subchildren at first level for(; anIter.More(); anIter.Next()) { - TDF_Label aLabel = anIter.Value(); - Handle(SALOMEDSImpl_AttributeName) aName; - if (aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID(), aName)) aResultSeq->Append(aName->Value()); + DF_Label aLabel = anIter.Value(); + SALOMEDSImpl_AttributeName* aName; + if ((aName=(SALOMEDSImpl_AttributeName*)aLabel.FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) + aResultSeq.push_back(aName->Value()); } return aResultSeq; @@ -705,10 +690,10 @@ Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetComponentNames(con * Purpose : Create a ChildIterator from an SObject */ //============================================================================ -Handle(SALOMEDSImpl_ChildIterator) SALOMEDSImpl_Study::NewChildIterator(const Handle(SALOMEDSImpl_SObject)& aSO) +SALOMEDSImpl_ChildIterator SALOMEDSImpl_Study::NewChildIterator(const SALOMEDSImpl_SObject& aSO) { _errorCode = ""; - return new SALOMEDSImpl_ChildIterator(aSO); + return SALOMEDSImpl_ChildIterator(aSO); } @@ -729,7 +714,7 @@ SALOMEDSImpl_SComponentIterator SALOMEDSImpl_Study::NewComponentIterator() * Purpose : Create a StudyBuilder */ //============================================================================ -Handle(SALOMEDSImpl_StudyBuilder) SALOMEDSImpl_Study::NewBuilder() +SALOMEDSImpl_StudyBuilder* SALOMEDSImpl_Study::NewBuilder() { _errorCode = ""; if(_autoFill) { @@ -745,7 +730,7 @@ Handle(SALOMEDSImpl_StudyBuilder) SALOMEDSImpl_Study::NewBuilder() * Purpose : get study name */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::Name() +std::string SALOMEDSImpl_Study::Name() { _errorCode = ""; return _name; @@ -756,7 +741,7 @@ TCollection_AsciiString SALOMEDSImpl_Study::Name() * Purpose : set study name */ //============================================================================ -void SALOMEDSImpl_Study::Name(const TCollection_AsciiString& name) +void SALOMEDSImpl_Study::Name(const std::string& name) { _errorCode = ""; _name = name; @@ -782,7 +767,7 @@ void SALOMEDSImpl_Study::IsSaved(bool save) { _errorCode = ""; _Saved = save; - if(save) _doc->UnModify(); + if(save) _doc->SetModified(false); } //============================================================================ @@ -795,7 +780,7 @@ bool SALOMEDSImpl_Study::IsModified() _errorCode = ""; // True if is modified - if (_doc->IsModified()) return true; + if (_doc && _doc->IsModified()) return true; return false; } @@ -805,7 +790,7 @@ bool SALOMEDSImpl_Study::IsModified() * Purpose : get URL of the study (persistent reference of the study) */ //============================================================================ -TCollection_AsciiString SALOMEDSImpl_Study::URL() +std::string SALOMEDSImpl_Study::URL() { _errorCode = ""; return _URL; @@ -816,13 +801,13 @@ TCollection_AsciiString SALOMEDSImpl_Study::URL() * Purpose : set URL of the study (persistent reference of the study) */ //============================================================================ -void SALOMEDSImpl_Study::URL(const TCollection_AsciiString& url) +void SALOMEDSImpl_Study::URL(const std::string& url) { _errorCode = ""; _URL = url; /*jfa: Now name of SALOMEDS study will correspond to name of SalomeApp study - TCollection_AsciiString tmp(_URL); + std::string tmp(_URL); char *aName = (char*)tmp.ToCString(); char *adr = strtok(aName, "/"); @@ -841,32 +826,32 @@ void SALOMEDSImpl_Study::URL(const TCollection_AsciiString& url) * Purpose : Find an Object with SALOMEDSImpl_Name = anObjectName */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::_FindObject(const Handle(SALOMEDSImpl_SObject)& SO, - const TCollection_AsciiString& theObjectName, - bool& _find) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::_FindObject(const SALOMEDSImpl_SObject& SO, + const std::string& theObjectName, + bool& _find) { - if(SO.IsNull()) return NULL; + SALOMEDSImpl_SObject RefSO; + if(!SO) return RefSO; // Iterate on each objects and subobjects of the component // If objectName find, stop the loop and get the object reference - Handle(SALOMEDSImpl_SObject) RefSO; - Handle(SALOMEDSImpl_AttributeName) anAttr; + SALOMEDSImpl_AttributeName* anAttr; - TCollection_AsciiString soid = SO->GetID(); - TDF_ChildIterator it(SO->GetLabel()); + std::string soid = SO.GetID(); + DF_ChildIterator it(SO.GetLabel()); for (; it.More(); it.Next()){ if(!_find) { - if (it.Value().FindAttribute(SALOMEDSImpl_AttributeName::GetID(), anAttr)) - { - TCollection_AsciiString Val(anAttr->Value()); - if (Val == theObjectName) - { - RefSO = GetSObject(it.Value()); - _find = true; - } - } - if (!_find) RefSO = _FindObject(GetSObject(it.Value()), theObjectName, _find); + if ((anAttr=(SALOMEDSImpl_AttributeName*)it.Value().FindAttribute(SALOMEDSImpl_AttributeName::GetID()))) + { + std::string Val(anAttr->Value()); + if (Val == theObjectName) + { + RefSO = GetSObject(it.Value()); + _find = true; + } + } + if (!_find) RefSO = _FindObject(GetSObject(it.Value()), theObjectName, _find); } } return RefSO; @@ -877,38 +862,93 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::_FindObject(const Handle(SALOME * Purpose : Find an Object with SALOMEDSImpl_IOR = anObjectIOR */ //============================================================================ -Handle(SALOMEDSImpl_SObject) -SALOMEDSImpl_Study::_FindObjectIOR(const Handle(SALOMEDSImpl_SObject)& SO, - const TCollection_AsciiString& theObjectIOR, - bool& _find) +SALOMEDSImpl_SObject +SALOMEDSImpl_Study::_FindObjectIOR(const SALOMEDSImpl_SObject& SO, + const std::string& theObjectIOR, + bool& _find) { - if(SO.IsNull()) return NULL; + SALOMEDSImpl_SObject RefSO, aSO; + if(!SO) return RefSO; // Iterate on each objects and subobjects of the component // If objectName find, stop the loop and get the object reference - Handle(SALOMEDSImpl_SObject) RefSO, aSO; - Handle(SALOMEDSImpl_AttributeIOR) anAttr; + SALOMEDSImpl_AttributeIOR* anAttr; - TDF_ChildIterator it(SO->GetLabel()); + DF_ChildIterator it(SO.GetLabel()); for (; it.More();it.Next()){ if(!_find) { - if (it.Value().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID(), anAttr)) - { - TCollection_AsciiString Val(anAttr->Value()); - if (Val == theObjectIOR) - { - RefSO = GetSObject(it.Value()); - _find = true; - } - } - aSO = GetSObject(it.Value()); - if (!_find) RefSO = _FindObjectIOR(aSO, theObjectIOR, _find); + if ((anAttr=(SALOMEDSImpl_AttributeIOR*)it.Value().FindAttribute(SALOMEDSImpl_AttributeIOR::GetID()))) + { + std::string Val(anAttr->Value()); + if (Val == theObjectIOR) + { + RefSO = GetSObject(it.Value()); + _find = true; + } + } + aSO = GetSObject(it.Value()); + if (!_find) RefSO = _FindObjectIOR(aSO, theObjectIOR, _find); } } return RefSO; } +//============================================================================ +/*! Function : _GetNoteBookAccessor + * Purpose : Find an Object with SALOMEDSImpl_IOR = anObjectIOR + */ +//============================================================================ +std::string SALOMEDSImpl_Study::_GetNoteBookAccessor(){ + return std::string("notebook"); +} + +//============================================================================ +/*! Function : _GetStudyVariablesScript + * Purpose : + */ +//============================================================================ +std::string SALOMEDSImpl_Study::_GetStudyVariablesScript() +{ + std::string dump(""); + + if(myNoteBookVars.empty()) + return dump; + + Kernel_Utils::Localizer loc; + + dump += "####################################################\n"; + dump += "## Begin of NoteBook variables section ##\n"; + dump += "####################################################\n"; + + std::string set_method = _GetNoteBookAccessor()+".set("; + std::string varName; + std::string varValue; + for(int i = 0 ; i < myNoteBookVars.size();i++ ) { + varName = myNoteBookVars[i]->Name(); + varValue = myNoteBookVars[i]->SaveToScript(); + dump+=set_method+"\""+varName+"\", "+varValue+")\n"; + } + + dump += "####################################################\n"; + dump += "## End of NoteBook variables section ##\n"; + dump += "####################################################\n"; + + return dump; +} + +//============================================================================ +/*! Function : _GetNoteBookAccess + * Purpose : + */ +//============================================================================ +std::string SALOMEDSImpl_Study::_GetNoteBookAccess(const std::string& theStudyVar) +{ + std::string notebook = "import salome_notebook\n"; + notebook += _GetNoteBookAccessor() + " = salome_notebook.NoteBook(" + theStudyVar + ")" ; + return notebook; +} + bool SALOMEDSImpl_Study::IsLocked() { _errorCode = ""; @@ -927,51 +967,58 @@ void SALOMEDSImpl_Study::StudyId(int id) _StudyId = id; } -void SALOMEDSImpl_Study::UpdateIORLabelMap(const TCollection_AsciiString& anIOR,const TCollection_AsciiString& anEntry) +void SALOMEDSImpl_Study::UpdateIORLabelMap(const std::string& anIOR,const std::string& anEntry) { _errorCode = ""; - TDF_Label aLabel; - char* anEn = (char*)anEntry.ToCString(); - char* IOR = (char*)anIOR.ToCString(); - TDF_Tool::Label(_doc->GetData(),anEn, aLabel, Standard_True); - if (myIORLabels.IsBound(TCollection_ExtendedString(IOR))) myIORLabels.UnBind(TCollection_ExtendedString(IOR)); - myIORLabels.Bind(TCollection_ExtendedString(IOR), aLabel); + DF_Label aLabel = DF_Label::Label(_doc->Main(), anEntry, true); + std::map::iterator it=myIORLabels.find(anIOR); + if (it != myIORLabels.end()) myIORLabels.erase(it); + myIORLabels[anIOR] = aLabel; +} + +void SALOMEDSImpl_Study::DeleteIORLabelMapItem(const std::string& anIOR) +{ + std::map::iterator it=myIORLabels.find(anIOR); + if (it != myIORLabels.end()) + { + //remove the ior entry and decref the genericobj (if it's one) + myIORLabels.erase(it); + } } -Handle(SALOMEDSImpl_Study) SALOMEDSImpl_Study::GetStudy(const TDF_Label& theLabel) +SALOMEDSImpl_Study* SALOMEDSImpl_Study::GetStudy(const DF_Label& theLabel) { - Handle(SALOMEDSImpl_StudyHandle) Att; - if (theLabel.Root().FindAttribute(SALOMEDSImpl_StudyHandle::GetID(),Att)) { - return Att->GetHandle(); + SALOMEDSImpl_StudyHandle* Att; + if ((Att=(SALOMEDSImpl_StudyHandle*)theLabel.Root().FindAttribute(SALOMEDSImpl_StudyHandle::GetID()))) { + return Att->Get(); } return NULL; } -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::SObject(const TDF_Label& theLabel) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::SObject(const DF_Label& theLabel) { return GetStudy(theLabel)->GetSObject(theLabel); } -Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::SComponent(const TDF_Label& theLabel) +SALOMEDSImpl_SComponent SALOMEDSImpl_Study::SComponent(const DF_Label& theLabel) { return GetStudy(theLabel)->GetSComponent(theLabel); } -void SALOMEDSImpl_Study::IORUpdated(const Handle(SALOMEDSImpl_AttributeIOR)& theAttribute) +void SALOMEDSImpl_Study::IORUpdated(const SALOMEDSImpl_AttributeIOR* theAttribute) { - TCollection_AsciiString aString; - TDF_Tool::Entry(theAttribute->Label(), aString); + std::string aString = theAttribute->Label().Entry(); GetStudy(theAttribute->Label())->UpdateIORLabelMap(theAttribute->Value(), aString); } -Handle(TColStd_HSequenceOfTransient) SALOMEDSImpl_Study::FindDependances(const Handle(SALOMEDSImpl_SObject)& anObject) +std::vector SALOMEDSImpl_Study::FindDependances(const SALOMEDSImpl_SObject& anObject) { _errorCode = ""; - Handle(TColStd_HSequenceOfTransient) aSeq; + std::vector aSeq; - Handle(SALOMEDSImpl_AttributeTarget) aTarget; - if (anObject->GetLabel().FindAttribute(SALOMEDSImpl_AttributeTarget::GetID(), aTarget)) { + SALOMEDSImpl_AttributeTarget* aTarget; + if ((aTarget=(SALOMEDSImpl_AttributeTarget*)anObject.GetLabel().FindAttribute(SALOMEDSImpl_AttributeTarget::GetID()))) { return aTarget->Get(); } @@ -979,48 +1026,48 @@ Handle(TColStd_HSequenceOfTransient) SALOMEDSImpl_Study::FindDependances(const H } -Handle(SALOMEDSImpl_AttributeStudyProperties) SALOMEDSImpl_Study::GetProperties() +SALOMEDSImpl_AttributeStudyProperties* SALOMEDSImpl_Study::GetProperties() { _errorCode = ""; return SALOMEDSImpl_AttributeStudyProperties::Set(_doc->Main()); } -TCollection_AsciiString SALOMEDSImpl_Study::GetLastModificationDate() +std::string SALOMEDSImpl_Study::GetLastModificationDate() { _errorCode = ""; - Handle(SALOMEDSImpl_AttributeStudyProperties) aProp = GetProperties(); + SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties(); - Handle(TColStd_HSequenceOfExtendedString) aNames; - Handle(TColStd_HSequenceOfInteger) aMinutes, aHours, aDays, aMonths, aYears; + std::vector aNames; + std::vector aMinutes, aHours, aDays, aMonths, aYears; aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears); - int aLastIndex = aNames->Length(); + int aLastIndex = aNames.size()-1; char aResult[20]; sprintf(aResult, "%2.2d/%2.2d/%4.4d %2.2d:%2.2d", - (int)(aDays->Value(aLastIndex)),(int)(aMonths->Value(aLastIndex)), (int)(aYears->Value(aLastIndex)), - (int)(aHours->Value(aLastIndex)), (int)(aMinutes->Value(aLastIndex))); - TCollection_AsciiString aResStr (aResult); + (int)(aDays[aLastIndex]),(int)(aMonths[aLastIndex]), (int)(aYears[aLastIndex]), + (int)(aHours[aLastIndex]), (int)(aMinutes[aLastIndex])); + std::string aResStr (aResult); return aResStr; } -Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetModificationsDate() +std::vector SALOMEDSImpl_Study::GetModificationsDate() { _errorCode = ""; - Handle(SALOMEDSImpl_AttributeStudyProperties) aProp = GetProperties(); + SALOMEDSImpl_AttributeStudyProperties* aProp = GetProperties(); - Handle(TColStd_HSequenceOfExtendedString) aNames; - Handle(TColStd_HSequenceOfInteger) aMinutes, aHours, aDays, aMonths, aYears; + std::vector aNames; + std::vector aMinutes, aHours, aDays, aMonths, aYears; aProp->GetModifications(aNames, aMinutes, aHours, aDays, aMonths, aYears); - int anIndex, aLength = aNames->Length(); - Handle(TColStd_HSequenceOfAsciiString) aDates = new TColStd_HSequenceOfAsciiString; + int anIndex, aLength = aNames.size(); + std::vector aDates; - for (anIndex = 2; anIndex <= aLength; anIndex++) { + for (anIndex = 1; anIndex < aLength; anIndex++) { char aDate[20]; sprintf(aDate, "%2.2d/%2.2d/%4.4d %2.2d:%2.2d", - (int)(aDays->Value(anIndex)), (int)(aMonths->Value(anIndex)), (int)(aYears->Value(anIndex)), - (int)(aHours->Value(anIndex)), (int)(aMinutes->Value(anIndex))); - aDates->Append(aDate); + (int)(aDays[anIndex]), (int)(aMonths[anIndex]), (int)(aYears[anIndex]), + (int)(aHours[anIndex]), (int)(aMinutes[anIndex])); + aDates.push_back(aDate); } return aDates; } @@ -1032,7 +1079,7 @@ Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::GetModificationsDate( * Purpose : Returns a UseCase builder */ //============================================================================ -Handle(SALOMEDSImpl_UseCaseBuilder) SALOMEDSImpl_Study::GetUseCaseBuilder() +SALOMEDSImpl_UseCaseBuilder* SALOMEDSImpl_Study::GetUseCaseBuilder() { _errorCode = ""; return _useCaseBuilder; @@ -1047,117 +1094,11 @@ Handle(SALOMEDSImpl_UseCaseBuilder) SALOMEDSImpl_Study::GetUseCaseBuilder() void SALOMEDSImpl_Study::Close() { _errorCode = ""; - Handle(TDocStd_Application) anApp = Handle(TDocStd_Application)::DownCast(_doc->Application()); - if(!anApp.IsNull()) anApp->Close(_doc); - _doc.Nullify(); - _mapOfSO.Clear(); - _mapOfSCO.Clear(); -} - -//============================================================================ -/*! Function : AddPostponed - * Purpose : - */ - //============================================================================ -void SALOMEDSImpl_Study::AddPostponed(const TCollection_AsciiString& theIOR) -{ - _errorCode = ""; - if (!NewBuilder()->HasOpenCommand()) return; - TCollection_AsciiString anIOR(theIOR); - anIOR.Prepend("d"); - myPostponedIORs.Append(anIOR); // add prefix: deleted - myNbPostponed.SetValue(myNbPostponed.Length(), myNbPostponed.Last() + 1); -} - -//============================================================================ -/*! Function : AddCreatedPostponed - * Purpose : - */ - //============================================================================ -void SALOMEDSImpl_Study::AddCreatedPostponed(const TCollection_AsciiString& theIOR) -{ - _errorCode = ""; - if (!NewBuilder()->HasOpenCommand()) return; - TCollection_AsciiString anIOR(theIOR); - anIOR.Prepend("c"); - myPostponedIORs.Append(anIOR); // add prefix: created - myNbPostponed.SetValue(myNbPostponed.Length(), myNbPostponed.Last() + 1); -} - -//============================================================================ -/*! Function : RemovePostponed - * Purpose : - */ -//============================================================================ -Handle(TColStd_HSequenceOfAsciiString) SALOMEDSImpl_Study::RemovePostponed(const int theUndoLimit) -{ - _errorCode = ""; - - int anIndex; - int anOld; - - int aUndoLimit = theUndoLimit; - if (theUndoLimit < 0) aUndoLimit = 0; - - Handle(TColStd_HSequenceOfAsciiString) aSeq = new TColStd_HSequenceOfAsciiString; - - if (myNbUndos > 0) { // remove undone - anOld = 0; - for(anIndex = 1; anIndex < myNbPostponed.Length() - myNbUndos; anIndex++) - anOld += myNbPostponed(anIndex); - int aNew = myPostponedIORs.Length() - myNbPostponed.Last(); - - for(anIndex = anOld + 1; anIndex <= aNew; anIndex++) { - TCollection_AsciiString anIOR = myPostponedIORs(anIndex); - if (anIOR.Value(1) == 'c') { - aSeq->Append(anIOR.Split(1).ToCString()); - } - } - if (anOld < aNew) myPostponedIORs.Remove(anOld + 1, aNew); - if (myNbPostponed.Length() > 0) myNbPostponed.Remove(myNbPostponed.Length() - myNbUndos, myNbPostponed.Length() - 1); - - myNbUndos = 0; - } - - if (myNbPostponed.Length() > aUndoLimit) { // remove objects, that can not be undone - anOld = 0; - for(anIndex = myNbPostponed.Length() - aUndoLimit; anIndex >= 1; anIndex--) - anOld += myNbPostponed(anIndex); - for(anIndex = 1; anIndex <= anOld; anIndex++) { - TCollection_AsciiString anIOR = myPostponedIORs(anIndex); - if (anIOR.Value(1) == 'd') { - aSeq->Append(anIOR.Split(1).ToCString()); - } - } - if (anOld > 0) myPostponedIORs.Remove(1, anOld); - myNbPostponed.Remove(1, myNbPostponed.Length() - aUndoLimit); - } - - if (theUndoLimit == -1) { // remove all IORs from the study on the study close - TDF_ChildIDIterator anIter(_doc->GetData()->Root(), SALOMEDSImpl_AttributeIOR::GetID(), Standard_True); - for(; anIter.More(); anIter.Next()) { - Handle(SALOMEDSImpl_AttributeIOR) anAttr = Handle(SALOMEDSImpl_AttributeIOR)::DownCast(anIter.Value()); - aSeq->Append(anAttr->Value()); - } - } else myNbPostponed.Append(0); - - return aSeq; -} - -//============================================================================ -/*! Function : UndoPostponed - * Purpose : - */ -//============================================================================ -void SALOMEDSImpl_Study::UndoPostponed(const int theWay) -{ - _errorCode = ""; - - myNbUndos += theWay; - // remove current postponed - if (myNbPostponed.Last() > 0) - myPostponedIORs.Remove(myPostponedIORs.Length() - myNbPostponed.Last() + 1, myPostponedIORs.Length()); - myNbPostponed(myNbPostponed.Length()) = 0; + _notifier = 0; + _doc->GetApplication()->Close(_doc); + _doc = NULL; + _mapOfSO.clear(); + _mapOfSCO.clear(); } @@ -1166,16 +1107,15 @@ void SALOMEDSImpl_Study::UndoPostponed(const int theWay) * Purpose : */ //============================================================================ -Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::GetSComponent(const TCollection_AsciiString& theEntry) +SALOMEDSImpl_SComponent SALOMEDSImpl_Study::GetSComponent(const std::string& theEntry) { - Handle(SALOMEDSImpl_SComponent) aSCO; - if(_mapOfSCO.IsBound(theEntry)) - aSCO = Handle(SALOMEDSImpl_SComponent)::DownCast(_mapOfSCO.Find(theEntry)); + SALOMEDSImpl_SComponent aSCO; + if(_mapOfSCO.find(theEntry) != _mapOfSCO.end()) + aSCO = _mapOfSCO[theEntry]; else { - TDF_Label aLabel; - TDF_Tool::Label(_doc->GetData(), theEntry, aLabel); - aSCO = new SALOMEDSImpl_SComponent(aLabel); - _mapOfSCO.Bind(theEntry, aSCO); + DF_Label aLabel = DF_Label::Label(_doc->Main(), theEntry); + aSCO = SALOMEDSImpl_SComponent(aLabel); + _mapOfSCO[theEntry] = aSCO; } return aSCO; @@ -1186,11 +1126,9 @@ Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::GetSComponent(const TCollect * Purpose : */ //============================================================================ -Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::GetSComponent(const TDF_Label& theLabel) +SALOMEDSImpl_SComponent SALOMEDSImpl_Study::GetSComponent(const DF_Label& theLabel) { - TCollection_AsciiString anEntry; - TDF_Tool::Entry(theLabel, anEntry); - return GetSComponent(anEntry); + return SALOMEDSImpl_SComponent(theLabel); } //============================================================================ @@ -1198,16 +1136,16 @@ Handle(SALOMEDSImpl_SComponent) SALOMEDSImpl_Study::GetSComponent(const TDF_Labe * Purpose : */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::GetSObject(const TCollection_AsciiString& theEntry) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::GetSObject(const std::string& theEntry) { - Handle(SALOMEDSImpl_SObject) aSO; - if(_mapOfSO.IsBound(theEntry)) - aSO = Handle(SALOMEDSImpl_SObject)::DownCast(_mapOfSO.Find(theEntry)); + SALOMEDSImpl_SObject aSO; + std::map::iterator it=_mapOfSO.find(theEntry); + if(it != _mapOfSO.end()) + aSO = it->second; else { - TDF_Label aLabel; - TDF_Tool::Label(_doc->GetData(), theEntry, aLabel); - aSO = new SALOMEDSImpl_SObject(aLabel); - _mapOfSO.Bind(theEntry, aSO); + DF_Label aLabel = DF_Label::Label(_doc->Main(), theEntry); + aSO = SALOMEDSImpl_SObject(aLabel); + _mapOfSO[theEntry] = aSO; } return aSO; @@ -1218,11 +1156,9 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::GetSObject(const TCollection_As * Purpose : */ //============================================================================ -Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::GetSObject(const TDF_Label& theLabel) +SALOMEDSImpl_SObject SALOMEDSImpl_Study::GetSObject(const DF_Label& theLabel) { - TCollection_AsciiString anEntry; - TDF_Tool::Entry(theLabel, anEntry); - return GetSObject(anEntry); + return SALOMEDSImpl_SObject(theLabel); } //============================================================================ @@ -1230,24 +1166,50 @@ Handle(SALOMEDSImpl_SObject) SALOMEDSImpl_Study::GetSObject(const TDF_Label& the * Purpose : */ //============================================================================ -Handle(TDF_Attribute) SALOMEDSImpl_Study::GetAttribute(const TCollection_AsciiString& theEntry, - const TCollection_AsciiString& theType) +DF_Attribute* SALOMEDSImpl_Study::GetAttribute(const std::string& theEntry, + const std::string& theType) { - Handle(SALOMEDSImpl_SObject) aSO = GetSObject(theEntry); - Handle(TDF_Attribute) anAttr; - aSO->FindAttribute(anAttr, theType); + SALOMEDSImpl_SObject aSO = GetSObject(theEntry); + DF_Attribute* anAttr; + aSO.FindAttribute(anAttr, theType); return anAttr; } +//! number of spaces for indentation in Python dump files (to replace \t symbols) +static const int indent_size = 2; + +static std::string replace_tabs( const std::string& in ) +{ + std::string out = in; +#ifdef WITHOUT_TABS + size_t pos = out.find( '\t' ); + while ( pos != std::string::npos ) { + out.replace( pos, 1, indent_size, ' ' ); + pos = out.find( '\t' ); + } +#endif + return out; +} + +static std::string GetComponentHeader(const char* theComponentName) +{ + std::stringstream txt; + txt << "###" << std::endl; + txt << "### " << theComponentName << " component" << std::endl; + txt << "###" << std::endl; + return txt.str(); +} + //============================================================================ /*! Function : DumpStudy * Purpose : */ //============================================================================ -bool SALOMEDSImpl_Study::DumpStudy(const TCollection_AsciiString& thePath, - const TCollection_AsciiString& theBaseName, - bool isPublished, - SALOMEDSImpl_DriverFactory* theFactory) +bool SALOMEDSImpl_Study::DumpStudy(const std::string& thePath, + const std::string& theBaseName, + bool isPublished, + bool isMultiFile, + SALOMEDSImpl_DriverFactory* theFactory) { _errorCode = ""; @@ -1256,33 +1218,52 @@ bool SALOMEDSImpl_Study::DumpStudy(const TCollection_AsciiString& thePath, return false; } - TColStd_SequenceOfExtendedString aSeq; - TCollection_AsciiString aCompType, aFactoryType; + std::vector aSeq; + std::string aCompType, aFactoryType; //Build a list of all components in the Study SALOMEDSImpl_SComponentIterator itcomponent = NewComponentIterator(); for (; itcomponent.More(); itcomponent.Next()) { - Handle(SALOMEDSImpl_SComponent) sco = itcomponent.Value(); - aCompType = sco->ComponentDataType(); - //GEOM and MED are independent components - if (aCompType == "GEOM" || aCompType == "MED") - aSeq.Prepend(TCollection_ExtendedString(aCompType)); + SALOMEDSImpl_SComponent sco = itcomponent.Value(); + aCompType = sco.ComponentDataType(); + if (aCompType == "GEOM") + aSeq.insert(aSeq.begin(), aCompType); else - aSeq.Append(TCollection_ExtendedString(aCompType)); + aSeq.push_back(aCompType); + } + // re-arrange modules in the sequence, if specific order is given via SALOME_MODULES_ORDER environment variable. + if ( getenv("SALOME_MODULES_ORDER") != 0 ) { + std::string order = getenv("SALOME_MODULES_ORDER"); + std::vector mlist; + while ( !order.empty() ) { + size_t idx = order.find( "," ); + std::string m = order.substr(0, idx); + order = order.substr( ( idx == std::string::npos ) ? order.size() : idx+1 ); + if ( m.empty() || std::find( mlist.begin(), mlist.end(), m ) != mlist.end() ) continue; + mlist.push_back( m ); + } + + for ( std::vector::reverse_iterator mit = mlist.rbegin(); mit != mlist.rend(); ++mit ) { + std::vector::iterator it = std::find( aSeq.begin(), aSeq.end(), *mit ); + if ( it != aSeq.end() ) { + aSeq.erase( it ); + aSeq.insert( aSeq.begin(), *mit ); + } + } } #ifdef WIN32 - TCollection_AsciiString aFileName = - thePath + TCollection_AsciiString("\\") + theBaseName + TCollection_AsciiString(".py"); + std::string aFileName = + thePath + std::string("\\") + theBaseName + std::string(".py"); #else - TCollection_AsciiString aFileName = - thePath + TCollection_AsciiString("/") + theBaseName + TCollection_AsciiString(".py"); + std::string aFileName = + thePath + std::string("/") + theBaseName + std::string(".py"); #endif //Create a file that will contain a main Study script - fstream fp; - fp.open(aFileName.ToCString(), ios::out); + std::fstream fp; + fp.open(aFileName.c_str(), std::ios::out); #ifdef WIN32 bool isOpened = fp.is_open(); @@ -1291,64 +1272,80 @@ bool SALOMEDSImpl_Study::DumpStudy(const TCollection_AsciiString& thePath, #endif if(!isOpened) { - _errorCode = TCollection_AsciiString("Can't create a file ")+aFileName; + _errorCode = std::string("Can't create a file ")+aFileName; return false; } - TCollection_AsciiString aBatchModeScript = "salome"; + std::stringstream sfp; + + std::string aBatchModeScript = "salome"; //Output to the main Study script required Python modules import, //set sys.path and add a creation of the study. - fp << GetDumpStudyComment().ToCString() << endl << endl; - fp << "import sys" << endl; - fp << "import " << aBatchModeScript << endl << endl; - fp << aBatchModeScript << ".salome_init()" << endl << endl; + // dump header + sfp << GetDumpStudyComment() << std::endl; - fp << "sys.path.insert( 0, \'" << thePath << "\')" << endl << endl; + // global imports + sfp << "import sys" << std::endl; + sfp << "import " << aBatchModeScript << std::endl << std::endl; + std::string aStudyVar = "salome.myStudy"; + // initialization function + sfp << aBatchModeScript << ".salome_init()" << std::endl; + if ( !isMultiFile ) { + sfp << "theStudy = " << aStudyVar << std::endl << std::endl; + aStudyVar = "theStudy"; + } + // notebook initialization + sfp << _GetNoteBookAccess(aStudyVar) << std::endl; - //Check if it's necessary to dump visual parameters + // extend sys.path with the directory where the script is being dumped to + sfp << "sys.path.insert( 0, r\'" << thePath << "\')" << std::endl << std::endl; + + // dump NoteBook variables + sfp << _GetStudyVariablesScript(); + + // dump visual parameters if necessary bool isDumpVisuals = SALOMEDSImpl_IParameters::isDumpPython(this); int lastSavePoint = -1; if(isDumpVisuals) { lastSavePoint = SALOMEDSImpl_IParameters::getLastSavePoint(this); if(lastSavePoint > 0) { - fp << SALOMEDSImpl_IParameters::getStudyScript(this, lastSavePoint) << endl << endl; + sfp << SALOMEDSImpl_IParameters::getStudyScript(this, lastSavePoint) << std::endl << std::endl; } } - - Handle(TColStd_HSequenceOfAsciiString) aSeqOfFileNames = new TColStd_HSequenceOfAsciiString; + std::vector aSeqOfFileNames; - //Iterate all components and create the componponents specific scripts. + // dump all components and create the components specific scripts bool isOk = true; - int aLength = aSeq.Length(); + int aLength = aSeq.size(); for(int i = 1; i <= aLength; i++) { - aCompType = aSeq.Value(i); - Handle(SALOMEDSImpl_SComponent) sco = FindComponent(aCompType); + aCompType = aSeq[i-1]; + SALOMEDSImpl_SComponent sco = FindComponent(aCompType); SALOMEDSImpl_Driver* aDriver = NULL; // if there is an associated Engine call its method for saving - TCollection_AsciiString IOREngine; + std::string IOREngine; try { - if (!sco->ComponentIOR(IOREngine)) { - if (!aCompType.IsEmpty()) { - - aDriver = theFactory->GetDriverByType(aCompType); - - if (aDriver != NULL) { - Handle(SALOMEDSImpl_StudyBuilder) SB = NewBuilder(); - if(!SB->LoadWith(sco, aDriver)) { - _errorCode = SB->GetErrorCode(); - return false; - } - } - else continue; - } + if (!sco.ComponentIOR(IOREngine)) { + if (!aCompType.empty()) { + + aDriver = theFactory->GetDriverByType(aCompType); + + if (aDriver != NULL) { + SALOMEDSImpl_StudyBuilder* SB = NewBuilder(); + if(!SB->LoadWith(sco, aDriver)) { + _errorCode = SB->GetErrorCode(); + return false; + } + } + else continue; + } } else { - aDriver = theFactory->GetDriverByIOR(IOREngine); + aDriver = theFactory->GetDriverByIOR(IOREngine); } } catch(...) { _errorCode = "Can not restore information to dump it"; @@ -1359,58 +1356,77 @@ bool SALOMEDSImpl_Study::DumpStudy(const TCollection_AsciiString& thePath, bool isValidScript; long aStreamLength = 0; - Handle(SALOMEDSImpl_TMPFile) aStream = aDriver->DumpPython(this, isPublished, isValidScript, aStreamLength); + SALOMEDSImpl_TMPFile* aStream = aDriver->DumpPython(this, isPublished, isMultiFile, isValidScript, aStreamLength); if ( !isValidScript ) isOk = false; - //Create a file that will contain the component specific script - fstream fp2; + std::stringstream sfp2; + + //Output the Python script generated by the component in the newly created file. + if ( isMultiFile ) + sfp2 << GetDumpStudyComment( aCompType.c_str() ) << std::endl; + else + sfp2 << GetComponentHeader( aCompType.c_str() ) << std::endl; + sfp2 << aStream->Data(); + + if ( isMultiFile ) { + //Create a file that will contain the component specific script + std::fstream fp2; #ifdef WIN32 - aFileName=thePath+TCollection_AsciiString("\\"); + aFileName=thePath+std::string("\\"); #else - aFileName=thePath+TCollection_AsciiString("/"); + aFileName=thePath+std::string("/"); #endif - TCollection_AsciiString aScriptName; - aScriptName += theBaseName; - aScriptName += "_"; - aScriptName += aCompType; - - aFileName += aScriptName+ TCollection_AsciiString(".py"); - aSeqOfFileNames->Append(aFileName); - - fp2.open(aFileName.ToCString(), ios::out); - + std::string aScriptName; + aScriptName += theBaseName; + aScriptName += "_"; + aScriptName += aCompType; + + aFileName += aScriptName+ std::string(".py"); + aSeqOfFileNames.push_back(aFileName); + + fp2.open(aFileName.c_str(), std::ios::out); + #ifdef WIN32 - isOpened = fp2.is_open(); + isOpened = fp2.is_open(); #else - isOpened = fp2.rdbuf()->is_open(); + isOpened = fp2.rdbuf()->is_open(); #endif + + if(!isOpened) { + _errorCode = std::string("Can't create a file ")+aFileName; + SALOMEDSImpl_Tool::RemoveTemporaryFiles(thePath, aSeqOfFileNames, false); + return false; + } + + // replace '\t' symbols + fp2 << replace_tabs( sfp2.str() ); - if(!isOpened) { - _errorCode = TCollection_AsciiString("Can't create a file ")+aFileName; - SALOMEDSImpl_Tool::RemoveTemporaryFiles(thePath, aSeqOfFileNames, false); - return false; - } + fp2.close(); - //Output the Python script generated by the component in the newly created file. - fp2 << aStream->Data(); - fp2.close(); + //Add to the main script a call to RebuildData of the generated by the component the Python script + sfp << "import " << aScriptName << std::endl; + sfp << aScriptName << ".RebuildData(" << aBatchModeScript << ".myStudy)" << std::endl; + } + else + sfp << sfp2.str(); - //Add to the main script a call to RebuildData of the generated by the component the Python script - fp << "import " << aScriptName << endl; - fp << aScriptName << ".RebuildData(" << aBatchModeScript << ".myStudy)" << endl; + if(aStream) delete aStream; } - fp << endl; - fp << "if salome.sg.hasDesktop():" << endl; - fp << "\tsalome.sg.updateObjBrowser(1)" << endl; + sfp << std::endl; + sfp << "if salome.sg.hasDesktop():" << std::endl; + sfp << "\tsalome.sg.updateObjBrowser(True)" << std::endl; if(isDumpVisuals) { //Output the call to Session's method restoreVisualState - fp << "\tiparameters.getSession().restoreVisualState(1)" << endl; + sfp << "\tiparameters.getSession().restoreVisualState(1)" << std::endl; } - + // replace '\t' symbols + fp << replace_tabs( sfp.str() ); + fp.close(); + return isOk; } @@ -1419,29 +1435,36 @@ bool SALOMEDSImpl_Study::DumpStudy(const TCollection_AsciiString& thePath, //purpose : return a header comment for a DumpStudy script //======================================================================= -TCollection_AsciiString SALOMEDSImpl_Study::GetDumpStudyComment(const char* theComponentName) +std::string SALOMEDSImpl_Study::GetDumpStudyComment(const char* theComponentName) { - TCollection_AsciiString txt - ("### This file is generated by SALOME automatically by dump python functionality"); + std::stringstream txt; + txt << "# -*- coding: utf-8 -*-" << std::endl << std::endl; + txt << "###" << std::endl; + txt << "### This file is generated automatically by SALOME v" + << KERNEL_VERSION_STR + << " with dump python functionality"; if ( theComponentName ) - txt += TCollection_AsciiString(" of ") + (char*) theComponentName + " component"; - return txt; + txt << " (" << theComponentName << " component)"; + txt << std::endl; + txt << "###" << std::endl; + return txt.str(); } -void dumpSO(const Handle(SALOMEDSImpl_SObject)& theSO, - fstream& fp, - const TCollection_AsciiString& Tab, - const Handle(SALOMEDSImpl_Study) theStudy); +void dumpSO(const SALOMEDSImpl_SObject& theSO, + std::fstream& fp, + const std::string& Tab, + SALOMEDSImpl_Study* theStudy); + //============================================================================ /*! Function : dump * Purpose : */ //============================================================================ -void SALOMEDSImpl_Study::dump(const TCollection_AsciiString& theFileName) +void SALOMEDSImpl_Study::dump(const std::string& theFileName) { //Create a file that will contain a main Study script - fstream fp; - fp.open(theFileName.ToCString(), ios::out); + std::fstream fp; + fp.open(theFileName.c_str(), std::ios::out); #ifdef WIN32 bool isOpened = fp.is_open(); @@ -1450,65 +1473,64 @@ void SALOMEDSImpl_Study::dump(const TCollection_AsciiString& theFileName) #endif if(!isOpened) { - _errorCode = TCollection_AsciiString("Can't create a file ")+theFileName; - cout << "### SALOMEDSImpl_Study::dump Error: " << _errorCode << endl; + _errorCode = std::string("Can't create a file ")+theFileName; + std::cout << "### SALOMEDSImpl_Study::dump Error: " << _errorCode << std::endl; return; } - Handle(SALOMEDSImpl_SObject) aSO = FindObjectID("0:1"); - fp << "0:1" << endl; - Handle(SALOMEDSImpl_ChildIterator) Itr = NewChildIterator(aSO); - TCollection_AsciiString aTab(" "); - for(; Itr->More(); Itr->Next()) { - dumpSO(Itr->Value(), fp, aTab, this); + SALOMEDSImpl_SObject aSO = FindObjectID("0:1"); + fp << "0:1" << std::endl; + SALOMEDSImpl_ChildIterator Itr = NewChildIterator(aSO); + std::string aTab(" "); + for(; Itr.More(); Itr.Next()) { + dumpSO(Itr.Value(), fp, aTab, this); } fp.close(); } -void dumpSO(const Handle(SALOMEDSImpl_SObject)& theSO, - fstream& fp, - const TCollection_AsciiString& Tab, - const Handle(SALOMEDSImpl_Study) theStudy) +void dumpSO(const SALOMEDSImpl_SObject& theSO, + std::fstream& fp, + const std::string& Tab, + SALOMEDSImpl_Study* theStudy) { - TCollection_AsciiString aTab(Tab), anID(theSO->GetID()); - fp << aTab << anID << endl; - TDF_AttributeIterator anItr(theSO->GetLabel()); - for(; anItr.More(); anItr.Next()) { - Handle(SALOMEDSImpl_GenericAttribute) anAttr = Handle(SALOMEDSImpl_GenericAttribute)::DownCast(anItr.Value()); + std::string aTab(Tab), anID(theSO.GetID()); + fp << aTab << anID << std::endl; + std::vector attribs = theSO.GetLabel().GetAttributes(); + for(int i = 0; i(attribs[i]); - if(anAttr.IsNull()) { - fp << Tab << " -- " << anItr.Value()->DynamicType(); + if(!anAttr) { continue; } - TCollection_AsciiString aType = anAttr->GetClassType(); + std::string aType = anAttr->GetClassType(); fp << Tab << " -- " << aType; - if(aType == "AttributeReal") { - fp << " : " << Handle(SALOMEDSImpl_AttributeReal)::DownCast(anAttr)->Value(); + if(aType == std::string("AttributeReal")) { + fp << " : " << dynamic_cast(anAttr)->Value(); } - else if(aType == "AttributeInteger") { - fp << " : " << Handle(SALOMEDSImpl_AttributeInteger)::DownCast(anAttr)->Value(); + else if(aType == std::string("AttributeInteger")) { + fp << " : " << dynamic_cast(anAttr)->Value(); } - else if(aType == "AttributeName") { - fp << " : " << Handle(SALOMEDSImpl_AttributeName)::DownCast(anAttr)->Value(); + else if(aType == std::string("AttributeName")) { + fp << " : " << dynamic_cast(anAttr)->Value(); } - else if(aType == "AttributeComment") { - fp << " : " << Handle(SALOMEDSImpl_AttributeComment)::DownCast(anAttr)->Value(); + else if(aType == std::string("AttributeComment")) { + fp << " : " << dynamic_cast(anAttr)->Value(); } - else if(aType == "AttributeReference") { - fp << " : " << Handle(SALOMEDSImpl_AttributeReference)::DownCast(anAttr)->Save(); + else if(aType == std::string("AttributeReference")) { + fp << " : " << dynamic_cast(anAttr)->Save(); } - fp << endl; + fp << std::endl; } - Handle(SALOMEDSImpl_ChildIterator) Itr = theStudy->NewChildIterator(theSO); - TCollection_AsciiString aNewTab(" "); + SALOMEDSImpl_ChildIterator Itr = theStudy->NewChildIterator(theSO); + std::string aNewTab(" "); aNewTab+=aTab; - for(; Itr->More(); Itr->Next()) { - dumpSO(Itr->Value(), fp, aNewTab, theStudy); + for(; Itr.More(); Itr.Next()) { + dumpSO(Itr.Value(), fp, aNewTab, theStudy); } return; @@ -1517,57 +1539,629 @@ void dumpSO(const Handle(SALOMEDSImpl_SObject)& theSO, void SALOMEDSImpl_Study::Modify() { _errorCode = ""; - _doc->Modify(); + _doc->SetModified(true); } //============================================================================ -/*! Function : +/*! Function : * Purpose : */ //============================================================================ -Handle(SALOMEDSImpl_AttributeParameter) SALOMEDSImpl_Study::GetCommonParameters(const char* theID, int theSavePoint) +SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_Study::GetCommonParameters(const char* theID, int theSavePoint) { - if(theSavePoint < 0) return NULL; - Handle(SALOMEDSImpl_StudyBuilder) builder = NewBuilder(); - Handle(SALOMEDSImpl_SObject) so = FindComponent((char*)theID); - if(so.IsNull()) so = builder->NewComponent((char*)theID); - Handle(SALOMEDSImpl_SObject) newSO; - if(theSavePoint == 0) //Get an attribute that is placed on the component itself. - newSO = so; - else - newSO = builder->NewObjectToTag(so, theSavePoint); - return Handle(SALOMEDSImpl_AttributeParameter)::DownCast(builder->FindOrCreateAttribute(newSO, "AttributeParameter")); + if (theSavePoint < -1) return NULL; + SALOMEDSImpl_StudyBuilder* builder = NewBuilder(); + SALOMEDSImpl_SObject so = FindComponent((char*)theID); + if (!so) so = builder->NewComponent((char*)theID); + SALOMEDSImpl_AttributeParameter* attParam = NULL; + + if (theSavePoint == -1) { + int ctag = 1; + DF_Label savePointLabel = so.GetLabel().FindChild( ctag, /*create=*/0 ); + DF_Label prevPointLabel; + while ( !savePointLabel.IsNull() ) { + ctag++; + prevPointLabel = savePointLabel; + savePointLabel = so.GetLabel().FindChild( ctag, /*create=*/0 ); + } + if ( !prevPointLabel.IsNull() ) + so = GetSObject( prevPointLabel ); + } + if (theSavePoint > 0) { // Try to find SObject that contains attribute parameter ... + DF_Label savePointLabel = so.GetLabel().FindChild( theSavePoint, /*create=*/0 ); + if ( !savePointLabel.IsNull() ) + so = GetSObject( savePointLabel ); + else // ... if it does not exist - create a new one + so = builder->NewObjectToTag( so, theSavePoint ); + } + + DF_Attribute* A; + if (so) { + builder->FindAttribute(so, A, "AttributeParameter"); + if ( !A ) { // first call of GetCommonParameters on "Interface Applicative" component + A = builder->FindOrCreateAttribute(so, "AttributeParameter"); + } + attParam = dynamic_cast( A ); + } + return attParam; } //============================================================================ -/*! Function : +/*! Function : * Purpose : */ //============================================================================ -Handle(SALOMEDSImpl_AttributeParameter) SALOMEDSImpl_Study::GetModuleParameters(const char* theID, - const char* theModuleName, - int theSavePoint) +SALOMEDSImpl_AttributeParameter* SALOMEDSImpl_Study::GetModuleParameters(const char* theID, + const char* theModuleName, + int theSavePoint) { - if(theSavePoint <= 0) return NULL; - Handle(SALOMEDSImpl_AttributeParameter) main_ap = GetCommonParameters(theID, theSavePoint); - Handle(SALOMEDSImpl_SObject) main_so = main_ap->GetSObject(); - Handle(SALOMEDSImpl_AttributeParameter) par; - - Handle(SALOMEDSImpl_ChildIterator) it = NewChildIterator(main_so); - string moduleName(theModuleName); - for(; it->More(); it->Next()) { - Handle(SALOMEDSImpl_SObject) so(it->Value()); - Handle(SALOMEDSImpl_GenericAttribute) ga; - if(so->FindAttribute(ga, "AttributeParameter")) { - par = Handle(SALOMEDSImpl_AttributeParameter)::DownCast(ga); + if(theSavePoint < -1) return NULL; + SALOMEDSImpl_AttributeParameter* main_ap = GetCommonParameters(theID, theSavePoint); + SALOMEDSImpl_SObject main_so = main_ap->GetSObject(); + SALOMEDSImpl_AttributeParameter* par = NULL; + + SALOMEDSImpl_ChildIterator it = NewChildIterator(main_so); + std::string moduleName(theModuleName); + for(; it.More(); it.Next()) { + SALOMEDSImpl_SObject so(it.Value()); + if((par=(SALOMEDSImpl_AttributeParameter*)so.GetLabel().FindAttribute(SALOMEDSImpl_AttributeParameter::GetID()))) { if(!par->IsSet("AP_MODULE_NAME", (Parameter_Types)3)) continue; //3 -> PT_STRING if(par->GetString("AP_MODULE_NAME") == moduleName) return par; } } - Handle(SALOMEDSImpl_StudyBuilder) builder = NewBuilder(); - Handle(SALOMEDSImpl_SObject) so = builder->NewObject(main_so); - par = Handle(SALOMEDSImpl_AttributeParameter)::DownCast(builder->FindOrCreateAttribute(so, "AttributeParameter")); + SALOMEDSImpl_StudyBuilder* builder = NewBuilder(); + SALOMEDSImpl_SObject so = builder->NewObject(main_so); + par = dynamic_cast(builder->FindOrCreateAttribute(so, "AttributeParameter")); par->SetString("AP_MODULE_NAME", moduleName); return par; } + +//============================================================================ +/*! Function : SetStudyLock + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::SetStudyLock(const char* theLockerID) +{ + _lockers.push_back(theLockerID); +} + +//============================================================================ +/*! Function : IsStudyLocked + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::IsStudyLocked() +{ + return (_lockers.size() > 0); +} + +//============================================================================ +/*! Function : UnLockStudy + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::UnLockStudy(const char* theLockerID) +{ + std::vector::iterator vsI = _lockers.begin(); + int length = _lockers.size(); + bool isFound = false; + std::string id(theLockerID); + for(int i = 0; i SALOMEDSImpl_Study::GetLockerID() +{ + return _lockers; +} + +//============================================================================ +/*! Function : SetVariable + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::SetVariable(const std::string& theVarName, + const double theValue, + const SALOMEDSImpl_GenericVariable::VariableTypes theType) +{ + bool modified = false; + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + + if( aGVar == NULL ) { + + SALOMEDSImpl_ScalarVariable* aSVar = new SALOMEDSImpl_ScalarVariable(theType, theVarName); + + aSVar->setValue(theValue); + myNoteBookVars.push_back(aSVar); + modified = true; + } + else { + if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast(aGVar)) { + modified = aSVar->setValue(theValue) || modified; + modified = aSVar->setType(theType) || modified; + } + } + if(modified) + Modify(); +} + +//============================================================================ +/*! Function : SetStringVariable + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::SetStringVariable(const std::string& theVarName, + const std::string& theValue, + const SALOMEDSImpl_GenericVariable::VariableTypes theType) +{ + bool modified = false; + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + + if( aGVar == NULL ) { + + SALOMEDSImpl_ScalarVariable* aSVar = new SALOMEDSImpl_ScalarVariable(theType, theVarName); + + aSVar->setStringValue(theValue); + myNoteBookVars.push_back(aSVar); + modified = true; + } + else { + if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast(aGVar)) { + modified = aSVar->setStringValue(theValue) || modified; + modified = aSVar->setType(theType) || modified; + } + } + if(modified) + Modify(); +} + +//============================================================================ +/*! Function : SetStringVariableAsDouble + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::SetStringVariableAsDouble(const std::string& theVarName, + const double theValue, + const SALOMEDSImpl_GenericVariable::VariableTypes theType) +{ + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast(aGVar)) + aSVar->setValue(theValue); +} + +//============================================================================ +/*! Function : GetReal + * Purpose : + */ +//============================================================================ +double SALOMEDSImpl_Study::GetVariableValue(const std::string& theVarName) +{ + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + + if(aGVar != NULL ) + if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast(aGVar)) + return aSVar->getValue(); + + return 0; +} + +//============================================================================ +/*! Function : GetString + * Purpose : + */ +//============================================================================ +std::string SALOMEDSImpl_Study::GetStringVariableValue(const std::string& theVarName) +{ + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + + if(aGVar != NULL ) + if(SALOMEDSImpl_ScalarVariable* aSVar = dynamic_cast(aGVar)) + return aSVar->getStringValue(); + + return 0; +} + +//============================================================================ +/*! Function : IsTypeOf + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::IsTypeOf(const std::string& theVarName, + SALOMEDSImpl_GenericVariable:: + VariableTypes theType) const +{ + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + + if(aGVar != NULL ) + return aGVar->Type() == theType; + + return false; +} + +//============================================================================ +/*! Function : IsVariable + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::IsVariable(const std::string& theVarName) const +{ + SALOMEDSImpl_GenericVariable* aGVar = GetVariable(theVarName); + return (aGVar != NULL); +} + +//============================================================================ +/*! Function : GetVariableNames + * Purpose : + */ +//============================================================================ +std::vector SALOMEDSImpl_Study::GetVariableNames() const +{ + std::vector aResult; + + for(int i = 0; i < myNoteBookVars.size(); i++) + aResult.push_back(myNoteBookVars[i]->Name()); + + return aResult; +} + +//============================================================================ +/*! Function : AddVariable + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::AddVariable(SALOMEDSImpl_GenericVariable* theVariable) +{ + myNoteBookVars.push_back(theVariable); +} + +//============================================================================ +/*! Function : AddVariable + * Purpose : + */ +//============================================================================ +SALOMEDSImpl_GenericVariable* SALOMEDSImpl_Study::GetVariable(const std::string& theName) const +{ + SALOMEDSImpl_GenericVariable* aResult = NULL; + for(int i = 0; i < myNoteBookVars.size();i++) { + if(theName.compare(myNoteBookVars[i]->Name()) == 0) { + aResult = myNoteBookVars[i]; + break; + } + } + return aResult; +} + +//============================================================================ +/*! Function : RemoveVariable + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::RemoveVariable(const std::string& theVarName) +{ + SALOMEDSImpl_GenericVariable* aVariable = GetVariable( theVarName ); + if( !aVariable ) + return false; + + std::string aValue = aVariable->SaveToScript(); + ReplaceVariableAttribute( theVarName, aValue ); + + std::vector::iterator it = myNoteBookVars.begin(), itEnd = myNoteBookVars.end(); + for( ; it != itEnd; it++ ) + { + SALOMEDSImpl_GenericVariable* aVariableRef = *it; + if( aVariableRef && theVarName.compare( aVariableRef->Name() ) == 0 ) + { + myNoteBookVars.erase( it ); + Modify(); + break; + } + } + + return true; +} + +//============================================================================ +/*! Function : RenameVariable + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::RenameVariable(const std::string& theVarName, const std::string& theNewVarName) +{ + SALOMEDSImpl_GenericVariable* aVariable = GetVariable( theVarName ); + if( !aVariable ) + return false; + + ReplaceVariableAttribute( theVarName, theNewVarName ); + + std::vector::iterator it = myNoteBookVars.begin(), itEnd = myNoteBookVars.end(); + for( ; it != itEnd; it++ ) + { + SALOMEDSImpl_GenericVariable* aVariableRef = *it; + if( aVariableRef && theVarName.compare( aVariableRef->Name() ) == 0 ) + { + aVariableRef->setName( theNewVarName ); + Modify(); + break; + } + } + + return true; +} + +//============================================================================ +/*! Function : IsVariableUsed + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::IsVariableUsed(const std::string& theVarName) +{ + return FindVariableAttribute( theVarName ); +} + +//============================================================================ +/*! Function : FindVariableAttribute + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::FindVariableAttribute(SALOMEDSImpl_StudyBuilder* theStudyBuilder, + SALOMEDSImpl_SObject theSObject, + const std::string& theName) +{ + SALOMEDSImpl_ChildIterator anIter = NewChildIterator( theSObject ); + for( ; anIter.More(); anIter.Next() ) + if( FindVariableAttribute( theStudyBuilder, anIter.Value(), theName ) ) + return true; + + DF_Attribute* anAttr; + if( theStudyBuilder->FindAttribute( theSObject, anAttr, "AttributeString" ) ) + { + if( SALOMEDSImpl_AttributeString* aStringAttr = ( SALOMEDSImpl_AttributeString* )anAttr ) + { + std::string aString = aStringAttr->Value(); + + std::vector< std::vector > aSections = ParseVariables( aString ); + for( int i = 0, n = aSections.size(); i < n; i++ ) + { + std::vector aVector = aSections[i]; + for( int j = 0, m = aVector.size(); j < m; j++ ) + { + std::string aStr = aVector[j]; + if( aStr.compare( theName ) == 0 ) + return true; + } + } + } + } + return false; +} + +//============================================================================ +/*! Function : FindVariableAttribute + * Purpose : + */ +//============================================================================ +bool SALOMEDSImpl_Study::FindVariableAttribute(const std::string& theName) +{ + SALOMEDSImpl_StudyBuilder* aStudyBuilder = NewBuilder(); + SALOMEDSImpl_SComponentIterator aCompIter = NewComponentIterator(); + for( ; aCompIter.More(); aCompIter.Next() ) + { + SALOMEDSImpl_SObject aComp = aCompIter.Value(); + if( FindVariableAttribute( aStudyBuilder, aComp, theName ) ) + return true; + } + return false; +} + +//============================================================================ +/*! Function : ReplaceVariableAttribute + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::ReplaceVariableAttribute(SALOMEDSImpl_StudyBuilder* theStudyBuilder, + SALOMEDSImpl_SObject theSObject, + const std::string& theSource, + const std::string& theDest) +{ + SALOMEDSImpl_ChildIterator anIter = NewChildIterator( theSObject ); + for( ; anIter.More(); anIter.Next() ) + ReplaceVariableAttribute( theStudyBuilder, anIter.Value(), theSource, theDest ); + + DF_Attribute* anAttr; + if( theStudyBuilder->FindAttribute( theSObject, anAttr, "AttributeString" ) ) + { + if( SALOMEDSImpl_AttributeString* aStringAttr = ( SALOMEDSImpl_AttributeString* )anAttr ) + { + bool isChanged = false; + std::string aNewString, aCurrentString = aStringAttr->Value(); + + std::vector< std::vector > aSections = ParseVariables( aCurrentString ); + for( int i = 0, n = aSections.size(); i < n; i++ ) + { + std::vector aVector = aSections[i]; + for( int j = 0, m = aVector.size(); j < m; j++ ) + { + std::string aStr = aVector[j]; + if( aStr.compare( theSource ) == 0 ) + { + isChanged = true; + aStr = theDest; + } + + aNewString.append( aStr ); + if( j != m - 1 ) + aNewString.append( ":" ); + } + if( i != n - 1 ) + aNewString.append( "|" ); + } + + if( isChanged ) + aStringAttr->SetValue( aNewString ); + } + } +} + +//============================================================================ +/*! Function : ReplaceVariableAttribute + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::ReplaceVariableAttribute(const std::string& theSource, const std::string& theDest) +{ + SALOMEDSImpl_StudyBuilder* aStudyBuilder = NewBuilder(); + SALOMEDSImpl_SComponentIterator aCompIter = NewComponentIterator(); + for( ; aCompIter.More(); aCompIter.Next() ) + { + SALOMEDSImpl_SObject aComp = aCompIter.Value(); + ReplaceVariableAttribute( aStudyBuilder, aComp, theSource, theDest ); + } +} + +//============================================================================ +/*! Function : ParseVariables + * Purpose : + */ +//============================================================================ +std::vector< std::vector< std::string > > SALOMEDSImpl_Study::ParseVariables(const std::string& theVariables) const +{ + return SALOMEDSImpl_Tool::splitStringWithEmpty( theVariables, OPERATION_SEPARATOR, VARIABLE_SEPARATOR ); +} + +//============================================================================ +/*! Function : EnableUseCaseAutoFilling + * Purpose : + */ +//============================================================================ +void SALOMEDSImpl_Study::EnableUseCaseAutoFilling(bool isEnabled) +{ + _errorCode = ""; _autoFill = isEnabled; + if(isEnabled) { + _builder->SetOnAddSObject(_cb); + _builder->SetOnRemoveSObject(_cb); + } + else { + _builder->SetOnAddSObject(NULL); + _builder->SetOnRemoveSObject(NULL); + } +} + +//============================================================================ +/*! Function : GetIORs + * Purpose : + */ +//============================================================================ +std::vector SALOMEDSImpl_Study::GetIORs() +{ + std::vector anIORs; + std::map::const_iterator MI; + for(MI = myIORLabels.begin(); MI!=myIORLabels.end(); MI++) + anIORs.push_back(MI->first); + + return anIORs; +} + +//============================================================================ +/*! Function : addSO_Notification + * Purpose : This function tells all the observers that a SO has been added + */ +//============================================================================ +bool SALOMEDSImpl_Study::addSO_Notification (const SALOMEDSImpl_SObject& theSObject) +{ + if(_notifier) + return _notifier->addSO_Notification(theSObject); + else + return false; +} + +//============================================================================ +/*! Function : removeSO_Notification + * Purpose : This function tells all the observers that a SO has been removed + */ +//============================================================================ +bool SALOMEDSImpl_Study::removeSO_Notification (const SALOMEDSImpl_SObject& theSObject) +{ + if(_notifier) + return _notifier->removeSO_Notification(theSObject); + else + return false; +} + +//============================================================================ +/*! Function : modifySO_Notification + * Purpose : This function tells all the observers that a SO has been modified and + pass the mofification reason + */ +//============================================================================ +bool SALOMEDSImpl_Study::modifySO_Notification (const SALOMEDSImpl_SObject& theSObject, int reason) +{ + if(_notifier) + return _notifier->modifySO_Notification(theSObject, reason); + else + return false; +} + +//============================================================================ +/*! Function : setNotifier + * Purpose : register a notifier + */ +//============================================================================ +void SALOMEDSImpl_Study::setNotifier(SALOMEDSImpl_AbstractCallback* notifier) +{ + _notifier=notifier; +} + +static SALOMEDSImpl_AbstractCallback* & getGenObjRegister( DF_Document* doc ) +{ + static std::vector< SALOMEDSImpl_AbstractCallback* > _genObjRegVec; + if ( doc->GetDocumentID() >= (int)_genObjRegVec.size() ) + _genObjRegVec.resize( doc->GetDocumentID() + 1, 0 ); + return _genObjRegVec[ doc->GetDocumentID() ]; +} + +//================================================================================ +/*! + * \brief Stores theRegister + */ +//================================================================================ + +void SALOMEDSImpl_Study::setGenObjRegister(SALOMEDSImpl_AbstractCallback* theRegister) +{ + getGenObjRegister( _doc ) = theRegister; +} + +//================================================================================ +/*! + * \brief Indirectly invokes GenericObj_i::Register() + */ +//================================================================================ + +void SALOMEDSImpl_Study::RegisterGenObj (const std::string& theIOR, DF_Label label) +{ + if ( SALOMEDSImpl_AbstractCallback* goRegister = getGenObjRegister( label.GetDocument() )) + goRegister->RegisterGenObj( theIOR ); +} + +//================================================================================ +/*! + * \brief Indirectly invokes GenericObj_i::UnRegister() + */ +//================================================================================ + +void SALOMEDSImpl_Study::UnRegisterGenObj(const std::string& theIOR, DF_Label label) +{ + if ( SALOMEDSImpl_AbstractCallback* goRegister = getGenObjRegister( label.GetDocument() )) + goRegister->UnRegisterGenObj( theIOR ); +}