X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;ds=sidebyside;f=src%2FModel%2FModel_Objects.cpp;h=1265360d602afe2cc0e7c96e0951fe7aeeeeb0eb;hb=54ff377298a07d18bec1ed7bb2946e44247eb94c;hp=7324960c650a448bab7a7845a518116d4de3b45e;hpb=2ccdad0a7c9460b2b2bc686f1cd6db9f7772c9b0;p=modules%2Fshaper.git diff --git a/src/Model/Model_Objects.cpp b/src/Model/Model_Objects.cpp index 7324960c6..1265360d6 100644 --- a/src/Model/Model_Objects.cpp +++ b/src/Model/Model_Objects.cpp @@ -1,4 +1,4 @@ -// Copyright (C) 2014-2017 CEA/DEN, EDF R&D +// Copyright (C) 2014-2021 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 @@ -12,10 +12,9 @@ // // 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 +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // -// See http://www.salome-platform.org/ or -// email : webmaster.salome@opencascade.com +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // #include @@ -26,29 +25,38 @@ #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 +// for TDF_Label map usage +static Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper); +static Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2); + +int kUNDEFINED_FEATURE_INDEX = -1; + static const std::string& groupNameFoldering(const std::string& theGroupID, const bool theAllowFolder) { @@ -60,6 +68,22 @@ static const std::string& groupNameFoldering(const std::string& theGroupID, return theGroupID; } +// Check theFeature is a first or last feature in folder and return this folder +static FolderPtr inFolder(const FeaturePtr& theFeature, const std::string& theFolderAttr) +{ + const std::set& aRefs = theFeature->data()->refsToMe(); + for (std::set::iterator anIt = aRefs.begin(); anIt != aRefs.end(); ++anIt) { + if ((*anIt)->id() != theFolderAttr) + continue; + + ObjectPtr anOwner = (*anIt)->owner(); + FolderPtr aFolder = std::dynamic_pointer_cast(anOwner); + if (aFolder.get()) + return aFolder; + } + return FolderPtr(); +} + static const int TAG_OBJECTS = 2; // tag of the objects sub-tree (features, results) @@ -81,7 +105,7 @@ void Model_Objects::setOwner(DocumentPtr theDoc) myDoc = theDoc; // update all fields and recreate features and result objects if needed TDF_LabelList aNoUpdated; - synchronizeFeatures(aNoUpdated, true, true, true, true); + synchronizeFeatures(aNoUpdated, true, false, true, true); myHistory.clear(); } @@ -134,7 +158,7 @@ static void AddToRefArray(TDF_Label& theArrayLab, TDF_Label& theReferenced, TDF_ } else { // extend array by one more element Handle(TDataStd_HLabelArray1) aNewArray = new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper() + 1); - int aPassedPrev = 0; // prev feature is found and passed + int aPassedPrev = 0; // previous feature is found and passed if (thePrevLab.IsNull()) { // null means that inserted feature must be the first aNewArray->SetValue(aRefs->Lower(), theReferenced); aPassedPrev = 1; @@ -160,12 +184,24 @@ void Model_Objects::addFeature(FeaturePtr theFeature, const FeaturePtr theAfterT // store feature in the features array: before "initData" because in macro features // in initData it creates new features, appeared later than this TDF_Label aPrevFeateureLab; + FolderPtr aParentFolder; if (theAfterThis.get()) { // searching for the previous feature label std::shared_ptr aPrevData = std::dynamic_pointer_cast(theAfterThis->data()); if (aPrevData.get()) { aPrevFeateureLab = aPrevData->label().Father(); } + // Check if the previous feature is the last feature in a folder, + // then the folder should be updated to contain additional feature. + // Macro features are not stored in folder. + if (!theFeature->isMacro()) { + // If the last feature is a sub-feature of composite, use parent feature + // to check belonging to a folder. + FeaturePtr afterThis = ModelAPI_Tools::compositeOwner(theAfterThis); + if (!afterThis) + afterThis = theAfterThis; + aParentFolder = inFolder(afterThis, ModelAPI_Folder::LAST_FEATURE_ID()); + } } AddToRefArray(aFeaturesLab, aFeatureLab, aPrevFeateureLab); @@ -183,6 +219,12 @@ void Model_Objects::addFeature(FeaturePtr theFeature, const FeaturePtr theAfterT // must be after binding to the map because of "Box" macro feature that // creates other features in "initData" initData(theFeature, aFeatureLab, TAG_FEATURE_ARGUMENTS); + // put feature to the end of folder if it is added while + // the history line is set to the last feature from the folder + if (aParentFolder) { + aParentFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(theFeature); + updateHistory(ModelAPI_Folder::group()); + } // event: feature is added, mist be before "initData" to update OB correctly on Duplicate: // first new part, then the content static Events_ID anEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); @@ -277,10 +319,12 @@ void Model_Objects::removeFeature(FeaturePtr theFeature) for(; aRefIter != aRefs.end(); aRefIter++) { std::shared_ptr aComposite = std::dynamic_pointer_cast(*aRefIter); - if (aComposite.get() && aComposite->isSub(theFeature)) { + if (aComposite.get() && aComposite->data()->isValid() && aComposite->isSub(theFeature)) { aComposite->removeFeature(theFeature); } } + // remove feature from folder + removeFromFolder(std::list(1, theFeature)); // this must be before erase since theFeature erasing removes all information about // the feature results and groups of results // To reproduce: create sketch, extrusion, remove sketch => constructions tree is not updated @@ -329,7 +373,7 @@ void Model_Objects::eraseAllFeatures() } kCreator->sendDeleted(myDoc, ModelAPI_Feature::group()); myFeatures.Clear(); // just remove features without modification of DS - updateHistory(ModelAPI_Feature::group()); + myHistory.clear(); } void Model_Objects::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) @@ -343,9 +387,12 @@ void Model_Objects::moveFeature(FeaturePtr theMoved, FeaturePtr theAfterThis) if (theAfterThis.get()) anAfterLab = std::dynamic_pointer_cast(theAfterThis->data())->label().Father(); + // check whether some folder refers to the moved feature by start or end: if yes, remove from it + removeFromFolder(std::list(1, theMoved)); + Handle(TDataStd_HLabelArray1) aNewArray = new TDataStd_HLabelArray1(aRefs->Lower(), aRefs->Upper()); - int aPassedMovedFrom = 0; // the prev feature location is found and passed + int aPassedMovedFrom = 0; // the previous feature location is found and passed int aPassedMovedTo = 0; // the feature is added and this location is passed if (!theAfterThis.get()) { // null means that inserted feature must be the first aNewArray->SetValue(aRefs->Lower(), aMovedLab); @@ -451,7 +498,7 @@ void Model_Objects::createHistory(const std::string& theGroupID) } else { // it may be a folder - ObjectPtr aFolder = folder(aRefs->Value(a)); + const ObjectPtr& aFolder = folder(aRefs->Value(a)); if (aFolder.get()) { // store folder information for the Features group only if (isFeature || isFolder) { @@ -499,11 +546,12 @@ void Model_Objects::updateHistory(const std::string theGroup) } } -ObjectPtr Model_Objects::folder(TDF_Label theLabel) const +const ObjectPtr& Model_Objects::folder(TDF_Label theLabel) const { if (myFolders.IsBound(theLabel)) return myFolders.Find(theLabel); - return ObjectPtr(); + static ObjectPtr anEmptyResult; + return anEmptyResult; } FeaturePtr Model_Objects::feature(TDF_Label theLabel) const @@ -519,41 +567,54 @@ ObjectPtr Model_Objects::object(TDF_Label theLabel) FeaturePtr aFeature = feature(theLabel); if (aFeature.get()) return feature(theLabel); - TDF_Label aFeatureLabel = theLabel.Father().Father(); // let's suppose it is result - aFeature = feature(aFeatureLabel); - bool isSubResult = false; - if (!aFeature.get() && aFeatureLabel.Depth() > 1) { // let's suppose this is sub-result of result + TDF_Label aFeatureLabel = theLabel; // let's suppose it is result of this feature + TDF_LabelList aSubLabs; // sub - labels from higher level to lower level of result + while(!aFeature.get() && aFeatureLabel.Depth() > 1) { + aSubLabs.Prepend(aFeatureLabel); aFeatureLabel = aFeatureLabel.Father().Father(); aFeature = feature(aFeatureLabel); - isSubResult = true; } if (aFeature.get()) { - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.cbegin(); - for (; aRIter != aResults.cend(); aRIter++) { - if (isSubResult) { - ResultCompSolidPtr aCompRes = std::dynamic_pointer_cast(*aRIter); - if (aCompRes.get()) { - int aNumSubs = aCompRes->numberOfSubs(); - for(int a = 0; a < aNumSubs; a++) { - ResultPtr aSub = aCompRes->subResult(a); - if (aSub.get()) { - std::shared_ptr aSubData = std::dynamic_pointer_cast( - aSub->data()); - if (aSubData->label().Father().IsEqual(theLabel)) - return aSub; + ResultPtr aCurrentResult; + // searching for results then sub-results label by label + for(TDF_ListIteratorOfLabelList aSubLab(aSubLabs); aSubLab.More(); aSubLab.Next()) { + if (aCurrentResult.get()) { // iterate sub-results of result + ResultBodyPtr anOwner = std::dynamic_pointer_cast(aCurrentResult); + if (!anOwner) + return ObjectPtr(); // only Body can have sub-results + int a, aNumSubs = anOwner->numberOfSubs(); + for(a = 0; a < aNumSubs; a++) { + ResultPtr aSub = anOwner->subResult(a); + if (aSub.get()) { + std::shared_ptr aSubData = std::dynamic_pointer_cast( + aSub->data()); + const TDF_Label& aSubLabVal = aSubLab.ChangeValue(); + if (aSubData->label().Father().IsEqual(aSubLabVal)) { + aCurrentResult = aSub; + break; } } } - } else { - std::shared_ptr aResData = std::dynamic_pointer_cast( - (*aRIter)->data()); - if (aResData->label().Father().IsEqual(theLabel)) - return *aRIter; + if (a == aNumSubs) // not found an appropriate sub-result of result + return ObjectPtr(); + } else { // iterate results of feature + const std::list& aResults = aFeature->results(); + std::list >::const_iterator aRIter = aResults.cbegin(); + for(; aRIter != aResults.cend(); aRIter++) { + std::shared_ptr aResData = + std::dynamic_pointer_cast((*aRIter)->data()); + if (aResData->label().Father().IsEqual(aSubLab.ChangeValue())) { + aCurrentResult = *aRIter; + break; + } + } + if (aRIter == aResults.cend()) // not found an appropriate result of feature + return ObjectPtr(); } } + return aCurrentResult; } - return FeaturePtr(); // not found + return ObjectPtr(); // not found } ObjectPtr Model_Objects::object(const std::string& theGroupID, @@ -568,38 +629,28 @@ ObjectPtr Model_Objects::object(const std::string& theGroupID, } std::shared_ptr Model_Objects::objectByName( - const std::string& theGroupID, const std::string& theName) + const std::string& theGroupID, const std::wstring& theName) { createHistory(theGroupID); if (theGroupID == ModelAPI_Feature::group()) { // searching among features (in history or not) std::list > allObjs = allFeatures(); - std::list >::iterator anObjIter = allObjs.begin(); - for(; anObjIter != allObjs.end(); anObjIter++) { + // from the end to find the latest result with such name + std::list >::reverse_iterator anObjIter = allObjs.rbegin(); + for(; anObjIter != allObjs.rend(); anObjIter++) { if ((*anObjIter)->data()->name() == theName) return *anObjIter; } } else { // searching among results (concealed or not) std::list > allObjs = allFeatures(); - std::list >::iterator anObjIter = allObjs.begin(); - for(; anObjIter != allObjs.end(); anObjIter++) { - const std::list >& aResults = (*anObjIter)->results(); - std::list >::const_iterator aRIter = aResults.cbegin(); - for (; aRIter != aResults.cend(); aRIter++) { - if (aRIter->get() && (*aRIter)->groupName() == theGroupID) { - if ((*aRIter)->data()->name() == theName) - return *aRIter; - ResultCompSolidPtr aCompRes = - std::dynamic_pointer_cast(*aRIter); - if (aCompRes.get()) { - int aNumSubs = aCompRes->numberOfSubs(); - for(int a = 0; a < aNumSubs; a++) { - ResultPtr aSub = aCompRes->subResult(a); - if (aSub.get() && aSub->groupName() == theGroupID) { - if (aSub->data()->name() == theName) - return aSub; - } - } - } + // from the end to find the latest result with such name + std::list >::reverse_iterator anObjIter = allObjs.rbegin(); + for(; anObjIter != allObjs.rend(); anObjIter++) { + std::list allRes; + ModelAPI_Tools::allResults(*anObjIter, allRes); + for(std::list::iterator aRes = allRes.begin(); aRes != allRes.end(); aRes++) { + if (aRes->get() && (*aRes)->groupName() == theGroupID) { + if ((*aRes)->data()->name() == theName) + return *aRes; } } } @@ -638,6 +689,21 @@ int Model_Objects::size(const std::string& theGroupID, const bool theAllowFolder return aGroupID.empty() ? int(myHistory[theGroupID].size()) : int(myHistory[aGroupID].size()); } +std::shared_ptr Model_Objects::parent( + const std::shared_ptr theChild) +{ + if (theChild.get()) { + std::shared_ptr aData = std::dynamic_pointer_cast(theChild->data()); + TDF_Label aLab = aData->label(); + if (!aLab.IsNull() && aLab.Depth() > 2) { + ObjectPtr anObj = object(aLab.Father().Father().Father()); + return anObj; + } + } + return ObjectPtr(); +} + + void Model_Objects::allResults(const std::string& theGroupID, std::list& theResults) { // iterate the array of references and get feature by feature from the array @@ -667,46 +733,32 @@ TDF_Label Model_Objects::featuresLabel() const return myMain.FindChild(TAG_OBJECTS); } -static std::string composeName(const std::string& theFeatureKind, const int theIndex) +static std::wstring composeName(const std::string& theFeatureKind, const int theIndex) { std::stringstream aNameStream; aNameStream << theFeatureKind << "_" << theIndex; - return aNameStream.str(); + return Locale::Convert::toWString(aNameStream.str()); } void Model_Objects::setUniqueName(FeaturePtr theFeature) { if (!theFeature->data()->name().empty()) return; // not needed, name is already defined - std::string aName; // result + std::wstring aName; // result // first count all features of such kind to start with index = count + 1 int aNumObjects = -1; // this feature is already in this map NCollection_DataMap::Iterator aFIter(myFeatures); + std::set allNames; for (; aFIter.More(); aFIter.Next()) { if (aFIter.Value()->getKind() == theFeature->getKind()) aNumObjects++; + allNames.insert(aFIter.Value()->data()->name()); } // generate candidate name aName = composeName(theFeature->getKind(), aNumObjects + 1); // check this is unique, if not, increase index by 1 - for (aFIter.Initialize(myFeatures); aFIter.More();) { - FeaturePtr aFeature = aFIter.Value(); - bool isSameName = aFeature->data()->name() == aName; - if (!isSameName) { // check also results to avoid same results names (actual for Parts) - const std::list >& aResults = aFeature->results(); - std::list >::const_iterator aRIter = aResults.begin(); - for (; aRIter != aResults.cend(); aRIter++) { - isSameName = (*aRIter)->data()->name() == aName; - } - } - - if (isSameName) { - aNumObjects++; - aName = composeName(theFeature->getKind(), aNumObjects + 1); - // reinitialize iterator to make sure a new name is unique - aFIter.Initialize(myFeatures); - } else - aFIter.Next(); + for(aNumObjects++; allNames.find(aName) != allNames.end(); aNumObjects++) { + aName = composeName(theFeature->getKind(), aNumObjects + 1); } theFeature->data()->setName(aName); } @@ -717,13 +769,13 @@ void Model_Objects::setUniqueName(FolderPtr theFolder) return; // name is already defined int aNbFolders = myFolders.Size(); - std::string aName = composeName(ModelAPI_Folder::ID(), aNbFolders); + std::wstring aName = composeName(ModelAPI_Folder::ID(), aNbFolders); // check the uniqueness of the name NCollection_DataMap::Iterator anIt(myFolders); while (anIt.More()) { if (anIt.Value()->data()->name() == aName) { - aName = composeName(ModelAPI_Folder::ID(), aNbFolders); + aName = composeName(ModelAPI_Folder::ID(), ++aNbFolders); // reinitialize iterator to make sure a new name is unique anIt.Initialize(myFolders); } else @@ -751,15 +803,6 @@ void Model_Objects::initData(ObjectPtr theObj, TDF_Label theLab, const int theTa theObj->initAttributes(); } -std::shared_ptr Model_Objects::featureById(const int theId) -{ - if (theId > 0) { - TDF_Label aLab = featuresLabel().FindChild(theId, Standard_False); - return feature(aLab); - } - return std::shared_ptr(); // not found -} - void Model_Objects::synchronizeFeatures( const TDF_LabelList& theUpdated, const bool theUpdateReferences, const bool theExecuteFeatures, const bool theOpen, const bool theFlush) @@ -769,11 +812,11 @@ void Model_Objects::synchronizeFeatures( return; // after all updates, sends a message that groups of features were created or updated Events_Loop* aLoop = Events_Loop::loop(); - static Events_ID aDispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - static Events_ID aCreateEvent = Events_Loop::eventByName(EVENT_OBJECT_CREATED); - static Events_ID anUpdateEvent = Events_Loop::eventByName(EVENT_OBJECT_UPDATED); + //static Events_ID aDispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); + static Events_ID aCreateEvent = aLoop->eventByName(EVENT_OBJECT_CREATED); + static Events_ID anUpdateEvent = aLoop->eventByName(EVENT_OBJECT_UPDATED); static Events_ID aRedispEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); - static Events_ID aDeleteEvent = Events_Loop::eventByName(EVENT_OBJECT_DELETED); + static Events_ID aDeleteEvent = aLoop->eventByName(EVENT_OBJECT_DELETED); static Events_ID aToHideEvent = aLoop->eventByName(EVENT_OBJECT_TO_REDISPLAY); bool isActive = aLoop->activateFlushes(false); @@ -784,7 +827,7 @@ void Model_Objects::synchronizeFeatures( TDF_Label& aFeatureLab = anUpdatedIter.Value(); while(aFeatureLab.Depth() > 3) aFeatureLab = aFeatureLab.Father(); - if (myFeatures.IsBound(aFeatureLab)) + if (myFeatures.IsBound(aFeatureLab) || myFolders.IsBound(aFeatureLab)) anUpdatedMap.Add(aFeatureLab); } @@ -807,7 +850,7 @@ void Model_Objects::synchronizeFeatures( ObjectPtr aFeature = isFolder ? ObjectPtr(new ModelAPI_Folder) : ObjectPtr(aSession->createFeature(aFeatureID, anOwner)); if (!aFeature.get()) { - // somethig is wrong, most probably, the opened document has invalid structure + // something is wrong, most probably, the opened document has invalid structure Events_InfoMessage("Model_Objects", "Invalid type of object in the document").send(); aLabIter.Value()->Label().ForgetAllAttributes(); continue; @@ -836,11 +879,28 @@ void Model_Objects::synchronizeFeatures( if (anUpdatedMap.Contains(aFeatureLabel)) { if (!theOpen) { // on abort/undo/redo reinitialize attributes if something is changed - std::list > anAttrs = - anObject->data()->attributes(""); - std::list >::iterator anAttr = anAttrs.begin(); - for(; anAttr != anAttrs.end(); anAttr++) - (*anAttr)->reinit(); + FiltersFeaturePtr aFilter = std::dynamic_pointer_cast(anObject); + if (aFilter.get()) { // for filters attributes may be added/removed on undo/redo + std::dynamic_pointer_cast(aFilter->data())->clearAttributes(); + aFilter->initAttributes(); + } else { + std::list > anAttrs = + anObject->data()->attributes(""); + std::list >::iterator anAttr = anAttrs.begin(); + for(; anAttr != anAttrs.end(); anAttr++) + (*anAttr)->reinit(); + // if feature contains results, re-init them too + if (aFeature.get()) { + std::list aResults; + ModelAPI_Tools::allResults(aFeature, aResults); + std::list::iterator aResIter = aResults.begin(); + for(; aResIter != aResults.end(); aResIter++) { + anAttrs = (*aResIter)->data()->attributes(""); + for(anAttr = anAttrs.begin(); anAttr != anAttrs.end(); anAttr++) + (*anAttr)->reinit(); + } + } + } } ModelAPI_EventCreator::get()->sendUpdated(anObject, anUpdateEvent); if (aFeature && aFeature->getKind() == "Parameter") { @@ -898,6 +958,8 @@ void Model_Objects::synchronizeFeatures( // unbind after the "erase" call: on abort sketch // is removes sub-objects that corrupts aFIter myFolders.UnBind(aFldIt.Key()); + // reinitialize iterator because unbind may corrupt the previous order in the map + aFldIt.Initialize(myFolders); } } @@ -906,7 +968,7 @@ void Model_Objects::synchronizeFeatures( } // update results of the features (after features created because // they may be connected, like sketch and sub elements) - // After synchronisation of back references because sketch + // After synchronization of back references because sketch // must be set in sub-elements before "execute" by updateResults std::set aProcessed; // composites must be updated after their subs (issue 360) TDF_ChildIDIterator aLabIter2(featuresLabel(), TDataStd_Comment::GetID()); @@ -927,8 +989,8 @@ void Model_Objects::synchronizeFeatures( myHistory.clear(); } - if (theExecuteFeatures) - anOwner->executeFeatures() = false; + if (!theExecuteFeatures) + anOwner->setExecuteFeatures(false); aLoop->activateFlushes(isActive); if (theFlush) { @@ -941,23 +1003,32 @@ void Model_Objects::synchronizeFeatures( aLoop->flush(aRedispEvent); aLoop->flush(aToHideEvent); } - if (theExecuteFeatures) - anOwner->executeFeatures() = true; + if (!theExecuteFeatures) + anOwner->setExecuteFeatures(true); } -/// synchronises back references for the given object basing on the collected data +/// synchronizes back references for the given object basing on the collected data void Model_Objects::synchronizeBackRefsForObject(const std::set& theNewRefs, ObjectPtr theObject) { if (!theObject.get() || !theObject->data()->isValid()) return; // invalid std::shared_ptr aData = std::dynamic_pointer_cast(theObject->data()); - // iterate new list to compare with curent + // iterate new list to compare with current std::set::iterator aNewIter = theNewRefs.begin(); for(; aNewIter != theNewRefs.end(); aNewIter++) { + // for the Model_AttributeRefList erase cash (issue #2819) + std::shared_ptr aRefList = + std::dynamic_pointer_cast(*aNewIter); + if (aRefList) + aRefList->eraseHash(); + if (aData->refsToMe().find(*aNewIter) == aData->refsToMe().end()) { FeaturePtr aRefFeat = std::dynamic_pointer_cast((*aNewIter)->owner()); - aData->addBackReference(aRefFeat, (*aNewIter)->id()); + if (aRefFeat) + aData->addBackReference(aRefFeat, (*aNewIter)->id()); + else // add back reference to a folder + aData->addBackReference((*aNewIter)->owner(), (*aNewIter)->id()); } } if (theNewRefs.size() != aData->refsToMe().size()) { // some back ref must be removed @@ -993,6 +1064,35 @@ void Model_Objects::synchronizeBackRefsForObject(const std::set& t } else aCurrentIter++; } } + // for the last feature in the folder, check if it is a sub-feature, + // then refer the folder to a top-level parent composite feature + const std::set& aRefs = aData->refsToMe(); + std::set::iterator anIt = aRefs.begin(); + for (; anIt != aRefs.end(); ++anIt) + if ((*anIt)->id() == ModelAPI_Folder::LAST_FEATURE_ID()) + break; + if (anIt != aRefs.end()) { + FeaturePtr aFeature = ModelAPI_Feature::feature(theObject); + if (aFeature) { + CompositeFeaturePtr aParent; + CompositeFeaturePtr aGrandParent = ModelAPI_Tools::compositeOwner(aFeature); + do { + aParent = aGrandParent; + if (aGrandParent) + aGrandParent = ModelAPI_Tools::compositeOwner(aParent); + } while (aGrandParent.get()); + if (aParent) { + ObjectPtr aFolder = (*anIt)->owner(); + // remove reference from the current feature + aData->removeBackReference(aFolder, ModelAPI_Folder::LAST_FEATURE_ID()); + // set reference to a top-level parent + aFolder->data()->reference(ModelAPI_Folder::LAST_FEATURE_ID())->setValue(aParent); + std::shared_ptr aParentData = + std::dynamic_pointer_cast(aParent->data()); + aParentData->addBackReference(aFolder, ModelAPI_Folder::LAST_FEATURE_ID()); + } + } + } aData->updateConcealmentFlag(); } @@ -1022,9 +1122,9 @@ static void collectReferences(std::shared_ptr theData, void Model_Objects::synchronizeBackRefs() { // collect all back references in the separated container: to update everything at once, - // without additional Concealment switchin on and off: only the final modification + // without additional Concealment switching on and off: only the final modification - // referenced (slave) objects to referencing attirbutes + // referenced (slave) objects to referencing attributes std::map > allRefs; NCollection_DataMap::Iterator aFeatures(myFeatures); for(; aFeatures.More(); aFeatures.Next()) { @@ -1065,7 +1165,7 @@ void Model_Objects::synchronizeBackRefs() FeaturePtr aFeature = aFeatures.Value(); std::list aResults; ModelAPI_Tools::allResults(aFeature, aResults); - // update the concealment status for disply in isConcealed of ResultBody + // update the concealment status for display in isConcealed of ResultBody std::list::iterator aRIter = aResults.begin(); for(; aRIter != aResults.cend(); aRIter++) { (*aRIter)->isConcealed(); @@ -1089,52 +1189,67 @@ TDF_Label Model_Objects::resultLabel( bool Model_Objects::hasCustomName(DataPtr theFeatureData, ResultPtr theResult, - int theResultIndex, - std::string& theParentName) const + int /*theResultIndex*/, + std::wstring& theParentName) const { - ResultCompSolidPtr aCompSolidRes = - std::dynamic_pointer_cast(theFeatureData->owner()); - if (aCompSolidRes) { - FeaturePtr anOwner = ModelAPI_Feature::feature(theResult->data()->owner()); + ResultBodyPtr aBodyRes = std::dynamic_pointer_cast(theFeatureData->owner()); + if (aBodyRes) { + // only for top-results (works for the cases when results are not yet added to the feature) + FeaturePtr anOwner = ModelAPI_Feature::feature(theResult); // names of sub-solids in CompSolid should be default (for example, // result of boolean operation 'Boolean_1' is a CompSolid which is renamed to 'MyBOOL', // however, sub-elements of 'MyBOOL' should be named 'Boolean_1_1', 'Boolean_1_2' etc.) - std::ostringstream aDefaultName; - aDefaultName << anOwner->name(); - // compute default name of CompSolid (name of feature + index of CompSolid's result) - int aCompSolidResultIndex = 0; - const std::list& aResults = anOwner->results(); - for (std::list::const_iterator anIt = aResults.begin(); - anIt != aResults.end(); ++anIt, ++aCompSolidResultIndex) - if (aCompSolidRes == *anIt) - break; - aDefaultName << "_" << (aCompSolidResultIndex + 1); - theParentName = aDefaultName.str(); + if (std::dynamic_pointer_cast(aBodyRes->data())->label().Depth() == 6) { + std::wostringstream aDefaultName; + // compute default name of CompSolid (name of feature + index of CompSolid's result) + int aBodyResultIndex = 0; + const std::list& aResults = anOwner->results(); + std::list::const_iterator anIt = aResults.begin(); + for (; anIt != aResults.end(); ++anIt, ++aBodyResultIndex) + if (aBodyRes == *anIt) + break; + aDefaultName << anOwner->name(); + aDefaultName << "_" << (aBodyResultIndex + 1); + theParentName = aDefaultName.str(); + } else { // just name of the parent result if it is deeper than just a sub-result + theParentName = aBodyRes->data()->name(); + } return false; } - theParentName = ModelAPI_Tools::getDefaultName(theResult, theResultIndex); - return true; + std::pair aName = ModelAPI_Tools::getDefaultName(theResult); + if (aName.second) + theParentName = aName.first; + return aName.second; } void Model_Objects::storeResult(std::shared_ptr theFeatureData, std::shared_ptr theResult, - const int theResultIndex) + const int theResultIndex, + const std::wstring& theNameShape) { theResult->init(); theResult->setDoc(myDoc); initData(theResult, resultLabel(theFeatureData, theResultIndex), TAG_FEATURE_ARGUMENTS); if (theResult->data()->name().empty()) { // if was not initialized, generate event and set a name - std::string aNewName = theFeatureData->name(); - if (!hasCustomName(theFeatureData, theResult, theResultIndex, aNewName)) { - std::stringstream aName; - aName << aNewName; - // if there are several results (issue #899: any number of result), - // add unique prefix starting from second - if (theResultIndex > 0 || theResult->groupName() == ModelAPI_ResultBody::group()) - aName << "_" << theResultIndex + 1; + std::wstring aNewName = theFeatureData->name(); + if (hasCustomName(theFeatureData, theResult, theResultIndex, aNewName)) { + // if the name of result is user-defined, then, at first time, assign name of the result + // by empty string to be sure that corresponding flag in the data model is set + theResult->data()->setName(L""); + } else { + std::wstringstream aName; + if ( theNameShape != L"" ){ + aName << theNameShape; + } else { + aName << aNewName; + // if there are several results (issue #899: any number of result), + // add unique prefix starting from second + if (theResultIndex > 0 || theResult->groupName() == ModelAPI_ResultBody::group()) + aName << "_" << theResultIndex + 1; + } aNewName = aName.str(); } theResult->data()->setName(aNewName); @@ -1159,31 +1274,20 @@ std::shared_ptr Model_Objects::createConstruction( } std::shared_ptr Model_Objects::createBody( - const std::shared_ptr& theFeatureData, const int theIndex) + const std::shared_ptr& theFeatureData, + const int theIndex, + const std::wstring& theNameShape) { TDF_Label aLab = resultLabel(theFeatureData, theIndex); - // for feature create compsolid, but for result sub create body: - // only one level of recursion is supported now - ResultPtr aResultOwner = std::dynamic_pointer_cast(theFeatureData->owner()); - ObjectPtr anOldObject; - if (aResultOwner.get()) { - TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str()); - } else { // in compsolid (higher level result) old object probably may be found - TDataStd_Comment::Set(aLab, ModelAPI_ResultCompSolid::group().c_str()); - anOldObject = object(aLab); - } + TDataStd_Comment::Set(aLab, ModelAPI_ResultBody::group().c_str()); + ObjectPtr anOldObject = object(aLab); std::shared_ptr aResult; if (anOldObject.get()) { aResult = std::dynamic_pointer_cast(anOldObject); } if (!aResult.get()) { - // create compsolid anyway; if it is compsolid, it will create sub-bodies internally - if (aResultOwner.get()) { - aResult = std::shared_ptr(new Model_ResultBody); - } else { - aResult = std::shared_ptr(new Model_ResultCompSolid); - } - storeResult(theFeatureData, aResult, theIndex); + aResult = std::shared_ptr(new Model_ResultBody); + storeResult(theFeatureData, aResult, theIndex, theNameShape); } return aResult; } @@ -1281,7 +1385,8 @@ std::shared_ptr Model_Objects::createFolder( std::shared_ptr aPrevData = std::dynamic_pointer_cast(theBeforeThis->data()); if (aPrevData.get()) { - aPrevFeatureLab = nextLabel(aPrevData->label().Father(), true); + int anIndex = kUNDEFINED_FEATURE_INDEX; + aPrevFeatureLab = nextLabel(aPrevData->label().Father(), anIndex, true); } } else { // find the label of the last feature Handle(TDataStd_ReferenceArray) aRefs; @@ -1335,6 +1440,7 @@ void Model_Objects::removeFolder(std::shared_ptr theFolder) updateHistory(ModelAPI_Feature::group()); } +// Returns one of the limiting features of the list static FeaturePtr limitingFeature(std::list& theFeatures, const bool isLast) { FeaturePtr aFeature; @@ -1348,6 +1454,13 @@ static FeaturePtr limitingFeature(std::list& theFeatures, const bool return aFeature; } +// Verify the feature is sub-element in composite feature or it is not used in the history +static bool isSkippedFeature(FeaturePtr theFeature) +{ + bool isSub = ModelAPI_Tools::compositeOwner(theFeature).get() != NULL; + return isSub || (theFeature && !theFeature->isInHistory()); +} + std::shared_ptr Model_Objects::findFolder( const std::list >& theFeatures, const bool theBelow) @@ -1385,14 +1498,23 @@ std::shared_ptr Model_Objects::findFolder( if (theBelow) continue; + // issue #18733: check for the last feature in folder before checking the sub-feature, + // because the folder may end by the feature which is + // neither a sub-feature nor a feature in history. if (!aLastFeatureInFolder.IsNull()) { if (IsEqual(aCurLabel, aLastFeatureInFolder)) - aLastFeatureInFolder.Nullify(); // the last feature in the folder is achived + aLastFeatureInFolder.Nullify(); // the last feature in the folder is achieved continue; } - aFoundFolder = std::dynamic_pointer_cast(folder(aCurLabel)); - if (aFoundFolder) { + // if feature is in sub-component, skip it + FeaturePtr aCurFeature = feature(aCurLabel); + if (isSkippedFeature(aCurFeature)) + continue; + + const ObjectPtr& aFolderObj = folder(aCurLabel); + if (aFolderObj.get()) { + aFoundFolder = std::dynamic_pointer_cast(aFolderObj); AttributeReferencePtr aLastFeatAttr = aFoundFolder->reference(ModelAPI_Folder::LAST_FEATURE_ID()); if (aLastFeatAttr) { @@ -1408,8 +1530,15 @@ std::shared_ptr Model_Objects::findFolder( } if (theBelow && aRefIndex < aRefs->Upper()) { + TDF_Label aLabel; + // skip following features which are sub-components or not in history + for (int anIndex = aRefIndex + 1; anIndex <= aRefs->Upper(); ++anIndex) { + aLabel = aRefs->Value(anIndex); + FeaturePtr aCurFeature = feature(aLabel); + if (!isSkippedFeature(aCurFeature)) + break; + } // check the next object is a folder - TDF_Label aLabel = aRefs->Value(aRefIndex + 1); aFoundFolder = std::dynamic_pointer_cast(folder(aLabel)); } @@ -1423,14 +1552,13 @@ std::shared_ptr Model_Objects::findFolder( !aFeatures.empty() && aRefIndex >= aRefs->Lower() && aRefIndex <= aRefs->Upper(); aRefIndex += aStep) { TDF_Label aCurLabel = aRefs->Value(aRefIndex); - TDF_Label aFeatureLabel; + // if feature is in sub-component, skip it + FeaturePtr aCurFeature = feature(aCurLabel); + if (isSkippedFeature(aCurFeature)) + continue; aLimitingFeature = limitingFeature(aFeatures, theBelow); - aData = std::static_pointer_cast(aLimitingFeature->data()); - if (aData && aData->isValid()) - aFeatureLabel = aData->label().Father(); - - if (!IsEqual(aCurLabel, aFeatureLabel)) + if (!aCurFeature->data()->isEqual(aLimitingFeature->data())) return FolderPtr(); // not a sequential list } @@ -1514,21 +1642,6 @@ bool Model_Objects::moveToFolder( return true; } -static FolderPtr inFolder(const FeaturePtr& theFeature, const std::string& theFolderAttr) -{ - const std::set& aRefs = theFeature->data()->refsToMe(); - for (std::set::iterator anIt = aRefs.begin(); anIt != aRefs.end(); ++anIt) { - if ((*anIt)->id() != theFolderAttr) - continue; - - ObjectPtr anOwner = (*anIt)->owner(); - FolderPtr aFolder = std::dynamic_pointer_cast(anOwner); - if (aFolder.get()) - return aFolder; - } - return FolderPtr(); -} - static FolderPtr isExtractionCorrect(const FolderPtr& theFirstFeatureFolder, const FolderPtr& theLastFeatureFolder, bool& isExtractBefore) @@ -1596,15 +1709,29 @@ bool Model_Objects::removeFromFolder( TDF_Label aFolderLabel = aData->label().Father(); TDF_Label aPrevFeatureLabel = aRefs->Value(aRefIndex); // update start reference of the folder - if (aFolderStartFeature.get()) - aFolderStartFeature = feature(aRefs->Value(aRefIndex + 1)); + if (aFolderStartFeature.get()) { + FeaturePtr aNewStartFeature; + do { // skip all features placed in the composite features + aPrevFeatureLabel = aRefs->Value(aRefIndex++); + aNewStartFeature = + aRefIndex <= aRefs->Upper() ? feature(aRefs->Value(aRefIndex)) : FeaturePtr(); + } while (aNewStartFeature && isSkippedFeature(aNewStartFeature)); + aFolderStartFeature = aNewStartFeature; + } // move the folder in the list of references after the last feature from the list RemoveFromRefArray(aFeaturesLab, aFolderLabel); AddToRefArray(aFeaturesLab, aFolderLabel, aPrevFeatureLabel); } else { // update end reference of the folder - if (aFolderEndFeature.get()) - aFolderEndFeature = feature(aRefs->Value(aRefIndex - 1)); + if (aFolderEndFeature.get()) { + FeaturePtr aNewEndFeature; + do { // skip all features placed in the composite features + --aRefIndex; + aNewEndFeature = + aRefIndex >= aRefs->Lower() ? feature(aRefs->Value(aRefIndex)) : FeaturePtr(); + } while (aNewEndFeature && isSkippedFeature(aNewEndFeature)); + aFolderEndFeature = aNewEndFeature; + } } // update folder references @@ -1634,17 +1761,32 @@ FolderPtr Model_Objects::findContainingFolder(const FeaturePtr& theFeature, int& TDF_Label aLastFeatureLabel; for (int aRefIndex = aRefs->Lower(); aRefIndex <= aRefs->Upper(); ++aRefIndex) { + TDF_Label aCurLabel = aRefs->Value(aRefIndex); + if (aFoundFolder) ++theIndexInFolder; - TDF_Label aCurLabel = aRefs->Value(aRefIndex); - if (aCurLabel == aLabelToFind) // the feature is reached + if (aCurLabel == aLabelToFind) { // the feature is reached + if (aFoundFolder) { + if (isSkippedFeature(theFeature)) { + theIndexInFolder = -1; + return FolderPtr(); + } + // decrease the index of the feature in the folder by the number of skipped features + for (int anIndex = theIndexInFolder - 1; anIndex > 0; anIndex--) { + aCurLabel = aRefs->Value(aRefIndex - anIndex); + if (isSkippedFeature(feature(aCurLabel))) + theIndexInFolder--; + } + } return aFoundFolder; + } if (!aFoundFolder) { // if the current label refers to a folder, feel all necessary data - aFoundFolder = std::dynamic_pointer_cast(folder(aCurLabel)); - if (aFoundFolder) { + const ObjectPtr& aFolderObj = folder(aCurLabel); + if (aFolderObj.get()) { + aFoundFolder = std::dynamic_pointer_cast(aFolderObj); theIndexInFolder = -1; AttributeReferencePtr aLastRef = @@ -1673,10 +1815,10 @@ std::shared_ptr Model_Objects::feature( const std::shared_ptr& theResult) { std::shared_ptr aData = std::dynamic_pointer_cast(theResult->data()); - if (aData.get()) { + if (aData.get() && aData->isValid()) { TDF_Label aFeatureLab = aData->label().Father().Father().Father(); FeaturePtr aFeature = feature(aFeatureLab); - if (!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result + while(!aFeature.get() && aFeatureLab.Depth() > 1) { // this may be sub-result of result aFeatureLab = aFeatureLab.Father().Father(); aFeature = feature(aFeatureLab); } @@ -1692,7 +1834,7 @@ std::string Model_Objects::featureResultGroup(FeaturePtr theFeature) if (aLabIter.More()) { TDF_Label anArgLab = aLabIter.Value(); Handle(TDataStd_Comment) aGroup; - if (aLabIter.Value().FindAttribute(TDataStd_Comment::GetID(), aGroup)) { + if (anArgLab.FindAttribute(TDataStd_Comment::GetID(), aGroup)) { return TCollection_AsciiString(aGroup->Get()).ToCString(); } } @@ -1717,8 +1859,10 @@ void Model_Objects::updateResults(FeaturePtr theFeature, std::set& t } } - // for not persistent is will be done by parametric updater automatically - //if (!theFeature->isPersistentResult()) return; + // it may be on undo + if (!theFeature->data() || !theFeature->data()->isValid() || theFeature->isDisabled()) + return; + // check the existing results and remove them if there is nothing on the label std::list::const_iterator aResIter = theFeature->results().cbegin(); while(aResIter != theFeature->results().cend()) { @@ -1735,9 +1879,6 @@ void Model_Objects::updateResults(FeaturePtr theFeature, std::set& t } aResIter++; } - // it may be on undo - if (!theFeature->data() || !theFeature->data()->isValid() || theFeature->isDisabled()) - return; // check that results are presented on all labels int aResSize = int(theFeature->results().size()); TDF_ChildIterator aLabIter(resultLabel(theFeature->data(), 0).Father()); @@ -1749,21 +1890,33 @@ void Model_Objects::updateResults(FeaturePtr theFeature, std::set& t TDF_Label anArgLab = aLabIter.Value(); Handle(TDataStd_Comment) aGroup; if (anArgLab.FindAttribute(TDataStd_Comment::GetID(), aGroup)) { - if (aGroup->Get() == ModelAPI_ResultBody::group().c_str() || - aGroup->Get() == ModelAPI_ResultCompSolid::group().c_str()) { + if (aGroup->Get() == ModelAPI_ResultBody::group().c_str()) { aNewBody = createBody(theFeature->data(), aResIndex); } else if (aGroup->Get() == ModelAPI_ResultPart::group().c_str()) { - std::shared_ptr aNewP = createPart(theFeature->data(), aResIndex); - theFeature->setResult(aNewP, aResIndex); - if (!aNewP->partDoc().get()) - // create the part result: it is better to restore the previous result if it is possible - theFeature->execute(); + if (aResIndex <= (int)theFeature->results().size()) {// to avoid crash if previous execute + // for index = 0 erases result + std::shared_ptr aNewP = createPart(theFeature->data(), aResIndex); + if (!aNewP->data()->isDeleted()) { + theFeature->setResult(aNewP, aResIndex); + if (!aNewP->partDoc().get()) + // create the part result: it is better to restore the previous result if possible + theFeature->execute(); + } + } } else if (aGroup->Get() == ModelAPI_ResultConstruction::group().c_str()) { - theFeature->execute(); // construction shapes are needed for sketch solver + ResultConstructionPtr aConstr = createConstruction(theFeature->data(), aResIndex); + if (!aConstr->data()->isDeleted()) { + if (!aConstr->updateShape()) + theFeature->execute(); // not stored shape in the data structure, execute to have it + else + theFeature->setResult(aConstr, aResIndex); // result is ready without execution + } } else if (aGroup->Get() == ModelAPI_ResultGroup::group().c_str()) { aNewBody = createGroup(theFeature->data(), aResIndex); } else if (aGroup->Get() == ModelAPI_ResultField::group().c_str()) { - aNewBody = createField(theFeature->data(), aResIndex); + ResultFieldPtr aField = createField(theFeature->data(), aResIndex); + aField->updateSteps(); // to refresh the internal data + aNewBody = aField; } else if (aGroup->Get() == ModelAPI_ResultParameter::group().c_str()) { theFeature->attributeChanged("expression"); // just produce a value } else { @@ -1776,9 +1929,25 @@ void Model_Objects::updateResults(FeaturePtr theFeature, std::set& t } } } + if (aResSize > 0) { // check there exist a body that must be updated + std::list::const_iterator aRes = theFeature->results().cbegin(); + for (; aResSize && aRes != theFeature->results().cend(); aRes++, aResSize++) { + if ((*aRes)->data()->isValid()) { + if ((*aRes)->groupName() == ModelAPI_ResultBody::group()) { + ResultBodyPtr aBody = std::dynamic_pointer_cast(*aRes); + aBody->updateSubs(aBody->shape(), false); + } else if ((*aRes)->groupName() == ModelAPI_ResultConstruction::group()) { + // update the cashed myShape presented in construction + ResultConstructionPtr aConstr = + std::dynamic_pointer_cast(*aRes); + aConstr->updateShape(); + } + } + } + } } -ResultPtr Model_Objects::findByName(const std::string theName) +ResultPtr Model_Objects::findByName(const std::wstring theName) { ResultPtr aResult; FeaturePtr aResFeature; // keep feature to return the latest one @@ -1805,31 +1974,41 @@ ResultPtr Model_Objects::findByName(const std::string theName) return aResult; } -TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, const bool theReverse) +TDF_Label Model_Objects::nextLabel(TDF_Label theCurrent, int& theIndex, const bool theReverse) { Handle(TDataStd_ReferenceArray) aRefs; if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) { - for(int a = aRefs->Lower(); a <= aRefs->Upper(); a++) { // iterate all existing features + int aStart = theIndex == kUNDEFINED_FEATURE_INDEX ? aRefs->Lower() : theIndex; + for(int a = aStart; a <= aRefs->Upper(); a++) { // iterate all existing features TDF_Label aCurLab = aRefs->Value(a); if (aCurLab.IsEqual(theCurrent)) { a += theReverse ? -1 : 1; - if (a >= aRefs->Lower() && a <= aRefs->Upper()) + if (a >= aRefs->Lower() && a <= aRefs->Upper()) { + theIndex = a; return aRefs->Value(a); - break; // finish iiteration: it's last feature + } + break; // finish iteration: it's last feature } } } return TDF_Label(); } -FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, const bool theReverse) +FeaturePtr Model_Objects::nextFeature(FeaturePtr theCurrent, int& theIndex, const bool theReverse) { std::shared_ptr aData = std::static_pointer_cast(theCurrent->data()); if (aData.get() && aData->isValid()) { TDF_Label aFeatureLabel = aData->label().Father(); - TDF_Label aNextLabel = nextLabel(aFeatureLabel, theReverse); - if (!aNextLabel.IsNull()) - return feature(aNextLabel); + do { + TDF_Label aNextLabel = nextLabel(aFeatureLabel, theIndex, theReverse); + if (aNextLabel.IsNull()) + break; // the last or something is wrong + FeaturePtr aFound = feature(aNextLabel); + if (aFound) + return aFound; // the feature is found + // if the next label is a folder, skip it + aFeatureLabel = folder(aNextLabel).get() ? aNextLabel : TDF_Label(); + } while (!aFeatureLabel.IsNull()); } return FeaturePtr(); // not found, last, or something is wrong } @@ -1847,6 +2026,12 @@ FeaturePtr Model_Objects::lastFeature() { Handle(TDataStd_ReferenceArray) aRefs; if (featuresLabel().FindAttribute(TDataStd_ReferenceArray::GetID(), aRefs)) { + // comment this because of #2674 - features are removed from array on deactivation of Part + /*FeaturePtr aLast = feature(aRefs->Value(aRefs->Upper())); + if (!aLast.get() && aRefs->Length() != 0) { // erase the invalid feature from the array + RemoveFromRefArray(featuresLabel(), aRefs->Value(aRefs->Upper())); + return lastFeature(); // try once again, after the last was removed + }*/ return feature(aRefs->Value(aRefs->Upper())); } return FeaturePtr(); // no features at all @@ -1854,6 +2039,8 @@ FeaturePtr Model_Objects::lastFeature() bool Model_Objects::isLater(FeaturePtr theLater, FeaturePtr theCurrent) const { + if (theLater->getKind() == "InternalSelectionInPartFeature") + return true; std::shared_ptr aLaterD = std::static_pointer_cast(theLater->data()); std::shared_ptr aCurrentD = std::static_pointer_cast(theCurrent->data()); if (aLaterD.get() && aLaterD->isValid() && aCurrentD.get() && aCurrentD->isValid()) { @@ -1928,7 +2115,6 @@ std::shared_ptr Model_Objects::internalFeature(const int theIn Standard_Integer HashCode(const TDF_Label& theLab, const Standard_Integer theUpper) { return TDF_LabelMapHasher::HashCode(theLab, theUpper); - } Standard_Boolean IsEqual(const TDF_Label& theLab1, const TDF_Label& theLab2) {