src/Model/Model_Validator.cpp

   1 // File:        Model_Validator.cpp
   2 // Created:     2 Jul 2014
   3 // Author:      Mikhail PONIKAROV
   4
   5 #include <Model_Validator.h>
   6 #include <Model_FeatureValidator.h>
   7 #include <ModelAPI_Feature.h>
   8 #include <ModelAPI_Attribute.h>
   9 #include <ModelAPI_Data.h>
  10 #include <ModelAPI_AttributeValidator.h>
  11 #include <Events_Error.h>
  12
  13 void Model_ValidatorsFactory::registerValidator(const std::string& theID,
  14   ModelAPI_Validator* theValidator)
  15 {
  16   if (myIDs.find(theID) != myIDs.end()) {
  17     Events_Error::send(std::string("Validator ") + theID + " is already registered");
  18   } else {
  19     myIDs[theID] = theValidator;
  20   }
  21 }
  22
  23 void Model_ValidatorsFactory::assignValidator(const std::string& theID,
  24   const std::string& theFeatureID)
  25 {
  26   if (myFeatures.find(theFeatureID) == myFeatures.end()) {
  27     myFeatures[theFeatureID] = AttrValidators();
  28   }
  29   if (myFeatures[theFeatureID].find(theID) != myFeatures[theFeatureID].end()) {
  30     //Events_Error::send(std::string("Validator ") + theID +
  31     //  " for feature " + theFeatureID + "is already registered");
  32   } else {
  33     myFeatures[theFeatureID][theID] = std::list<std::string>();
  34   }
  35 }
  36
  37 void Model_ValidatorsFactory::assignValidator(const std::string& theID,
  38   const std::string& theFeatureID,
  39   const std::list<std::string>& theArguments)
  40 {
  41   if (myFeatures.find(theFeatureID) == myFeatures.end()) {
  42     myFeatures[theFeatureID] = AttrValidators();
  43   }
  44
  45   if (myFeatures[theFeatureID].find(theID) != myFeatures[theFeatureID].end()) {
  46     //Events_Error::send(std::string("Validator ") + theID +
  47     //  " for feature " + theFeatureID + "is already registered");
  48   } else {
  49     myFeatures[theFeatureID][theID] = theArguments;
  50   }
  51 }
  52
  53 void Model_ValidatorsFactory::assignValidator(const std::string& theID,
  54   const std::string& theFeatureID,
  55   const std::string& theAttrID,
  56   const std::list<std::string>& theArguments)
  57 {
  58   // create feature-structures if not exist
  59   std::map<std::string, std::map<std::string, AttrValidators> >::iterator aFeature = myAttrs.find(
  60     theFeatureID);
  61   if (aFeature == myAttrs.end()) {
  62     myAttrs[theFeatureID] = std::map<std::string, AttrValidators>();
  63     aFeature = myAttrs.find(theFeatureID);
  64   }
  65   // add attr-structure if not exist, or generate error if already exist
  66   std::map<std::string, AttrValidators>::iterator anAttr = aFeature->second.find(theAttrID);
  67   if (anAttr == aFeature->second.end()) {
  68     aFeature->second[theAttrID] = AttrValidators();
  69   }
  70   aFeature->second[theAttrID][theID] = theArguments;
  71 }
  72
  73 void Model_ValidatorsFactory::validators(const std::string& theFeatureID,
  74   std::list<ModelAPI_Validator*>& theResult,
  75   std::list<std::list<std::string> >& theArguments) const
  76 {
  77   std::map<std::string, AttrValidators>::const_iterator aFeature = myFeatures.find(theFeatureID);
  78   if (aFeature != myFeatures.cend()) {
  79     AttrValidators::const_iterator aValIter = aFeature->second.cbegin();
  80     for (; aValIter != aFeature->second.cend(); aValIter++) {
  81       std::map<std::string, ModelAPI_Validator*>::const_iterator aFound =
  82         myIDs.find(aValIter->first);
  83       if (aFound == myIDs.end()) {
  84         Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
  85       } else {
  86         theResult.push_back(aFound->second);
  87         theArguments.push_back(aValIter->second);
  88       }
  89     }
  90   }
  91   addDefaultValidators(theResult);
  92 }
  93
  94 void Model_ValidatorsFactory::validators(const std::string& theFeatureID,
  95   const std::string& theAttrID,
  96   std::list<ModelAPI_Validator*>& theValidators,
  97   std::list<std::list<std::string> >& theArguments) const
  98 {
  99   std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeature =
 100     myAttrs.find(theFeatureID);
 101   if (aFeature != myAttrs.cend()) {
 102     std::map<std::string, AttrValidators>::const_iterator anAttr = aFeature->second.find(theAttrID);
 103     if (anAttr != aFeature->second.end()) {
 104       AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
 105       for (; aValIter != anAttr->second.cend(); aValIter++) {
 106         std::map<std::string, ModelAPI_Validator*>::const_iterator aFound = myIDs.find(
 107           aValIter->first);
 108         if (aFound == myIDs.end()) {
 109           Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
 110         } else {
 111           theValidators.push_back(aFound->second);
 112           theArguments.push_back(aValIter->second);
 113         }
 114       }
 115     }
 116   }
 117 }
 118
 119 Model_ValidatorsFactory::Model_ValidatorsFactory()
 120   : ModelAPI_ValidatorsFactory()
 121 {
 122   const static std::string kDefaultId = "Model_FeatureValidator";
 123   registerValidator(kDefaultId, new Model_FeatureValidator);
 124 }
 125
 126 const ModelAPI_Validator* Model_ValidatorsFactory::validator(const std::string& theID) const
 127 {
 128   std::map<std::string, ModelAPI_Validator*>::const_iterator aIt = myIDs.find(theID);
 129   if (aIt != myIDs.end()) {
 130     return aIt->second;
 131   }
 132   return NULL;
 133 }
 134
 135 void Model_ValidatorsFactory::addDefaultValidators(std::list<ModelAPI_Validator*>& theValidators) const
 136 {
 137   const static std::string kDefaultId = "Model_FeatureValidator";
 138   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 139   if(it == myIDs.end())
 140     return;
 141   theValidators.push_back(it->second);
 142 }
 143
 144 bool Model_ValidatorsFactory::validate(const std::shared_ptr<ModelAPI_Feature>& theFeature) const
 145 {
 146   const static std::string kDefaultId = "Model_FeatureValidator";
 147   // check feature validators first
 148   std::map<std::string, AttrValidators>::const_iterator aFeature =
 149     myFeatures.find(theFeature->getKind());
 150   if (aFeature != myFeatures.end()) {
 151     AttrValidators::const_iterator aValidator = aFeature->second.begin();
 152     for(; aValidator != aFeature->second.end(); aValidator++) {
 153       std::map<std::string, ModelAPI_Validator*>::const_iterator aValFind =
 154         myIDs.find(aValidator->first);
 155       if (aValFind == myIDs.end()) {
 156         Events_Error::send(std::string("Validator ") + aValidator->first + " was not registered");
 157         continue;
 158       }
 159       const ModelAPI_FeatureValidator* aFValidator =
 160         dynamic_cast<const ModelAPI_FeatureValidator*>(aValFind->second);
 161       if (aFValidator) {
 162         if (!aFValidator->isValid(theFeature, aValidator->second))
 163           return false;
 164       }
 165     }
 166   }
 167   // check default validator
 168   std::map<std::string, ModelAPI_Validator*>::const_iterator aDefaultVal = myIDs.find(kDefaultId);
 169   if(aDefaultVal != myIDs.end()) {
 170     static const std::list<std::string> anEmptyArgList;
 171     const ModelAPI_FeatureValidator* aFValidator =
 172       dynamic_cast<const ModelAPI_FeatureValidator*>(aDefaultVal->second);
 173     if (aFValidator) {
 174       if (!aFValidator->isValid(theFeature, anEmptyArgList))
 175         return false;
 176     }
 177   }
 178
 179   // check all attributes for validity
 180   std::shared_ptr<ModelAPI_Data> aData = theFeature->data();
 181   // Validity of data is checked by "Model_FeatureValidator" (kDefaultId)
 182   // if (!aData || !aData->isValid())
 183   //   return false;
 184   static const std::string kAllTypes = "";
 185   std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeatureIter =
 186     myAttrs.find(theFeature->getKind());
 187   if (aFeatureIter != myAttrs.cend()) {
 188     std::list<std::string> aLtAttributes = aData->attributesIDs(kAllTypes);
 189     std::list<std::string>::iterator anAttrIter = aLtAttributes.begin();
 190     for (; anAttrIter != aLtAttributes.end(); anAttrIter++) {
 191       std::map<std::string, AttrValidators>::const_iterator anAttr =
 192           aFeatureIter->second.find(*anAttrIter);
 193       if (anAttr != aFeatureIter->second.end()) {
 194         AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
 195         for (; aValIter != anAttr->second.cend(); aValIter++) {
 196           std::map<std::string, ModelAPI_Validator*>::const_iterator aFound = myIDs.find(
 197             aValIter->first);
 198           if (aFound == myIDs.end()) {
 199             Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
 200           } else {
 201             const ModelAPI_AttributeValidator* anAttrValidator =
 202               dynamic_cast<const ModelAPI_AttributeValidator*>(aFound->second);
 203             if (anAttrValidator) {
 204               AttributePtr anAttribute = theFeature->data()->attribute(*anAttrIter);
 205               if (!anAttrValidator->isValid(anAttribute, aValIter->second)) {
 206                   return false;
 207               }
 208             }
 209           }
 210         }
 211       }
 212     }
 213   }
 214   return true;
 215 }
 216
 217 void Model_ValidatorsFactory::registerNotObligatory(std::string theFeature, std::string theAttribute)
 218 {
 219   const static std::string kDefaultId = "Model_FeatureValidator";
 220   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 221   if (it != myIDs.end()) {
 222     Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(it->second);
 223     if (aValidator) {
 224       aValidator->registerNotObligatory(theFeature, theAttribute);
 225     }
 226   }
 227 }
 228
 229 bool Model_ValidatorsFactory::isNotObligatory(std::string theFeature, std::string theAttribute)
 230 {
 231   const static std::string kDefaultId = "Model_FeatureValidator";
 232   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 233   if (it != myIDs.end()) {
 234     Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(it->second);
 235     if (aValidator) {
 236       return aValidator->isNotObligatory(theFeature, theAttribute);
 237     }
 238   }
 239   return false; // default
 240 }
 241
 242 void Model_ValidatorsFactory::registerConcealment(std::string theFeature, std::string theAttribute)
 243 {
 244   std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
 245   if (aFind == myConcealed.end()) {
 246     std::set<std::string> aNewSet;
 247     aNewSet.insert(theAttribute);
 248     myConcealed[theFeature] = aNewSet;
 249   } else {
 250     aFind->second.insert(theAttribute);
 251   }
 252 }
 253
 254 bool Model_ValidatorsFactory::isConcealed(std::string theFeature, std::string theAttribute)
 255 {
 256   std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
 257   return aFind != myConcealed.end() && aFind->second.find(theAttribute) != aFind->second.end();
 258 }