+ myRefsToMe.clear();
+ std::shared_ptr<ModelAPI_Result> aRes =
+ std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
+ if (aRes)
+ aRes->setIsConcealed(false);
+}
+
+void Model_Data::removeBackReference(FeaturePtr theFeature, std::string theAttrID)
+{
+ AttributePtr anAttribute = theFeature->data()->attribute(theAttrID);
+ removeBackReference(anAttribute);
+}
+
+void Model_Data::removeBackReference(AttributePtr theAttr)
+{
+ if (myRefsToMe.find(theAttr) == myRefsToMe.end())
+ return;
+
+ myRefsToMe.erase(theAttr);
+
+ // remove concealment immideately: on deselection it must be posible to reselect in GUI the same
+ FeaturePtr aFeatureOwner = std::dynamic_pointer_cast<ModelAPI_Feature>(theAttr->owner());
+ if (aFeatureOwner.get() &&
+ ModelAPI_Session::get()->validators()->isConcealed(aFeatureOwner->getKind(), theAttr->id())) {
+ updateConcealmentFlag();
+ }
+}
+
+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));
+
+ if (theApplyConcealment && theFeature->isStable() &&
+ ModelAPI_Session::get()->validators()->isConcealed(theFeature->getKind(), theAttrID)) {
+ std::shared_ptr<ModelAPI_Result> aRes =
+ std::dynamic_pointer_cast<ModelAPI_Result>(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
+ if (aRes && !theFeature->isDisabled()) {
+ aRes->setIsConcealed(true);
+ }
+ }
+}
+
+void Model_Data::updateConcealmentFlag()
+{
+ std::set<AttributePtr>::iterator aRefsIter = myRefsToMe.begin();
+ for(; aRefsIter != myRefsToMe.end(); aRefsIter++) {
+ if (aRefsIter->get()) {
+ FeaturePtr aFeature = std::dynamic_pointer_cast<ModelAPI_Feature>((*aRefsIter)->owner());
+ if (aFeature.get() && !aFeature->isDisabled() && aFeature->isStable()) {
+ if (ModelAPI_Session::get()->validators()->isConcealed(
+ aFeature->getKind(), (*aRefsIter)->id())) {
+ std::shared_ptr<ModelAPI_Result> aRes =
+ std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
+ if (aRes.get()) {
+ aRes->setIsConcealed(true); // set concealed
+ }
+ return;
+ }
+ }
+ }
+ }
+ // thus, no concealment references anymore => make not-concealed
+ std::shared_ptr<ModelAPI_Result> aRes =
+ std::dynamic_pointer_cast<ModelAPI_Result>(myObject);
+ if (aRes.get()) {
+ aRes->setIsConcealed(false);
+ }
+}
+
+std::set<std::string> set_union(const std::set<std::string>& theLeft,
+ const std::set<std::string>& theRight)
+{
+ std::set<std::string> aResult;
+ aResult.insert(theLeft.begin(), theLeft.end());
+ aResult.insert(theRight.begin(), theRight.end());
+ return aResult;
+}
+
+std::set<std::string> usedParameters(const AttributePointPtr& theAttribute)
+{
+ std::set<std::string> anUsedParameters;
+ for (int aComponent = 0; aComponent < 3; ++aComponent)
+ anUsedParameters = set_union(anUsedParameters, theAttribute->usedParameters(aComponent));
+ return anUsedParameters;
+}
+
+std::set<std::string> usedParameters(const AttributePoint2DPtr& theAttribute)
+{
+ std::set<std::string> anUsedParameters;
+ for (int aComponent = 0; aComponent < 2; ++aComponent)
+ anUsedParameters = set_union(anUsedParameters, theAttribute->usedParameters(aComponent));
+ return anUsedParameters;
+}
+
+std::list<ResultParameterPtr> findVariables(const std::set<std::string>& theParameters,
+ const DocumentPtr& theDocument)
+{
+ std::list<ResultParameterPtr> aResult;
+ std::set<std::string>::const_iterator aParamIt = theParameters.cbegin();
+ for (; aParamIt != theParameters.cend(); ++aParamIt) {
+ const std::string& aName = *aParamIt;
+ double aValue;
+ ResultParameterPtr aParam;
+ if (ModelAPI_Tools::findVariable(aName, aValue, aParam, theDocument))
+ aResult.push_back(aParam);
+ }
+ return aResult;
+}
+
+void Model_Data::referencesToObjects(
+ std::list<std::pair<std::string, std::list<ObjectPtr> > >& theRefs)
+{
+ static Model_ValidatorsFactory* aValidators =
+ static_cast<Model_ValidatorsFactory*>(ModelAPI_Session::get()->validators());
+ FeaturePtr aMyFeature = std::dynamic_pointer_cast<ModelAPI_Feature>(myObject);
+
+ std::map<std::string, std::shared_ptr<ModelAPI_Attribute> >::iterator anAttr = myAttrs.begin();
+ std::list<ObjectPtr> aReferenced; // not inside of cycle to avoid excess memory management