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);
  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) const
 138 {
 139   const static std::string kDefaultId = "Model_FeatureValidator";
 140   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 141   if(it == myIDs.end())
 142     return;
 143   theValidators.push_back(it->second);
 144 }
 145
 146 bool Model_ValidatorsFactory::validate(const std::shared_ptr<ModelAPI_Feature>& theFeature) const
 147 {
 148   const static std::string kDefaultId = "Model_FeatureValidator";
 149   // check feature validators first
 150   std::map<std::string, AttrValidators>::const_iterator aFeature =
 151     myFeatures.find(theFeature->getKind());
 152   if (aFeature != myFeatures.end()) {
 153     AttrValidators::const_iterator aValidator = aFeature->second.begin();
 154     for(; aValidator != aFeature->second.end(); aValidator++) {
 155       std::map<std::string, ModelAPI_Validator*>::const_iterator aValFind =
 156         myIDs.find(aValidator->first);
 157       if (aValFind == myIDs.end()) {
 158         Events_Error::send(std::string("Validator ") + aValidator->first + " was not registered");
 159         continue;
 160       }
 161       const ModelAPI_FeatureValidator* aFValidator =
 162         dynamic_cast<const ModelAPI_FeatureValidator*>(aValFind->second);
 163       if (aFValidator) {
 164         if (!aFValidator->isValid(theFeature, aValidator->second))
 165           return false;
 166       }
 167     }
 168   }
 169   // check default validator
 170   std::map<std::string, ModelAPI_Validator*>::const_iterator aDefaultVal = myIDs.find(kDefaultId);
 171   if(aDefaultVal != myIDs.end()) {
 172     static const std::list<std::string> anEmptyArgList;
 173     const ModelAPI_FeatureValidator* aFValidator =
 174       dynamic_cast<const ModelAPI_FeatureValidator*>(aDefaultVal->second);
 175     if (aFValidator) {
 176       if (!aFValidator->isValid(theFeature, anEmptyArgList))
 177         return false;
 178     }
 179   }
 180
 181   // check all attributes for validity
 182   std::shared_ptr<ModelAPI_Data> aData = theFeature->data();
 183   // Validity of data is checked by "Model_FeatureValidator" (kDefaultId)
 184   // if (!aData || !aData->isValid())
 185   //   return false;
 186   static const std::string kAllTypes = "";
 187   std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeatureIter =
 188     myAttrs.find(theFeature->getKind());
 189   if (aFeatureIter != myAttrs.cend()) {
 190     std::list<std::string> aLtAttributes = aData->attributesIDs(kAllTypes);
 191     std::list<std::string>::iterator anAttrIter = aLtAttributes.begin();
 192     for (; anAttrIter != aLtAttributes.end(); anAttrIter++) {
 193       std::map<std::string, AttrValidators>::const_iterator anAttr =
 194           aFeatureIter->second.find(*anAttrIter);
 195       if (anAttr != aFeatureIter->second.end()) {
 196         AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
 197         for (; aValIter != anAttr->second.cend(); aValIter++) {
 198           std::map<std::string, ModelAPI_Validator*>::const_iterator aFound = myIDs.find(
 199             aValIter->first);
 200           if (aFound == myIDs.end()) {
 201             Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
 202           } else {
 203             const ModelAPI_AttributeValidator* anAttrValidator =
 204               dynamic_cast<const ModelAPI_AttributeValidator*>(aFound->second);
 205             if (anAttrValidator) {
 206               AttributePtr anAttribute = theFeature->data()->attribute(*anAttrIter);
 207               if (!anAttrValidator->isValid(anAttribute, aValIter->second)) {
 208                   return false;
 209               }
 210             }
 211           }
 212         }
 213       }
 214     }
 215   }
 216   return true;
 217 }
 218
 219 void Model_ValidatorsFactory::registerNotObligatory(std::string theFeature, std::string theAttribute)
 220 {
 221   const static std::string kDefaultId = "Model_FeatureValidator";
 222   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 223   if (it != myIDs.end()) {
 224     Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(it->second);
 225     if (aValidator) {
 226       aValidator->registerNotObligatory(theFeature, theAttribute);
 227     }
 228   }
 229 }
 230
 231 bool Model_ValidatorsFactory::isNotObligatory(std::string theFeature, std::string theAttribute)
 232 {
 233   const static std::string kDefaultId = "Model_FeatureValidator";
 234   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 235   if (it != myIDs.end()) {
 236     Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(it->second);
 237     if (aValidator) {
 238       return aValidator->isNotObligatory(theFeature, theAttribute);
 239     }
 240   }
 241   return false; // default
 242 }
 243
 244 void Model_ValidatorsFactory::registerConcealment(std::string theFeature, std::string theAttribute)
 245 {
 246   std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
 247   if (aFind == myConcealed.end()) {
 248     std::set<std::string> aNewSet;
 249     aNewSet.insert(theAttribute);
 250     myConcealed[theFeature] = aNewSet;
 251   } else {
 252     aFind->second.insert(theAttribute);
 253   }
 254 }
 255
 256 bool Model_ValidatorsFactory::isConcealed(std::string theFeature, std::string theAttribute)
 257 {
 258   std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
 259   return aFind != myConcealed.end() && aFind->second.find(theAttribute) != aFind->second.end();
 260 }