X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModelAPI%2FModelAPI_Tools.cpp;h=3f823dcb2f9e8fde966d603bb483a26260776df4;hb=c66d90377083e2611816b72500533d4ffbc73e19;hp=cbe1290a852b80cc4192d1d38bf6889517a4a74f;hpb=1b6e16d96b4f83c138791e0e86842d1507bcef1f;p=modules%2Fshaper.git

diff --git a/src/ModelAPI/ModelAPI_Tools.cpp b/src/ModelAPI/ModelAPI_Tools.cpp
old mode 100644
new mode 100755
index cbe1290a8..3f823dcb2
--- a/src/ModelAPI/ModelAPI_Tools.cpp
+++ b/src/ModelAPI/ModelAPI_Tools.cpp
@@ -19,42 +19,101 @@ namespace ModelAPI_Tools {
 
 std::shared_ptr<GeomAPI_Shape> shape(const ResultPtr& theResult)
 {
-/*
-  ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theResult);
-  if (aBody)
-    return aBody->shape();
-
-  ResultConstructionPtr aConstruct = std::dynamic_pointer_cast<ModelAPI_ResultConstruction>(
-    theResult);
-  if (aConstruct)
-    return aConstruct->shape();
-
-  ResultGroupPtr aGroup = std::dynamic_pointer_cast<ModelAPI_ResultGroup>(theResult);
-  if (aGroup)
-    return aGroup->shape();
-  return std::shared_ptr<GeomAPI_Shape>();
-  */
   return theResult->shape();
 }
 
-bool findVariable(const std::string& theName, double& outValue, ResultParameterPtr& theParam)
+const char* toString(ModelAPI_ExecState theExecState) 
+{
+#define TO_STRING(__NAME__) case __NAME__: return #__NAME__;
+  switch (theExecState) {
+  TO_STRING(ModelAPI_StateDone)
+  TO_STRING(ModelAPI_StateMustBeUpdated)
+  TO_STRING(ModelAPI_StateExecFailed)
+  TO_STRING(ModelAPI_StateInvalidArgument)
+  TO_STRING(ModelAPI_StateNothing)
+  default: return "Unknown ExecState.";
+  }
+#undef TO_STRING
+}
+
+std::string getFeatureError(const FeaturePtr& theFeature)
+{
+  std::string anError;
+  if (!theFeature.get() || !theFeature->data()->isValid() || theFeature->isAction())
+    return anError;
+
+  // to be removed later, this error should be got from the feature
+  if (theFeature->data()->execState() == ModelAPI_StateDone ||
+      theFeature->data()->execState() == ModelAPI_StateMustBeUpdated)
+    return anError;
+
+  // set error indication
+  anError = theFeature->error();
+  if (anError.empty()) {
+    bool isDone = ( theFeature->data()->execState() == ModelAPI_StateDone
+                 || theFeature->data()->execState() == ModelAPI_StateMustBeUpdated );
+    if (!isDone) {
+      anError = toString(theFeature->data()->execState());
+      // If the feature is Composite and error is StateInvalidArgument,
+      // error text should include error of first invalid sub-feature. Otherwise
+      // it is not clear what is the reason of the invalid argument.
+      if (theFeature->data()->execState() == ModelAPI_StateInvalidArgument) {
+        CompositeFeaturePtr aComposite =
+                    std::dynamic_pointer_cast<ModelAPI_CompositeFeature>(theFeature);
+        if (aComposite) {
+          for (int i = 0, aSize = aComposite->numberOfSubs(); i < aSize; i++) {
+            FeaturePtr aSubFeature = aComposite->subFeature(i);
+            std::string aSubFeatureError = getFeatureError(aSubFeature);
+            if (!aSubFeatureError.empty()) {
+              anError = anError + " in " + aSubFeature->getKind() + ".\n" + aSubFeatureError;
+              break;
+            }
+          }
+        }
+      }
+    }
+  }
+
+  return anError;
+}
+
+ObjectPtr objectByName(const DocumentPtr& theDocument, const std::string& theGroup, const std::string& theName)
+{
+  for (int anIndex = 0; anIndex < theDocument->size(theGroup); ++anIndex) {
+    ObjectPtr anObject = theDocument->object(theGroup, anIndex);
+    if (anObject->data()->name() == theName)
+      return anObject;
+  }
+  // not found
+  return ObjectPtr();
+}
+
+bool findVariable(const DocumentPtr& theDocument, 
+                  const std::string& theName, double& outValue, ResultParameterPtr& theParam)
+{
+  ObjectPtr aParamObj = objectByName(theDocument, ModelAPI_ResultParameter::group(), theName);
+  theParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aParamObj);
+  if (!theParam.get())
+    return false;
+  AttributeDoublePtr aValueAttribute = theParam->data()->real(ModelAPI_ResultParameter::VALUE());
+  outValue = aValueAttribute->value();
+  return true;
+}
+
+bool findVariable(const std::string& theName, double& outValue, ResultParameterPtr& theParam,
+                  const DocumentPtr& theDocument /*= DocumentPtr()*/)
 {
   SessionPtr aSession = ModelAPI_Session::get();
   std::list<DocumentPtr> aDocList;
-  DocumentPtr aDocument = aSession->activeDocument();
+  DocumentPtr aDocument = theDocument.get() ? theDocument : aSession->activeDocument();
   DocumentPtr aRootDocument = aSession->moduleDocument();
   aDocList.push_back(aDocument);
   if (aDocument != aRootDocument) {
     aDocList.push_back(aRootDocument);
   }
   for(std::list<DocumentPtr>::const_iterator it = aDocList.begin(); it != aDocList.end(); ++it) {
-    ObjectPtr aParamObj = (*it)->objectByName(ModelAPI_ResultParameter::group(), theName);
-    theParam = std::dynamic_pointer_cast<ModelAPI_ResultParameter>(aParamObj);
-    if(!theParam.get())
-      continue;
-    AttributeDoublePtr aValueAttribute = theParam->data()->real(ModelAPI_ResultParameter::VALUE());
-    outValue = aValueAttribute->value();
-    return true;
+    if (findVariable(*it, theName, outValue, theParam))
+      return true;
   }
   return false;
 }
