src/Model/Model_Validator.cpp

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