Make general validation mechanism also for attributes the validate method for feature...

diff --git a/src/ExchangePlugin/ExchangePlugin_Validators.cpp b/src/ExchangePlugin/ExchangePlugin_Validators.cpp
index 99e14bea9f76ad8363769dfff6a9a9b3fbb3fd1d..2560fb6213837d9cb567e48812f1a6551c600d71 100644 (file)
--- a/src/ExchangePlugin/ExchangePlugin_Validators.cpp
+++ b/src/ExchangePlugin/ExchangePlugin_Validators.cpp
@@ -11,9 +11,8 @@
 #include <string>
 
 
-bool ExchangePlugin_ImportFormatValidator::isValid(const FeaturePtr& theFeature,
-                                                 const std::list<std::string>& theArguments,
-                                                 const ObjectPtr& theObject) const
+bool ExchangePlugin_ImportFormatValidator::isValid(
+  const AttributePtr& theAttribute, const std::list<std::string>& theArguments) const
 {
   PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();

diff --git a/src/ExchangePlugin/ExchangePlugin_Validators.h b/src/ExchangePlugin/ExchangePlugin_Validators.h
index c4400fc9f24d14b076be2fe306ca31f354f6af38..21d72765b0bce158c26a991448a79145a6151844 100644 (file)
--- a/src/ExchangePlugin/ExchangePlugin_Validators.h
+++ b/src/ExchangePlugin/ExchangePlugin_Validators.h
@@ -11,9 +11,8 @@
 class ExchangePlugin_ImportFormatValidator : public ModelAPI_AttributeValidator
 {
  public:
-  virtual bool isValid(const FeaturePtr& theFeature,
-                       const std::list<std::string>& theArguments,
-                       const ObjectPtr& theObject) const;
+  virtual bool isValid(
+    const AttributePtr& theAttribute, const std::list<std::string>& theArguments) const;
 
 };
 

diff --git a/src/Model/Model_Data.cpp b/src/Model/Model_Data.cpp
index d97975153fc87bd3f3bfd72cf710da011ff86d5b..7813c461f4f869b49a2bbfd3a95bcdbc6c262deb 100644 (file)
--- a/src/Model/Model_Data.cpp
+++ b/src/Model/Model_Data.cpp
@@ -251,7 +251,8 @@ bool Model_Data::isValid()
 std::list<boost::shared_ptr<ModelAPI_Attribute> > Model_Data::attributes(const std::string& theType)
 {
   std::list<boost::shared_ptr<ModelAPI_Attribute> > aResult;
-  std::map<std::string, boost::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter = myAttrs.begin();
+  std::map<std::string, boost::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter = 
+    myAttrs.begin();
   for (; anAttrsIter != myAttrs.end(); anAttrsIter++) {
     if (theType.empty() || anAttrsIter->second->attributeType() == theType) {
       aResult.push_back(anAttrsIter->second);
@@ -260,6 +261,19 @@ std::list<boost::shared_ptr<ModelAPI_Attribute> > Model_Data::attributes(const s
   return aResult;
 }
 
+std::list<std::string> Model_Data::attributesIDs(const std::string& theType) 
+{
+  std::list<std::string> aResult;
+  std::map<std::string, boost::shared_ptr<ModelAPI_Attribute> >::iterator anAttrsIter = 
+    myAttrs.begin();
+  for (; anAttrsIter != myAttrs.end(); anAttrsIter++) {
+    if (theType.empty() || anAttrsIter->second->attributeType() == theType) {
+      aResult.push_back(anAttrsIter->first);
+    }
+  }
+  return aResult;
+}
+
 void Model_Data::sendAttributeUpdated(ModelAPI_Attribute* theAttr)
 {
   theAttr->setInitialized();

diff --git a/src/Model/Model_Data.h b/src/Model/Model_Data.h
index 31ff67ff2adcf25fdeb823285c904cecf7b4172f..f8ad2f0a73b214aa0e5a5e5582a63740d2791b4e 100644 (file)
--- a/src/Model/Model_Data.h
+++ b/src/Model/Model_Data.h
@@ -87,10 +87,13 @@ class Model_Data : public ModelAPI_Data
   /// Returns the generic attribute by identifier
   /// \param theID identifier of the attribute
   MODEL_EXPORT virtual boost::shared_ptr<ModelAPI_Attribute> attribute(const std::string& theID);
-  /// Returns all attributes ofthe feature of the given type
+  /// Returns all attributes of the feature of the given type
   /// or all attributes if "theType" is empty
   MODEL_EXPORT virtual std::list<boost::shared_ptr<ModelAPI_Attribute> >
     attributes(const std::string& theType);
+  /// Returns all attributes ids of the feature of the given type
+  /// or all attributes if "theType" is empty
+  MODEL_EXPORT virtual std::list<std::string> attributesIDs(const std::string& theType);
 
   /// Identifier by the id (not fast, iteration by map)
   /// \param theAttr attribute already created in this data

diff --git a/src/Model/Model_FeatureValidator.cpp b/src/Model/Model_FeatureValidator.cpp
index b4b4fb8cc975a6e0a1ea0ee138d3e9a2f5b859e8..2f9894dced86249bc335504808f999e26c1255a2 100644 (file)
--- a/src/Model/Model_FeatureValidator.cpp
+++ b/src/Model/Model_FeatureValidator.cpp
@@ -11,7 +11,8 @@
 #include <list>
 #include <boost/shared_ptr.hpp>
 
-bool Model_FeatureValidator::isValid(const boost::shared_ptr<ModelAPI_Feature>& theFeature) const
+bool Model_FeatureValidator::isValid(const boost::shared_ptr<ModelAPI_Feature>& theFeature,
+  const std::list<std::string>& theArguments) const
 {
   boost::shared_ptr<ModelAPI_Data> aData = theFeature->data();
   if (!aData->isValid())

diff --git a/src/Model/Model_FeatureValidator.h b/src/Model/Model_FeatureValidator.h
index 042621b284268d3d8b771ca0d09e13b42f415fda..901f48ef7fbbf5f656c4d36c6aba2cf25fe0c6d6 100644 (file)
--- a/src/Model/Model_FeatureValidator.h
+++ b/src/Model/Model_FeatureValidator.h
@@ -16,7 +16,8 @@ class Model_FeatureValidator : public ModelAPI_FeatureValidator
  public:
   /// Returns true if feature and/or attributes are valid
   /// \param theFeature the validated feature
-  MODEL_EXPORT virtual bool isValid(const boost::shared_ptr<ModelAPI_Feature>& theFeature) const;
+  MODEL_EXPORT virtual bool isValid(const boost::shared_ptr<ModelAPI_Feature>& theFeature,
+    const std::list<std::string>& theArguments) const;
 };
 
 #endif

diff --git a/src/Model/Model_Validator.cpp b/src/Model/Model_Validator.cpp
index a1741e3b7a81333723483afbb3d5f707f44fdefc..408b20cf5b48659b95d4ccd3f372f9ed3a095492 100644 (file)
--- a/src/Model/Model_Validator.cpp
+++ b/src/Model/Model_Validator.cpp
@@ -5,10 +5,15 @@
 #include <Model_Validator.h>
 #include <Model_FeatureValidator.h>
 #include <ModelAPI_Feature.h>
+#include <ModelAPI_Attribute.h>
+#include <ModelAPI_Data.h>
+#include <ModelAPI_AttributeValidator.h>
 #include <Events_Error.h>
 
+const static std::string DefaultId = "Model_FeatureValidator";
+
 void Model_ValidatorsFactory::registerValidator(const std::string& theID,
-                                                ModelAPI_Validator* theValidator)
+  ModelAPI_Validator* theValidator)
 {
   if (myIDs.find(theID) != myIDs.end()) {
     Events_Error::send(std::string("Validator ") + theID + " is already registered");
@@ -18,7 +23,7 @@ void Model_ValidatorsFactory::registerValidator(const std::string& theID,
 }
 
 void Model_ValidatorsFactory::assignValidator(const std::string& theID,
-                                              const std::string& theFeatureID)
+  const std::string& theFeatureID)
 {
   if (myFeatures.find(theFeatureID) == myFeatures.end()) {
     myFeatures[theFeatureID] = AttrValidators();
@@ -32,8 +37,8 @@ void Model_ValidatorsFactory::assignValidator(const std::string& theID,
 }
 
 void Model_ValidatorsFactory::assignValidator(const std::string& theID,
-                                              const std::string& theFeatureID,
-                                              const std::list<std::string>& theArguments)
+  const std::string& theFeatureID,
+  const std::list<std::string>& theArguments)
 {
   if (myFeatures.find(theFeatureID) == myFeatures.end()) {
     myFeatures[theFeatureID] = AttrValidators();
@@ -48,13 +53,13 @@ void Model_ValidatorsFactory::assignValidator(const std::string& theID,
 }
 
 void Model_ValidatorsFactory::assignValidator(const std::string& theID,
-                                              const std::string& theFeatureID,
-                                              const std::string& theAttrID,
-                                              const std::list<std::string>& theArguments)
+  const std::string& theFeatureID,
+  const std::string& theAttrID,
+  const std::list<std::string>& theArguments)
 {
   // create feature-structures if not exist
   std::map<std::string, std::map<std::string, AttrValidators> >::iterator aFeature = myAttrs.find(
-      theFeatureID);
+    theFeatureID);
   if (aFeature == myAttrs.end()) {
     myAttrs[theFeatureID] = std::map<std::string, AttrValidators>();
     aFeature = myAttrs.find(theFeatureID);
@@ -68,8 +73,8 @@ void Model_ValidatorsFactory::assignValidator(const std::string& theID,
 }
 
 void Model_ValidatorsFactory::validators(const std::string& theFeatureID,
-                                         std::list<ModelAPI_Validator*>& theResult,
-                                         std::list<std::list<std::string> >& theArguments) const
+  std::list<ModelAPI_Validator*>& theResult,
+  std::list<std::list<std::string> >& theArguments) const
 {
   std::map<std::string, AttrValidators>::const_iterator aFeature = myFeatures.find(theFeatureID);
   if (aFeature != myFeatures.cend()) {
@@ -89,19 +94,19 @@ void Model_ValidatorsFactory::validators(const std::string& theFeatureID,
 }
 
 void Model_ValidatorsFactory::validators(const std::string& theFeatureID,
-                                         const std::string& theAttrID,
-                                         std::list<ModelAPI_Validator*>& theValidators,
-                                         std::list<std::list<std::string> >& theArguments) const
+  const std::string& theAttrID,
+  std::list<ModelAPI_Validator*>& theValidators,
+  std::list<std::list<std::string> >& theArguments) const
 {
-  std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeature = myAttrs
-      .find(theFeatureID);
+  std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeature = 
+    myAttrs.find(theFeatureID);
   if (aFeature != myAttrs.cend()) {
     std::map<std::string, AttrValidators>::const_iterator anAttr = aFeature->second.find(theAttrID);
     if (anAttr != aFeature->second.end()) {
       AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
       for (; aValIter != anAttr->second.cend(); aValIter++) {
         std::map<std::string, ModelAPI_Validator*>::const_iterator aFound = myIDs.find(
-            aValIter->first);
+          aValIter->first);
         if (aFound == myIDs.end()) {
           Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
         } else {
@@ -114,7 +119,7 @@ void Model_ValidatorsFactory::validators(const std::string& theFeatureID,
 }
 
 Model_ValidatorsFactory::Model_ValidatorsFactory()
-    : ModelAPI_ValidatorsFactory()
+  : ModelAPI_ValidatorsFactory()
 {
   registerValidator("Model_FeatureValidator", new Model_FeatureValidator);
 }
@@ -130,9 +135,78 @@ const ModelAPI_Validator* Model_ValidatorsFactory::validator(const std::string&
 
 void Model_ValidatorsFactory::addDefaultValidators(std::list<ModelAPI_Validator*>& theValidators) const
 {
-  std::string anId = "Model_FeatureValidator";
-  std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(anId);
+  std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(DefaultId);
   if(it == myIDs.end())
     return;
   theValidators.push_back(it->second);
 }
+
+bool Model_ValidatorsFactory::validate(const boost::shared_ptr<ModelAPI_Feature>& theFeature) const
+{
+  // check feature validators first
+  std::map<std::string, AttrValidators>::const_iterator aFeature = 
+    myFeatures.find(theFeature->getKind());
+  if (aFeature != myFeatures.end()) {
+    AttrValidators::const_iterator aValidator = aFeature->second.begin();
+    for(; aValidator != aFeature->second.end(); aValidator++) {
+      std::map<std::string, ModelAPI_Validator*>::const_iterator aValFind = 
+        myIDs.find(aValidator->first);
+      if (aValFind == myIDs.end()) {
+        Events_Error::send(std::string("Validator ") + aValidator->first + " was not registered");
+        continue;
+      }
+      const ModelAPI_FeatureValidator* aFValidator = 
+        dynamic_cast<const ModelAPI_FeatureValidator*>(aValFind->second);
+      if (aFValidator) {
+        if (!aFValidator->isValid(theFeature, aValidator->second))
+          return false;
+      }
+    }
+  }
+  // check default validator
+  std::map<std::string, ModelAPI_Validator*>::const_iterator aDefaultVal = myIDs.find(DefaultId);
+  if(aDefaultVal != myIDs.end()) {
+    static const std::list<std::string> anEmptyArgList;
+    const ModelAPI_FeatureValidator* aFValidator = 
+      dynamic_cast<const ModelAPI_FeatureValidator*>(aDefaultVal->second);
+    if (aFValidator) {
+      if (!aFValidator->isValid(theFeature, anEmptyArgList))
+        return false;
+    }
+  }
+  // check all attributes for validity
+  boost::shared_ptr<ModelAPI_Data> aData = theFeature->data();
+  if (!aData->isValid())
+    return false;
+  static const std::string kAllTypes = "";
+  std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeatureIter = 
+    myAttrs.find(theFeature->getKind());
+  if (aFeatureIter != myAttrs.cend()) {
+    std::list<std::string> aLtAttributes = aData->attributesIDs(kAllTypes);
+    std::list<std::string>::iterator anAttrIter = aLtAttributes.begin();
+    for (; anAttrIter != aLtAttributes.end(); anAttrIter++) {
+      std::map<std::string, AttrValidators>::const_iterator anAttr = 
+        aFeatureIter->second.find(*anAttrIter);
+      if (anAttr != aFeatureIter->second.end()) {
+        AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
+        for (; aValIter != anAttr->second.cend(); aValIter++) {
+          std::map<std::string, ModelAPI_Validator*>::const_iterator aFound = myIDs.find(
+            aValIter->first);
+          if (aFound == myIDs.end()) {
+            Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
+          } else {
+            const ModelAPI_AttributeValidator* anAttrValidator = 
+              dynamic_cast<const ModelAPI_AttributeValidator*>(aFound->second);
+            if (anAttrValidator) {
+              if (!anAttrValidator->isValid(theFeature->data()->attribute(*anAttrIter),
+                aValIter->second)) {
+                  return false;
+              }
+            }
+          }
+        }
+      }
+    }
+  }
+  return true;
+}

diff --git a/src/Model/Model_Validator.h b/src/Model/Model_Validator.h
index 645c4bdc693271039f2ae640aa87090d4a67b99b..f6f42b3cffc615371204ac532117bd18d965d691 100644 (file)
--- a/src/Model/Model_Validator.h
+++ b/src/Model/Model_Validator.h
@@ -63,12 +63,10 @@ class Model_ValidatorsFactory : public ModelAPI_ValidatorsFactory
                                        std::list<std::list<std::string> >& theArguments) const;
 
   /// Returns registered validator by its Id
-  virtual const ModelAPI_Validator* validator(const std::string& theID) const;
+  MODEL_EXPORT virtual const ModelAPI_Validator* validator(const std::string& theID) const;
 
-  /// Returns the result of "validate" method for attribute of validator.
-  /// If validator is not exists, returns true: everything is valid by default.
-  //MODEL_EXPORT virtual bool validate(
-  //  const boost::shared_ptr<ModelAPI_Feature>& theFeature, const std::string& theAttrID) const;
+  /// Returns true if feature and all its attributes are valid.
+  MODEL_EXPORT virtual bool validate(const boost::shared_ptr<ModelAPI_Feature>& theFeature) const;
 
  protected:
   void addDefaultValidators(std::list<ModelAPI_Validator*>& theValidators) const;

diff --git a/src/ModelAPI/CMakeLists.txt b/src/ModelAPI/CMakeLists.txt
index d7493bb18b737eaaa5cb52db6a59cef492a09b09..ccac1a79e606cb1349438fdfa8ffc0ded4eec812 100644 (file)
--- a/src/ModelAPI/CMakeLists.txt
+++ b/src/ModelAPI/CMakeLists.txt
@@ -28,15 +28,16 @@ SET(PROJECT_HEADERS
     ModelAPI_ResultConstruction.h
     ModelAPI_ResultPart.h
     ModelAPI_ResultParameters.h
-       ModelAPI_ResultValidator.h
-       ModelAPI_AttributeValidator.h
-       ModelAPI_Tools.h
+    ModelAPI_ResultValidator.h
+    ModelAPI_AttributeValidator.h
+    ModelAPI_Tools.h
+    ModelAPI_RefAttrValidator.h 
 )
 
 SET(PROJECT_SOURCES
     ModelAPI_Feature.cpp
     ModelAPI_PluginManager.cpp
-       ModelAPI_Tools.cpp
+    ModelAPI_Tools.cpp
 )
 
 SET(PROJECT_LIBRARIES

diff --git a/src/ModelAPI/ModelAPI_Attribute.h b/src/ModelAPI/ModelAPI_Attribute.h
index 8e2051ac253773a0b824ffb666e12a9ca6e8a16f..a73044d4a1ebcd57319cc2cd3548bb3ef7e55f9f 100644 (file)
--- a/src/ModelAPI/ModelAPI_Attribute.h
+++ b/src/ModelAPI/ModelAPI_Attribute.h
@@ -40,7 +40,7 @@ class ModelAPI_Attribute
   }
 
   /// Returns the owner of this attribute
-  MODELAPI_EXPORT const boost::shared_ptr<ModelAPI_Object>& owner()
+  MODELAPI_EXPORT const boost::shared_ptr<ModelAPI_Object>& owner() const
   {
     return myObject;
   }

diff --git a/src/ModelAPI/ModelAPI_AttributeValidator.h b/src/ModelAPI/ModelAPI_AttributeValidator.h
index 15b8514ec9302c3fa6337af06c7fda16eadbe0d1..63a1b9e6fb8e8e103e5a73b3a50b220f086acf08 100644 (file)
--- a/src/ModelAPI/ModelAPI_AttributeValidator.h
+++ b/src/ModelAPI/ModelAPI_AttributeValidator.h
@@ -1,19 +1,24 @@
 // File:        ModelAPI_AttributeValidator.h
-// Created:     5 Aug 2014
-// Author:      Vitaly SMETANNIKOV
+// Created:     4 Sep 2014
+// Author:      Mikhail PONIKAROV
 
 #ifndef ModelAPI_AttributeValidator_H
 #define ModelAPI_AttributeValidator_H
 
-#include <ModelAPI_Feature.h>
-#include <ModelAPI_Object.h>
+#include <ModelAPI_Attribute.h>
 #include <ModelAPI_Validator.h>
 
+/**
+ * Generic validator for any attribute of a feature.
+ */
 class ModelAPI_AttributeValidator : public ModelAPI_Validator
 {
- public:
-  virtual bool isValid(const FeaturePtr& theFeature, const std::list<std::string>& theArguments,
-                       const ObjectPtr& theObject) const = 0;
+public:
+  //! returns true if attribute is valid
+  //! \param theAttribute the checked attribute
+  //! \param theArguments arguments of the attribute
+  virtual bool isValid(
+    const AttributePtr& theAttribute, const std::list<std::string>& theArguments) const = 0;
 };
 
 #endif

diff --git a/src/ModelAPI/ModelAPI_Data.h b/src/ModelAPI/ModelAPI_Data.h
index ba9691136bb3566f661ec5445f5dd35fa38246d2..c4fe4712f1f5ce7dedcee88a4c451b617d12a9b8 100644 (file)
--- a/src/ModelAPI/ModelAPI_Data.h
+++ b/src/ModelAPI/ModelAPI_Data.h
@@ -58,10 +58,13 @@ class MODELAPI_EXPORT ModelAPI_Data
   /// Returns the generic attribute by identifier
   /// \param theID identifier of the attribute
   virtual boost::shared_ptr<ModelAPI_Attribute> attribute(const std::string& theID) = 0;
-  /// Returns all attributes ofthe feature of the given type
+  /// Returns all attributes of the feature of the given type
   /// or all attributes if "theType" is empty
   virtual std::list<boost::shared_ptr<ModelAPI_Attribute> >
   attributes(const std::string& theType) = 0;
+  /// Returns all attributes ids of the feature of the given type
+  /// or all attributes if "theType" is empty
+  virtual std::list<std::string> attributesIDs(const std::string& theType) = 0;
   /// Identifier by the id (not fast, iteration by map)
   /// \param theAttr attribute already created in this data
   virtual const std::string& id(const boost::shared_ptr<ModelAPI_Attribute>& theAttr) = 0;

diff --git a/src/ModelAPI/ModelAPI_FeatureValidator.h b/src/ModelAPI/ModelAPI_FeatureValidator.h
index 7508c7ad3d30eaf9405f6375e5546e0378267c4c..3dafdf813bd47fabf465166060727511c27581b1 100644 (file)
--- a/src/ModelAPI/ModelAPI_FeatureValidator.h
+++ b/src/ModelAPI/ModelAPI_FeatureValidator.h
@@ -15,7 +15,8 @@ class ModelAPI_FeatureValidator : public ModelAPI_Validator
   /// \param theFeature the validated feature
   /// \param theAttr the validated attribute ID, empty string of feature is validated
   /// \param theArguments list of string, feature attribute names: dependent attributes
-  virtual bool isValid(const boost::shared_ptr<ModelAPI_Feature>& theFeature) const = 0;
+  virtual bool isValid(const boost::shared_ptr<ModelAPI_Feature>& theFeature,
+    const std::list<std::string>& theArguments) const = 0;
 };
 
 #endif

diff --git a/src/ModelAPI/ModelAPI_RefAttrValidator.h b/src/ModelAPI/ModelAPI_RefAttrValidator.h
new file mode 100644 (file)
index 0000000..e5b1b66
--- /dev/null
+++ b/src/ModelAPI/ModelAPI_RefAttrValidator.h
@@ -0,0 +1,23 @@
+// File:        ModelAPI_RefAttrValidator.h
+// Created:     5 Aug 2014
+// Author:      Vitaly SMETANNIKOV
+
+#ifndef ModelAPI_RefAttrValidator_H
+#define ModelAPI_RefAttrValidator_H
+
+#include <ModelAPI_Feature.h>
+#include <ModelAPI_Object.h>
+#include <ModelAPI_AttributeValidator.h>
+
+/*
+ * Used for filtering out the object that can be used for reference attribute value
+ */
+class ModelAPI_RefAttrValidator : public ModelAPI_AttributeValidator
+{
+public:
+  //! Returns true if object is good for the feature attribute
+  virtual bool isValid(const FeaturePtr& theFeature, const std::list<std::string>& theArguments,
+                       const ObjectPtr& theObject) const = 0;
+};
+
+#endif

diff --git a/src/ModelAPI/ModelAPI_Validator.h b/src/ModelAPI/ModelAPI_Validator.h
index 78754d074e3dd581c6ebb6ba97b7751af8566cb6..a3e378856fe3538a94031d99f364c7c1260e2180 100644 (file)
--- a/src/ModelAPI/ModelAPI_Validator.h
+++ b/src/ModelAPI/ModelAPI_Validator.h
@@ -83,10 +83,8 @@ class MODELAPI_EXPORT ModelAPI_ValidatorsFactory
   /// Returns registered validator by its Id
   virtual const ModelAPI_Validator* validator(const std::string& theID) const = 0;
 
-  /// Returns the result of "validate" method for attribute of validator.
-  /// If validator is not exists, returns true: everything is valid by default.
-  //virtual bool validate(
-  //  const boost::shared_ptr<ModelAPI_Feature>& theFeature, const std::string& theAttrID) const = 0;
+  /// Returns true if feature and all its attributes are valid.
+  virtual bool validate(const boost::shared_ptr<ModelAPI_Feature>& theFeature) const = 0;
 
  protected:
   /// Get instance from PluginManager

diff --git a/src/ModuleBase/ModuleBase_WidgetFeature.cpp b/src/ModuleBase/ModuleBase_WidgetFeature.cpp
index 08cb49f0001123a533f76da9c1c388fed6ba32ac..e7c510a8385a0cfaea7d3fa94b6e5eb16246289a 100644 (file)
--- a/src/ModuleBase/ModuleBase_WidgetFeature.cpp
+++ b/src/ModuleBase/ModuleBase_WidgetFeature.cpp
@@ -19,7 +19,7 @@
 #include <ModelAPI_AttributeRefAttr.h>
 #include <ModelAPI_Validator.h>
 #include <ModelAPI_ResultValidator.h>
-#include <ModelAPI_AttributeValidator.h>
+#include <ModelAPI_RefAttrValidator.h>
 
 #include <QWidget>
 #include <QLineEdit>
@@ -98,8 +98,8 @@ bool ModuleBase_WidgetFeature::setObject(const ObjectPtr& theObject, bool theSen
   aValidator = aValidators.begin();
   std::list<std::list<std::string> >::iterator aArgs = anArguments.begin();
   for (; aValidator != aValidators.end(); aValidator++, aArgs++) {
-    const ModelAPI_AttributeValidator* aAttrValidator =
-        dynamic_cast<const ModelAPI_AttributeValidator*>(*aValidator);
+    const ModelAPI_RefAttrValidator* aAttrValidator =
+        dynamic_cast<const ModelAPI_RefAttrValidator*>(*aValidator);
     if (aAttrValidator) {
       if (!aAttrValidator->isValid(myFeature, *aArgs, theObject)) {
         return false;

diff --git a/src/SketchPlugin/SketchPlugin_ResultValidators.cpp b/src/SketchPlugin/SketchPlugin_ResultValidators.cpp
index e40022f7cdc1cf10529424c8e6dbbfb9b8b1ee4d..0e39fcb0349631b93175cafb88c913c7ea4440e9 100644 (file)
--- a/src/SketchPlugin/SketchPlugin_ResultValidators.cpp
+++ b/src/SketchPlugin/SketchPlugin_ResultValidators.cpp
@@ -39,4 +39,3 @@ bool SketchPlugin_ResultArcValidator::isValid(const ObjectPtr theObject) const
   boost::shared_ptr<GeomAPI_Shape> aShape = ModelAPI_Tools::shape(aResult);
   return aShape && aShape->isEdge() && GeomAPI_Curve(aShape).isCircle();
 }
-

diff --git a/src/SketchPlugin/SketchPlugin_Validators.cpp b/src/SketchPlugin/SketchPlugin_Validators.cpp
index 50af2be895a9e3c0880f63fc44e56ab56af7bb17..4115d11a4038b0ae522376672b847ddd0fae4d3e 100644 (file)
--- a/src/SketchPlugin/SketchPlugin_Validators.cpp
+++ b/src/SketchPlugin/SketchPlugin_Validators.cpp
@@ -30,3 +30,15 @@ bool SketchPlugin_DistanceAttrValidator::isValid(const FeaturePtr& theFeature,
   return false;
 }
 
+bool SketchPlugin_DistanceAttrValidator::isValid(
+  const AttributePtr& theAttribute, const std::list<std::string>& theArguments ) const
+{
+  boost::shared_ptr<ModelAPI_AttributeRefAttr> anAttr = 
+    boost::dynamic_pointer_cast<ModelAPI_AttributeRefAttr>(theAttribute);
+  if (anAttr) {
+    const ObjectPtr& anObj = theAttribute->owner();
+    const FeaturePtr aFeature = boost::dynamic_pointer_cast<ModelAPI_Feature>(anObj);
+    return isValid(aFeature, theArguments, anAttr->object());
+  }
+  return true; // it may be not reference attribute, in this case, it is OK
+}

diff --git a/src/SketchPlugin/SketchPlugin_Validators.h b/src/SketchPlugin/SketchPlugin_Validators.h
index 38ba0291698ce31d9ca27e8251f5a2c6e6a55018..4da0f73e92f21641a304fb8a98ea75aecfe71ff0 100644 (file)
--- a/src/SketchPlugin/SketchPlugin_Validators.h
+++ b/src/SketchPlugin/SketchPlugin_Validators.h
@@ -6,12 +6,17 @@
 #define SketchPlugin_Validators_H
 
 #include "SketchPlugin.h"
-//#include <ModuleBase_FeatureValidator.h>
-#include <ModelAPI_AttributeValidator.h>
+#include <ModelAPI_RefAttrValidator.h>
 
 class SketchPlugin_DistanceAttrValidator : public ModelAPI_AttributeValidator
 {
  public:
+  //! returns true if attribute is valid
+  //! \param theAttribute the checked attribute
+  //! \param theArguments arguments of the attribute
+  virtual bool isValid(
+    const AttributePtr& theAttribute, const std::list<std::string>& theArguments) const;
+  //! Returns true if object is good for the feature attribute
   virtual bool isValid(const FeaturePtr& theFeature, const std::list<std::string>& theArguments,
                        const ObjectPtr& theObject) const;
 

diff --git a/src/XGUI/XGUI_OperationMgr.cpp b/src/XGUI/XGUI_OperationMgr.cpp
index c5972b9b9ba77444a78279cef7437a84221ee9e5..88e625e36297aa367d362e2d540796259eb35786 100644 (file)
--- a/src/XGUI/XGUI_OperationMgr.cpp
+++ b/src/XGUI/XGUI_OperationMgr.cpp
@@ -84,22 +84,8 @@ void XGUI_OperationMgr::validateOperation(ModuleBase_Operation* theOperation)
   //Get validators for the Id
   PluginManagerPtr aMgr = ModelAPI_PluginManager::get();
   ModelAPI_ValidatorsFactory* aFactory = aMgr->validators();
-  std::list<ModelAPI_Validator*> aValidators;
-  std::list<std::list<std::string> > anArguments;
-  aFactory->validators(anOperationId.toStdString(), aValidators, anArguments);
-  //
-  std::list<ModelAPI_Validator*>::iterator it = aValidators.begin();
-  bool isValid = true;
-  for (; it != aValidators.end(); it++) {
-    const ModelAPI_FeatureValidator* aFeatureValidator =
-        dynamic_cast<const ModelAPI_FeatureValidator*>(*it);
-    if (!aFeatureValidator)
-      continue;
-    if (!aFeatureValidator->isValid(aFeature)) {
-      isValid = false;
-      break;
-    }
-  }
+
+  bool isValid = aFactory->validate(aFeature);
   emit operationValidated(isValid);
 }