@@ -147,7 +206,7 @@ void findRandomColor(std::vector<int>& theValues)
     fillColorMap();
   }
 
-  int aSize = myColorMap.size();
+  size_t aSize = myColorMap.size();
   int anIndex = rand() % aSize;
   if (myColorMap.find(anIndex) != myColorMap.end()) {
     theValues = myColorMap.at(anIndex);
@@ -156,14 +215,96 @@ void findRandomColor(std::vector<int>& theValues)
 
 ResultPtr findPartResult(const DocumentPtr& theMain, const DocumentPtr& theSub)
 {
-  for (int a = theMain->size(ModelAPI_ResultPart::group()) - 1; a >= 0; a--) {
-    ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(
-        theMain->object(ModelAPI_ResultPart::group(), a));
-    if (aPart && aPart->data()->document(ModelAPI_ResultPart::DOC_REF())->value() == theSub) {
-      return aPart;
+  if (theMain != theSub) { // to optimize and avoid of crash on partset document close (don't touch the sub-document structure)
+    for (int a = theMain->size(ModelAPI_ResultPart::group()) - 1; a >= 0; a--) {
+      ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(
+          theMain->object(ModelAPI_ResultPart::group(), a));
+      if (aPart && aPart->data()->document(ModelAPI_ResultPart::DOC_REF())->value() == theSub) {
+        return aPart;
+      }
     }
   }
   return ResultPtr();
 }
 
+FeaturePtr findPartFeature(const DocumentPtr& theMain, const DocumentPtr& theSub)
+{
+  if (theMain != theSub) { // to optimize and avoid of crash on partset document close (don't touch the sub-document structure)
+    for (int a = theMain->size(ModelAPI_Feature::group()) - 1; a >= 0; a--) {
+      FeaturePtr aPartFeat = std::dynamic_pointer_cast<ModelAPI_Feature>(
+          theMain->object(ModelAPI_Feature::group(), a));
+      if (aPartFeat.get()) {
+        const std::list<std::shared_ptr<ModelAPI_Result> >& aResList = aPartFeat->results();
+        std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRes = aResList.begin();
+        for(; aRes != aResList.end(); aRes++) {
+          ResultPartPtr aPart = std::dynamic_pointer_cast<ModelAPI_ResultPart>(*aRes);
+          if (aPart.get()) {
+            if (aPart->isActivated() && aPart->partDoc() == theSub)
+              return aPartFeat;
+          } else break; // if the first is not Part, others are also not
+        }
+      }
+    }
+  }
+  return FeaturePtr();
+}
+
+CompositeFeaturePtr compositeOwner(const FeaturePtr& theFeature)
+{
+  if (theFeature.get() && theFeature->data()->isValid()) {
+    const std::set<std::shared_ptr<ModelAPI_Attribute> >& aRefs = theFeature->data()->refsToMe();
+    std::set<std::shared_ptr<ModelAPI_Attribute> >::const_iterator aRefIter = aRefs.begin();
+    for(; aRefIter != aRefs.end(); aRefIter++) {
+      CompositeFeaturePtr aComp = std::dynamic_pointer_cast<ModelAPI_CompositeFeature>
+        ((*aRefIter)->owner());
+      if (aComp.get() && aComp->data()->isValid() && aComp->isSub(theFeature))
+        return aComp;
+    }
+  }
+  return CompositeFeaturePtr(); // not found
+}
+
+ResultCompSolidPtr compSolidOwner(const ResultPtr& theSub)
+{
+  ResultBodyPtr aBody = std::dynamic_pointer_cast<ModelAPI_ResultBody>(theSub);
+  if (aBody.get()) {
+    FeaturePtr aFeatureOwner = aBody->document()->feature(aBody);
+    if (aFeatureOwner.get()) {
+      std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aResIter = 
+        aFeatureOwner->results().cbegin();
+      for(; aResIter != aFeatureOwner->results().cend(); aResIter++) {
+        ResultCompSolidPtr aComp = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aResIter);
+        if (aComp && aComp->isSub(aBody))
+          return aComp;
+      }
+    }
+  }
+  return ResultCompSolidPtr(); // not found
+}
+
+bool hasSubResults(const ResultPtr& theResult)
+{
+  ResultCompSolidPtr aCompSolid = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(theResult);
+  return aCompSolid.get() && aCompSolid->numberOfSubs() > 0;
+}
+
+void allResults(const FeaturePtr& theFeature, std::list<ResultPtr>& theResults)
+{
+  const std::list<std::shared_ptr<ModelAPI_Result> >& aResults = theFeature->results();
+  std::list<std::shared_ptr<ModelAPI_Result> >::const_iterator aRIter = aResults.begin();
+  for (; aRIter != aResults.cend(); aRIter++) {
+    theResults.push_back(*aRIter);
+    // iterate sub-bodies of compsolid
+    ResultCompSolidPtr aComp = std::dynamic_pointer_cast<ModelAPI_ResultCompSolid>(*aRIter);
+    if (aComp.get()) {
+      int aNumSub = aComp->numberOfSubs();
+      for(int a = 0; a < aNumSub; a++) {
+        theResults.push_back(aComp->subResult(a));
+      }
+    }
+  }
+}
+
 } // namespace ModelAPI_Tools
+
+