X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Data.cpp;h=d7d14ad8cae6bea66468270675810de020136356;hb=b73fb7468bea81901dbeed8e229d742f788ec282;hp=dd2f8313088c96794083e2653a5e15b656c638d2;hpb=055d3c94f677cdf74eca05711fe9dcae89035d58;p=modules%2Fshaper.git diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp index dd2f83130..d7d14ad8c 100644 --- a/src/Model/Model_Data.cpp +++ b/src/Model/Model_Data.cpp @@ -1,40 +1,67 @@ -// 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 #include #include +#include #include #include #include +#include #include #include +#include #include #include #include +#include #include +#include #include #include +#include #include #include #include +#include +#include + +#include +#include #include #include #include #include -#include +#include #include #include #include +#include #include #include #include +#include #include @@ -46,11 +73,16 @@ static const int kFlagInHistory = 0; // 1 - is displayed or not 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()); -Model_Data::Model_Data() : mySendAttributeUpdated(true) +Model_Data::Model_Data() : mySendAttributeUpdated(true), myWasChangedButBlocked(false) { } @@ -60,17 +92,31 @@ void Model_Data::setLabel(TDF_Label theLab) // set or get the default flags if (!myLab.FindAttribute(TDataStd_BooleanArray::GetID(), myFlags)) { // set default values if not found - myFlags = TDataStd_BooleanArray::Set(myLab, 0, 1); + myFlags = TDataStd_BooleanArray::Set(myLab, 0, 2); myFlags->SetValue(kFlagInHistory, Standard_True); // is in history by default is true myFlags->SetValue(kFlagDisplayed, Standard_True); // is displayed by default is true + myFlags->SetValue(kFlagDeleted, Standard_False); // is deleted by default is false + } else if (myFlags->Length() != 3) { // for old formats support + Standard_Boolean aFlag0 = myFlags->Upper() >= 0 ? myFlags->Value(0) : Standard_True; + Standard_Boolean aFlag1 = myFlags->Upper() >= 1 ? myFlags->Value(1) : Standard_True; + Standard_Boolean aFlag2 = myFlags->Upper() >= 2 ? myFlags->Value(2) : Standard_True; + Handle(TColStd_HArray1OfByte) aNewArray = new TColStd_HArray1OfByte(0, 2); + myFlags->SetInternalArray(aNewArray); + myFlags->SetValue(0, aFlag0); + myFlags->SetValue(1, aFlag1); + myFlags->SetValue(2, aFlag2); } } std::string Model_Data::name() { Handle(TDataStd_Name) aName; - if (myLab.FindAttribute(TDataStd_Name::GetID(), aName)) + if (myLab.FindAttribute(TDataStd_Name::GetID(), aName)) { +#ifdef DEBUG_NAMES + myObject->myName = TCollection_AsciiString(aName->Get()).ToCString(); +#endif return std::string(TCollection_AsciiString(aName->Get()).ToCString()); + } return ""; // not defined } @@ -84,17 +130,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, false).first; + 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, 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(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); @@ -106,6 +179,8 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin anAttr = new Model_AttributeBoolean(anAttrLab); } else if (theAttrType == Model_AttributeString::typeId()) { anAttr = new Model_AttributeString(anAttrLab); + } else if (theAttrType == Model_AttributeStringArray::typeId()) { + anAttr = new Model_AttributeStringArray(anAttrLab); } else if (theAttrType == ModelAPI_AttributeReference::typeId()) { anAttr = new Model_AttributeReference(anAttrLab); } else if (theAttrType == ModelAPI_AttributeSelection::typeId()) { @@ -116,36 +191,58 @@ AttributePtr Model_Data::addAttribute(const std::string& theID, const std::strin anAttr = new Model_AttributeRefAttr(anAttrLab); } else if (theAttrType == ModelAPI_AttributeRefList::typeId()) { anAttr = new Model_AttributeRefList(anAttrLab); + } else if (theAttrType == ModelAPI_AttributeRefAttrList::typeId()) { + anAttr = new Model_AttributeRefAttrList(anAttrLab); } else if (theAttrType == ModelAPI_AttributeIntArray::typeId()) { anAttr = new Model_AttributeIntArray(anAttrLab); - } + } else if (theAttrType == ModelAPI_AttributeDoubleArray::typeId()) { + anAttr = new Model_AttributeDoubleArray(anAttrLab); + } else if (theAttrType == ModelAPI_AttributeTables::typeId()) { + anAttr = new Model_AttributeTables(anAttrLab); + } // create also GeomData attributes here because only here the OCAF structure is known else if (theAttrType == GeomData_Point::typeId()) { - anAttr = new GeomData_Point(anAttrLab); + GeomData_Point* anAttribute = new GeomData_Point(); + bool anAllInitialized = true; + for (int aComponent = 0; aComponent < GeomData_Point::NUM_COMPONENTS; ++aComponent) { + TDF_Label anExpressionLab = anAttrLab.FindChild(aComponent + 1); + anAttribute->myExpression[aComponent].reset(new Model_ExpressionDouble(anExpressionLab)); + anAllInitialized = anAllInitialized && anAttribute->myExpression[aComponent]->isInitialized(); + } + anAttribute->myIsInitialized = anAllInitialized; + anAttr = anAttribute; } else if (theAttrType == GeomData_Dir::typeId()) { anAttr = new GeomData_Dir(anAttrLab); } else if (theAttrType == GeomData_Point2D::typeId()) { - anAttr = new GeomData_Point2D(anAttrLab); + GeomData_Point2D* anAttribute = new GeomData_Point2D(); + bool anAllInitialized = true; + for (int aComponent = 0; aComponent < GeomData_Point2D::NUM_COMPONENTS; ++aComponent) { + TDF_Label anExpressionLab = anAttrLab.FindChild(aComponent + 1); + anAttribute->myExpression[aComponent].reset(new Model_ExpressionDouble(anExpressionLab)); + anAllInitialized = anAllInitialized && anAttribute->myExpression[aComponent]->isInitialized(); + } + anAttribute->myIsInitialized = anAllInitialized; + anAttr = anAttribute; } if (anAttr) { aResult = std::shared_ptr(anAttr); - myAttrs[theID] = aResult; + myAttrs[theID] = std::pair(aResult, anAttrIndex); anAttr->setObject(myObject); anAttr->setID(theID); } else { - Events_Error::send("Can not create unknown type of attribute " + theAttrType); + Events_InfoMessage("Model_Data", + "Can not create unknown type of attribute %1").arg(theAttrType).send(); } return aResult; } -// macro for gthe generic returning of the attribute by the ID +// macro for the generic returning of the attribute by the ID #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; \ } @@ -155,27 +252,30 @@ GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeDouble, real); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeInteger, integer); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeBoolean, boolean); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeString, string); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeStringArray, stringArray); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeReference, reference); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeSelection, selection); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeSelectionList, selectionList); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeRefAttr, refattr); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeRefList, reflist); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeRefAttrList, refattrlist); GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeIntArray, intArray); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeDoubleArray, realArray); +GET_ATTRIBUTE_BY_ID(ModelAPI_AttributeTables, tables); std::shared_ptr Model_Data::attribute(const std::string& theID) { 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 @@ -199,23 +299,23 @@ 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; } -std::list Model_Data::attributesIDs(const std::string& theType) +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); } } @@ -226,23 +326,89 @@ void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr) { theAttr->setInitialized(); if (theAttr->isArgument()) { - static const Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); - ModelAPI_EventCreator::get()->sendUpdated(myObject, anEvent); - if (mySendAttributeUpdated && myObject) { - myObject->attributeChanged(theAttr->id()); + if (mySendAttributeUpdated) { + if (myObject) { + 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); + } + } else { + // to avoid too many duplications do not add the same like the last + 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); } } } -void Model_Data::blockSendAttributeUpdated(const bool theBlock) -{ - mySendAttributeUpdated = !theBlock; +bool Model_Data::blockSendAttributeUpdated(const bool theBlock, const bool theSendMessage) +{ + bool aWasBlocked = !mySendAttributeUpdated; + if (mySendAttributeUpdated == theBlock) { + mySendAttributeUpdated = !theBlock; + if (mySendAttributeUpdated && !myWasChangedButBlocked.empty()) { + // so, now it is ok to send the update signal + if (theSendMessage) { + // make a copy to avoid iteration on modified list + // (may be cleared by attribute changed call) + std::list aWasChangedButBlocked = myWasChangedButBlocked; + myWasChangedButBlocked.clear(); + std::list::iterator aChangedIter = aWasChangedButBlocked.begin(); + for(; aChangedIter != aWasChangedButBlocked.end(); aChangedIter++) { + 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); + } else { + myWasChangedButBlocked.clear(); + } + } + } + return aWasBlocked; } void Model_Data::erase() { - if (!myLab.IsNull()) + if (!myLab.IsNull()) { + if (myLab.HasAttribute()) { + // remove in order to clear back references in other objects + std::list > > aRefs; + referencesToObjects(aRefs); + std::list > >::iterator + anAttrIter = aRefs.begin(); + for(; anAttrIter != aRefs.end(); anAttrIter++) { + std::list::iterator aReferenced = anAttrIter->second.begin(); + for(; aReferenced != anAttrIter->second.end(); aReferenced++) { + if (aReferenced->get() && (*aReferenced)->data()->isValid()) { + std::shared_ptr aData = + std::dynamic_pointer_cast((*aReferenced)->data()); + aData->removeBackReference(myAttrs[anAttrIter->first].first); + } + } + } + } + myAttrs.clear(); myLab.ForgetAllAttributes(); + } } // indexes in the state array @@ -266,7 +432,9 @@ static Handle(TDataStd_IntegerArray) stateArray(TDF_Label& theLab) void Model_Data::execState(const ModelAPI_ExecState theState) { if (theState != ModelAPI_StateNothing) { - stateArray(myLab)->SetValue(STATE_INDEX_STATE, (int)theState); + if (stateArray(myLab)->Value(STATE_INDEX_STATE) != (int)theState) { + stateArray(myLab)->SetValue(STATE_INDEX_STATE, (int)theState); + } } } @@ -289,11 +457,16 @@ void Model_Data::setError(const std::string& theError, bool theSend) { execState(ModelAPI_StateExecFailed); if (theSend) { - Events_Error::send(theError); + Events_InfoMessage("Model_Data", theError).send(); } TDataStd_AsciiString::Set(myLab, theError.c_str()); } +void Model_Data::eraseErrorString() +{ + myLab.ForgetAttribute(TDataStd_AsciiString::GetID()); +} + std::string Model_Data::error() const { Handle(TDataStd_AsciiString) anErrorAttr; @@ -311,39 +484,41 @@ int Model_Data::featureId() const void Model_Data::eraseBackReferences() { myRefsToMe.clear(); - std::shared_ptr aRes = - std::dynamic_pointer_cast(myObject); - if (aRes) + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); + if (aRes) { 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); - if (myRefsToMe.find(anAttribute) == myRefsToMe.end()) + AttributePtr anAttribute = theObject->data()->attribute(theAttrID); + removeBackReference(anAttribute); +} + +void Model_Data::removeBackReference(AttributePtr theAttr) +{ + if (myRefsToMe.find(theAttr) == myRefsToMe.end()) return; - myRefsToMe.erase(anAttribute); + myRefsToMe.erase(theAttr); // remove concealment immideately: on deselection it must be posible to reselect in GUI the same - if (ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) { + FeaturePtr aFeatureOwner = std::dynamic_pointer_cast(theAttr->owner()); + if (aFeatureOwner.get() && + ModelAPI_Session::get()->validators()->isConcealed(aFeatureOwner->getKind(), theAttr->id())) { updateConcealmentFlag(); } } -void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, +void Model_Data::addBackReference(FeaturePtr theFeature, std::string theAttrID, const bool theApplyConcealment) { - // do not add the same attribute twice - AttributePtr anAttribute = theFeature->data()->attribute(theAttrID); - if (myRefsToMe.find(anAttribute) != myRefsToMe.end()) - return; + addBackReference(ObjectPtr(theFeature), theAttrID); - myRefsToMe.insert(theFeature->data()->attribute(theAttrID)); - if (theApplyConcealment && + if (theApplyConcealment && theFeature->isStable() && ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) { - std::shared_ptr aRes = - std::dynamic_pointer_cast(myObject); + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); // the second condition is for history upper than concealment causer, so the feature result may // be displayed and previewed; also for avoiding of quick show/hide on history // moving deep down @@ -353,73 +528,186 @@ 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(); for(; aRefsIter != myRefsToMe.end(); aRefsIter++) { if (aRefsIter->get()) { FeaturePtr aFeature = std::dynamic_pointer_cast((*aRefsIter)->owner()); - if (aFeature.get() && !aFeature->isDisabled()) { + if (aFeature.get() && !aFeature->isDisabled() && aFeature->isStable()) { if (ModelAPI_Session::get()->validators()->isConcealed( aFeature->getKind(), (*aRefsIter)->id())) { - return; // it is still concealed, nothing to do + std::shared_ptr aRes = + std::dynamic_pointer_cast(myObject); + if (aRes.get()) { + aRes->setIsConcealed(true); // set concealed + return; + } } } } } - // thus, no concealment references anymore => make not-concealed - std::shared_ptr aRes = + std::shared_ptr aRes = std::dynamic_pointer_cast(myObject); if (aRes.get()) { aRes->setIsConcealed(false); - static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); - ModelAPI_EventCreator::get()->sendUpdated(aRes, anEvent); - Events_Loop::loop()->flush(anEvent); } } -#include +std::set set_union(const std::set& theLeft, + const std::set& theRight) +{ + std::set aResult; + aResult.insert(theLeft.begin(), theLeft.end()); + aResult.insert(theRight.begin(), theRight.end()); + return aResult; +} + +std::set usedParameters(const AttributePointPtr& theAttribute) +{ + std::set anUsedParameters; + for (int aComponent = 0; aComponent < 3; ++aComponent) + anUsedParameters = set_union(anUsedParameters, theAttribute->usedParameters(aComponent)); + return anUsedParameters; +} + +std::set usedParameters(const AttributePoint2DPtr& theAttribute) +{ + std::set anUsedParameters; + for (int aComponent = 0; aComponent < 2; ++aComponent) + anUsedParameters = set_union(anUsedParameters, theAttribute->usedParameters(aComponent)); + return anUsedParameters; +} + +std::list findVariables(const std::set& theParameters, + const DocumentPtr& theDocument) +{ + std::list aResult; + std::set::const_iterator aParamIt = theParameters.cbegin(); + for (; aParamIt != theParameters.cend(); ++aParamIt) { + const std::string& aName = *aParamIt; + double aValue; + 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, theDocument)) + aResult.push_back(aParam); + } + return aResult; +} void Model_Data::referencesToObjects( std::list > >& theRefs) { - static Model_ValidatorsFactory* aValidators = + static Model_ValidatorsFactory* aValidators = static_cast(ModelAPI_Session::get()->validators()); FeaturePtr aMyFeature = std::dynamic_pointer_cast(myObject); - std::map >::iterator anAttr = myAttrs.begin(); - std::list aReferenced; // not inside of cycle to avoid excess memory menagement - for(; anAttr != myAttrs.end(); anAttr++) { - // skip not-case attributres, that really may refer to anything not-used (issue 671) - if (aMyFeature.get() && !aValidators->isCase(aMyFeature, anAttr->second->id())) + AttributeMap::iterator anAttrIt = myAttrs.begin(); + std::list aReferenced; // not inside of cycle to avoid excess memory management + 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->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); - aReferenced.push_back(aRef->isObject() ? aRef->object() : aRef->attr()->owner()); + ModelAPI_AttributeRefAttr>(anAttr); + if (aRef->isObject()) { + aReferenced.push_back(aRef->object()); + } else { + AttributePtr anAttr = aRef->attr(); + if (anAttr.get()) + aReferenced.push_back(anAttr->owner()); + } } else if (aType == ModelAPI_AttributeRefList::typeId()) { // list of references - aReferenced = std::dynamic_pointer_cast(anAttr->second)->list(); - } else if (aType == ModelAPI_AttributeSelection::typeId()) { // selection attribute + 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); - aReferenced.push_back(aRef->context()); + ModelAPI_AttributeSelection>(anAttr); + FeaturePtr aRefFeat = aRef->contextFeature(); + if (aRefFeat.get()) { // reference to all results of the referenced feature + const std::list& allRes = aRefFeat->results(); + std::list::const_iterator aRefRes = allRes.cbegin(); + for(; aRefRes != allRes.cend(); aRefRes++) { + aReferenced.push_back(*aRefRes); + } + } else { + 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--) { - aReferenced.push_back(aRef->value(a)->context()); + ModelAPI_AttributeSelectionList>(anAttr); + for(int a = 0, aSize = aRef->size(); a < aSize; ++a) { + FeaturePtr aRefFeat = aRef->value(a)->contextFeature(); + if (aRefFeat.get()) { // reference to all results of the referenced feature + const std::list& allRes = aRefFeat->results(); + std::list::const_iterator aRefRes = allRes.cbegin(); + for (; aRefRes != allRes.cend(); aRefRes++) { + aReferenced.push_back(*aRefRes); + } + } else { + aReferenced.push_back(aRef->value(a)->context()); + } } + } else if (aType == ModelAPI_AttributeRefAttrList::typeId()) { + std::shared_ptr aRefAttr = std::dynamic_pointer_cast< + ModelAPI_AttributeRefAttrList>(anAttr); + std::list > aRefs = aRefAttr->list(); + std::list >::const_iterator anIt = aRefs.begin(), + aLast = aRefs.end(); + for (; anIt != aLast; anIt++) { + aReferenced.push_back(anIt->first); + } + } else if (aType == ModelAPI_AttributeInteger::typeId()) { // integer attribute + AttributeIntegerPtr anAttribute = + std::dynamic_pointer_cast(anAttr); + std::set anUsedParameters = anAttribute->usedParameters(); + 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); + std::set anUsedParameters = anAttribute->usedParameters(); + 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); + std::set anUsedParameters = usedParameters(anAttribute); + 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); + std::set anUsedParameters = usedParameters(anAttribute); + 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(); } } @@ -435,7 +723,8 @@ static void copyAttrs(TDF_Label theSource, TDF_Label theDestination) { aTargetAttr = anAttrIter.Value()->NewEmpty(); theDestination.AddAttribute(aTargetAttr); } - Handle(TDF_RelocationTable) aRelocTable = new TDF_RelocationTable(); // no relocation, empty map + // no special relocation, empty map, but self-relocation is on: copy references w/o changes + Handle(TDF_RelocationTable) aRelocTable = new TDF_RelocationTable(Standard_True); anAttrIter.Value()->Paste(aTargetAttr, aRelocTable); } // copy the sub-labels content @@ -449,13 +738,10 @@ void Model_Data::copyTo(std::shared_ptr theTarget) { TDF_Label aTargetRoot = std::dynamic_pointer_cast(theTarget)->label(); copyAttrs(myLab, aTargetRoot); - // make initialized the initialized attributes - std::map >::iterator aMyIter = myAttrs.begin(); - for(; aMyIter != myAttrs.end(); aMyIter++) { - if (aMyIter->second->isInitialized()) { - theTarget->attribute(aMyIter->first)->setInitialized(); - } - } + // reinitialize Model_Attributes by TDF_Attributes set + std::shared_ptr aTData = std::dynamic_pointer_cast(theTarget); + aTData->myAttrs.clear(); + theTarget->owner()->initAttributes(); // reinit feature attributes } bool Model_Data::isInHistory() @@ -468,6 +754,16 @@ void Model_Data::setIsInHistory(const bool theFlag) return myFlags->SetValue(kFlagInHistory, theFlag); } +bool Model_Data::isDeleted() +{ + return myFlags->Value(kFlagDeleted) == Standard_True; +} + +void Model_Data::setIsDeleted(const bool theFlag) +{ + return myFlags->SetValue(kFlagDeleted, theFlag); +} + bool Model_Data::isDisplayed() { if (!myObject.get() || !myObject->document().get() || // object is in valid @@ -503,7 +799,19 @@ std::shared_ptr Model_Data::invalidData() return kInvalid; } -bool Model_Data::isOwner(ModelAPI_Object* theOwner) +std::shared_ptr Model_Data::owner() { - return theOwner == myObject.get(); + 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; }