src/ModuleBase/ModuleBase_FilterFactory.cpp

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