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 const static std::string kDefaultId = "Model_FeatureValidator";
  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   registerValidator(kDefaultId, new Model_FeatureValidator);
 125 }
 126
 127 const ModelAPI_Validator* Model_ValidatorsFactory::validator(const std::string& theID) const
 128 {
 129   std::map<std::string, ModelAPI_Validator*>::const_iterator aIt = myIDs.find(theID);
 130   if (aIt != myIDs.end()) {
 131     return aIt->second;
 132   }
 133   return NULL;
 134 }
 135
 136 void Model_ValidatorsFactory::addDefaultValidators(std::list<ModelAPI_Validator*>& theValidators) const
 137 {
 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 boost::shared_ptr<ModelAPI_Feature>& theFeature) const
 145 {
 146   // check feature validators first
 147   std::map<std::string, AttrValidators>::const_iterator aFeature =
 148     myFeatures.find(theFeature->getKind());
 149   if (aFeature != myFeatures.end()) {
 150     AttrValidators::const_iterator aValidator = aFeature->second.begin();
 151     for(; aValidator != aFeature->second.end(); aValidator++) {
 152       std::map<std::string, ModelAPI_Validator*>::const_iterator aValFind =
 153         myIDs.find(aValidator->first);
 154       if (aValFind == myIDs.end()) {
 155         Events_Error::send(std::string("Validator ") + aValidator->first + " was not registered");
 156         continue;
 157       }
 158       const ModelAPI_FeatureValidator* aFValidator =
 159         dynamic_cast<const ModelAPI_FeatureValidator*>(aValFind->second);
 160       if (aFValidator) {
 161         if (!aFValidator->isValid(theFeature, aValidator->second))
 162           return false;
 163       }
 164     }
 165   }
 166   // check default validator
 167   std::map<std::string, ModelAPI_Validator*>::const_iterator aDefaultVal = myIDs.find(kDefaultId);
 168   if(aDefaultVal != myIDs.end()) {
 169     static const std::list<std::string> anEmptyArgList;
 170     const ModelAPI_FeatureValidator* aFValidator =
 171       dynamic_cast<const ModelAPI_FeatureValidator*>(aDefaultVal->second);
 172     if (aFValidator) {
 173       if (!aFValidator->isValid(theFeature, anEmptyArgList))
 174         return false;
 175     }
 176   }
 177   // check all attributes for validity
 178   boost::shared_ptr<ModelAPI_Data> aData = theFeature->data();
 179   if (!aData->isValid())
 180     return false;
 181   static const std::string kAllTypes = "";
 182   std::map<std::string, std::map<std::string, AttrValidators> >::const_iterator aFeatureIter =
 183     myAttrs.find(theFeature->getKind());
 184   if (aFeatureIter != myAttrs.cend()) {
 185     std::list<std::string> aLtAttributes = aData->attributesIDs(kAllTypes);
 186     std::list<std::string>::iterator anAttrIter = aLtAttributes.begin();
 187     for (; anAttrIter != aLtAttributes.end(); anAttrIter++) {
 188       std::map<std::string, AttrValidators>::const_iterator anAttr =
 189           aFeatureIter->second.find(*anAttrIter);
 190       if (anAttr != aFeatureIter->second.end()) {
 191         AttrValidators::const_iterator aValIter = anAttr->second.cbegin();
 192         for (; aValIter != anAttr->second.cend(); aValIter++) {
 193           std::map<std::string, ModelAPI_Validator*>::const_iterator aFound = myIDs.find(
 194             aValIter->first);
 195           if (aFound == myIDs.end()) {
 196             Events_Error::send(std::string("Validator ") + aValIter->first + " was not registered");
 197           } else {
 198             const ModelAPI_AttributeValidator* anAttrValidator =
 199               dynamic_cast<const ModelAPI_AttributeValidator*>(aFound->second);
 200             if (anAttrValidator) {
 201               AttributePtr anAttribute = theFeature->data()->attribute(*anAttrIter);
 202               if (!anAttrValidator->isValid(anAttribute, aValIter->second)) {
 203                   return false;
 204               }
 205             }
 206           }
 207         }
 208       }
 209     }
 210   }
 211   return true;
 212 }
 213
 214 void Model_ValidatorsFactory::registerNotObligatory(std::string theFeature, std::string theAttribute)
 215 {
 216   std::map<std::string, ModelAPI_Validator*>::const_iterator it = myIDs.find(kDefaultId);
 217   if (it != myIDs.end()) {
 218     Model_FeatureValidator* aValidator = dynamic_cast<Model_FeatureValidator*>(it->second);
 219     if (aValidator) {
 220       aValidator->registerNotObligatory(theFeature, theAttribute);
 221     }
 222   }
 223 }
 224
 225 void Model_ValidatorsFactory::registerConcealment(std::string theFeature, std::string theAttribute)
 226 {
 227   std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
 228   if (aFind == myConcealed.end()) {
 229     std::set<std::string> aNewSet;
 230     aNewSet.insert(theAttribute);
 231     myConcealed[theFeature] = aNewSet;
 232   } else {
 233     aFind->second.insert(theAttribute);
 234   }
 235 }
 236
 237 bool Model_ValidatorsFactory::isConcealed(std::string theFeature, std::string theAttribute)
 238 {
 239   std::map<std::string, std::set<std::string> >::iterator aFind = myConcealed.find(theFeature);
 240   return aFind != myConcealed.end() && aFind->second.find(theAttribute) != aFind->second.end();
 241 }