X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Data.cpp;h=a863d55dd6a961c44a7277cd50ca3923c512b15f;hb=c3e944ee47c38c2ce7a18eb9fb0f643a4c2dcaf0;hp=2d28604bb0b2cf75fcf9d413484fac9bd7e80275;hpb=27ac635c3e55edc27402ccc1094f5e2de9166400;p=modules%2Fshaper.git diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp index 2d28604bb..a863d55dd 100644 --- a/src/Model/Model_Data.cpp +++ b/src/Model/Model_Data.cpp @@ -1,8 +1,22 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: Model_Data.hxx -// Created: 21 Mar 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// +// 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, 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 +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or +// email : webmaster.salome@opencascade.com +// #include #include @@ -44,6 +58,7 @@ #include #include #include +#include #include #include #include @@ -61,6 +76,9 @@ static const int kFlagInHistory = 0; static const int kFlagDisplayed = 1; // 2 - is deleted (for results) or not static const int kFlagDeleted = 2; +// TDataStd_Integer - 0 if the name of the object is generated automatically, +// otherwise the name is defined by user +Standard_GUID kUSER_DEFINED_NAME("9c694d18-a83c-4a56-bc9b-8020628a8244"); // invalid data const static std::shared_ptr kInvalid(new Model_Data()); @@ -113,24 +131,44 @@ void Model_Data::setName(const std::string& theName) isModified = true; } else { isModified = !aName->Get().IsEqual(theName.c_str()); - if (isModified) + if (isModified) { aName->Set(theName.c_str()); + + // check the name of result is defined by user + // (name of result does not composed of the name of feature and the result index) + bool isUserDefined = true; + ResultPtr aResult = std::dynamic_pointer_cast(myObject); + if (aResult) { + std::string aDefaultName = ModelAPI_Tools::getDefaultName(aResult); + isUserDefined = aDefaultName != theName; + } + if (isUserDefined) { + // name is user-defined, thus special attribute is set + TDataStd_UAttribute::Set(myLab, kUSER_DEFINED_NAME); + } + } } if (mySendAttributeUpdated && isModified) ModelAPI_ObjectRenamedMessage::send(myObject, anOldName, theName, this); if (isModified && myObject && myObject->document()) { std::dynamic_pointer_cast(myObject->document())-> - changeNamingName(anOldName, theName); + changeNamingName(anOldName, theName, myLab); } #ifdef DEBUG_NAMES myObject->myName = theName; #endif } +bool Model_Data::hasUserDefinedName() const +{ + return myLab.IsAttribute(kUSER_DEFINED_NAME); +} + AttributePtr Model_Data::addAttribute(const std::string& theID, const std::string theAttrType) { AttributePtr aResult; - TDF_Label anAttrLab = myLab.FindChild(int(myAttrs.size()) + 1); + int anAttrIndex = int(myAttrs.size()) + 1; + TDF_Label anAttrLab = myLab.FindChild(anAttrIndex); ModelAPI_Attribute* anAttr = 0; if (theAttrType == ModelAPI_AttributeDocRef::typeId()) { anAttr = new Model_AttributeDocRef(anAttrLab); @@ -189,7 +227,7 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin } if (anAttr) { aResult = std::shared_ptr(anAttr); - myAttrs[theID] = aResult; + myAttrs[theID] = std::pair(aResult, anAttrIndex); anAttr->setObject(myObject); anAttr->setID(theID); } else { @@ -203,10 +241,9 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin #define GET_ATTRIBUTE_BY_ID(ATTR_TYPE, METHOD_NAME) \ std::shared_ptr Model_Data::METHOD_NAME(const std::string& theID) { \ std::shared_ptr aRes; \ - std::map::iterator aFound = \ - myAttrs.find(theID); \ + AttributeMap::iterator aFound = myAttrs.find(theID); \ if (aFound != myAttrs.end()) { \ - aRes = std::dynamic_pointer_cast(aFound->second); \ + aRes = std::dynamic_pointer_cast(aFound->second.first); \ } \ return aRes; \ } @@ -232,15 +269,14 @@ std::shared_ptr Model_Data::attribute(const std::string& the std::shared_ptr aResult; if (myAttrs.find(theID) == myAttrs.end()) // no such attribute return aResult; - return myAttrs[theID]; + return myAttrs[theID].first; } const std::string& Model_Data::id(const std::shared_ptr& theAttr) { - std::map >::iterator anAttr = - myAttrs.begin(); + AttributeMap::iterator anAttr = myAttrs.begin(); for (; anAttr != myAttrs.end(); anAttr++) { - if (anAttr->second == theAttr) + if (anAttr->second.first == theAttr) return anAttr->first; } // not found @@ -264,11 +300,11 @@ bool Model_Data::isValid() std::list > Model_Data::attributes(const std::string& theType) { std::list > aResult; - std::map >::iterator anAttrsIter = - myAttrs.begin(); + AttributeMap::iterator anAttrsIter = myAttrs.begin(); for (; anAttrsIter != myAttrs.end(); anAttrsIter++) { - if (theType.empty() || anAttrsIter->second->attributeType() == theType) { - aResult.push_back(anAttrsIter->second); + AttributePtr anAttr = anAttrsIter->second.first; + if (theType.empty() || anAttr->attributeType() == theType) { + aResult.push_back(anAttr); } } return aResult; @@ -277,10 +313,10 @@ std::list > Model_Data::attributes(const std std::list Model_Data::attributesIDs(const std::string& theType) { std::list aResult; - std::map >::iterator anAttrsIter = - myAttrs.begin(); + AttributeMap::iterator anAttrsIter = myAttrs.begin(); for (; anAttrsIter != myAttrs.end(); anAttrsIter++) { - if (theType.empty() || anAttrsIter->second->attributeType() == theType) { + AttributePtr anAttr = anAttrsIter->second.first; + if (theType.empty() || anAttr->attributeType() == theType) { aResult.push_back(anAttrsIter->first); } } @@ -293,7 +329,14 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr) if (theAttr->isArgument()) { if (mySendAttributeUpdated) { if (myObject) { - myObject->attributeChanged(theAttr->id()); + try { + myObject->attributeChanged(theAttr->id()); + } catch(...) { + if (owner().get() && owner()->data().get() && owner()->data()->isValid()) { + Events_InfoMessage("Model_Data", + "%1 has failed during the update").arg(owner()->data()->name()).send(); + } + } static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); } @@ -302,6 +345,12 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr) if (myWasChangedButBlocked.empty() || *(myWasChangedButBlocked.rbegin()) != theAttr) myWasChangedButBlocked.push_back(theAttr); } + } else { + // trim: need to redisplay + if (myObject) { + static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_TO_REDISPLAY); + ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); + } } } @@ -319,7 +368,14 @@ bool Model_Data::blockSendAttributeUpdated(const bool theBlock, const bool theSe myWasChangedButBlocked.clear(); std::list::iterator aChangedIter = aWasChangedButBlocked.begin(); for(; aChangedIter != aWasChangedButBlocked.end(); aChangedIter++) { - myObject->attributeChanged((*aChangedIter)->id()); + try { + myObject->attributeChanged((*aChangedIter)->id()); + } catch(...) { + if (owner().get() && owner()->data().get() && owner()->data()->isValid()) { + Events_InfoMessage("Model_Data", + "%1 has failed during the update").arg(owner()->data()->name()).send(); + } + } } static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); @@ -346,7 +402,7 @@ void Model_Data::erase() if (aReferenced->get() && (*aReferenced)->data()->isValid()) { std::shared_ptr aData = std::dynamic_pointer_cast((*aReferenced)->data()); - aData->removeBackReference(myAttrs[anAttrIter->first]); + aData->removeBackReference(myAttrs[anAttrIter->first].first); } } } @@ -435,9 +491,9 @@ void Model_Data::eraseBackReferences() aRes->setIsConcealed(false); } -void Model_Data::removeBackReference(FeaturePtr theFeature, std::string theAttrID) +void Model_Data::removeBackReference(ObjectPtr theObject, std::string theAttrID) { - AttributePtr anAttribute = theFeature->data()->attribute(theAttrID); + AttributePtr anAttribute = theObject->data()->attribute(theAttrID); removeBackReference(anAttribute); } @@ -459,10 +515,7 @@ void Model_Data::removeBackReference(AttributePtr theAttr) void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, const bool theApplyConcealment) { - // it is possible to add the same attribute twice: may be last time the owner was not Stable... - AttributePtr anAttribute = theFeature->data()->attribute(theAttrID); - if (myRefsToMe.find(anAttribute) == myRefsToMe.end()) - myRefsToMe.insert(theFeature->data()->attribute(theAttrID)); + addBackReference(ObjectPtr(theFeature), theAttrID); if (theApplyConcealment && theFeature->isStable() && ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) { @@ -477,6 +530,14 @@ void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, } } +void Model_Data::addBackReference(ObjectPtr theObject, std::string theAttrID) +{ + // it is possible to add the same attribute twice: may be last time the owner was not Stable... + AttributePtr anAttribute = theObject->data()->attribute(theAttrID); + if (myRefsToMe.find(anAttribute) == myRefsToMe.end()) + myRefsToMe.insert(anAttribute); +} + void Model_Data::updateConcealmentFlag() { std::set::iterator aRefsIter = myRefsToMe.begin(); @@ -528,7 +589,8 @@ std::set usedParameters(const AttributePoint2DPtr& theAttribute) return anUsedParameters; } -std::list findVariables(const std::set& theParameters) +std::list findVariables(const std::set& theParameters, + const DocumentPtr& theDocument) { std::list aResult; std::set::const_iterator aParamIt = theParameters.cbegin(); @@ -538,7 +600,7 @@ std::list findVariables(const std::set& thePara ResultParameterPtr aParam; // theSearcher is not needed here: in expressions // of features the parameters history is not needed - if (ModelAPI_Tools::findVariable(FeaturePtr(), aName, aValue, aParam)) + if (ModelAPI_Tools::findVariable(FeaturePtr(), aName, aValue, aParam, theDocument)) aResult.push_back(aParam); } return aResult; @@ -551,21 +613,22 @@ void Model_Data::referencesToObjects( static_cast(ModelAPI_Session::get()->validators()); FeaturePtr aMyFeature = std::dynamic_pointer_cast(myObject); - std::map >::iterator anAttr = myAttrs.begin(); + AttributeMap::iterator anAttrIt = myAttrs.begin(); std::list aReferenced; // not inside of cycle to avoid excess memory management - for(; anAttr != myAttrs.end(); anAttr++) { + for(; anAttrIt != myAttrs.end(); anAttrIt++) { + AttributePtr anAttr = anAttrIt->second.first; // skip not-case attributes, that really may refer to anything not-used (issue 671) - if (aMyFeature.get() && !aValidators->isCase(aMyFeature, anAttr->second->id())) + if (aMyFeature.get() && !aValidators->isCase(aMyFeature, anAttr->id())) continue; - std::string aType = anAttr->second->attributeType(); + std::string aType = anAttr->attributeType(); if (aType == ModelAPI_AttributeReference::typeId()) { // reference to object std::shared_ptr aRef = std::dynamic_pointer_cast< - ModelAPI_AttributeReference>(anAttr->second); + ModelAPI_AttributeReference>(anAttr); aReferenced.push_back(aRef->value()); } else if (aType == ModelAPI_AttributeRefAttr::typeId()) { // reference to attribute or object std::shared_ptr aRef = std::dynamic_pointer_cast< - ModelAPI_AttributeRefAttr>(anAttr->second); + ModelAPI_AttributeRefAttr>(anAttr); if (aRef->isObject()) { aReferenced.push_back(aRef->object()); } else { @@ -574,20 +637,20 @@ void Model_Data::referencesToObjects( aReferenced.push_back(anAttr->owner()); } } else if (aType == ModelAPI_AttributeRefList::typeId()) { // list of references - aReferenced = std::dynamic_pointer_cast(anAttr->second)->list(); + aReferenced = std::dynamic_pointer_cast(anAttr)->list(); } else if (aType == ModelAPI_AttributeSelection::typeId()) { // selection attribute std::shared_ptr aRef = std::dynamic_pointer_cast< - ModelAPI_AttributeSelection>(anAttr->second); + ModelAPI_AttributeSelection>(anAttr); aReferenced.push_back(aRef->context()); } else if (aType == ModelAPI_AttributeSelectionList::typeId()) { // list of selection attributes std::shared_ptr aRef = std::dynamic_pointer_cast< - ModelAPI_AttributeSelectionList>(anAttr->second); - for(int a = aRef->size() - 1; a >= 0; a--) { + ModelAPI_AttributeSelectionList>(anAttr); + for(int a = 0, aSize = aRef->size(); a < aSize; ++a) { aReferenced.push_back(aRef->value(a)->context()); } } else if (aType == ModelAPI_AttributeRefAttrList::typeId()) { std::shared_ptr aRefAttr = std::dynamic_pointer_cast< - ModelAPI_AttributeRefAttrList>(anAttr->second); + ModelAPI_AttributeRefAttrList>(anAttr); std::list > aRefs = aRefAttr->list(); std::list >::const_iterator anIt = aRefs.begin(), aLast = aRefs.end(); @@ -596,33 +659,38 @@ void Model_Data::referencesToObjects( } } else if (aType == ModelAPI_AttributeInteger::typeId()) { // integer attribute AttributeIntegerPtr anAttribute = - std::dynamic_pointer_cast(anAttr->second); + std::dynamic_pointer_cast(anAttr); std::set anUsedParameters = anAttribute->usedParameters(); - std::list aParameters = findVariables(anUsedParameters); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == ModelAPI_AttributeDouble::typeId()) { // double attribute AttributeDoublePtr anAttribute = - std::dynamic_pointer_cast(anAttr->second); + std::dynamic_pointer_cast(anAttr); std::set anUsedParameters = anAttribute->usedParameters(); - std::list aParameters = findVariables(anUsedParameters); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == GeomDataAPI_Point::typeId()) { // point attribute AttributePointPtr anAttribute = - std::dynamic_pointer_cast(anAttr->second); + std::dynamic_pointer_cast(anAttr); std::set anUsedParameters = usedParameters(anAttribute); - std::list aParameters = findVariables(anUsedParameters); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else if (aType == GeomDataAPI_Point2D::typeId()) { // point attribute AttributePoint2DPtr anAttribute = - std::dynamic_pointer_cast(anAttr->second); + std::dynamic_pointer_cast(anAttr); std::set anUsedParameters = usedParameters(anAttribute); - std::list aParameters = findVariables(anUsedParameters); + std::list aParameters = + findVariables(anUsedParameters, owner()->document()); aReferenced.insert(aReferenced.end(), aParameters.begin(), aParameters.end()); } else continue; // nothing to do, not reference if (!aReferenced.empty()) { - theRefs.push_back(std::pair >(anAttr->first, aReferenced)); + theRefs.push_back( + std::pair >(anAttrIt->first, aReferenced)); aReferenced.clear(); } } @@ -718,3 +786,15 @@ std::shared_ptr Model_Data::owner() { return myObject; } + +bool Model_Data::isPrecedingAttribute(const std::string& theAttribute1, + const std::string& theAttribute2) const +{ + AttributeMap::const_iterator aFound1 = myAttrs.find(theAttribute1); + AttributeMap::const_iterator aFound2 = myAttrs.find(theAttribute2); + if (aFound2 == myAttrs.end()) + return true; + else if (aFound1 == myAttrs.end()) + return false; + return aFound1->second.second < aFound2->second.second; +}