X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Validator.cpp;h=3059ea572df8226c088604be4a3cad0d1350a518;hb=8d9373fd00a410b2e9fc7ac6b0653716314ded2d;hp=4f2041c36bfd7d70837317c2d39b2a492a99f975;hpb=cadc20ebc46d01b4d8ac0e91cc8e6fd1066867cb;p=modules%2Fshaper.git diff --git a/src/Model/Model_Validator.cpp b/src/Model/Model_Validator.cpp index 4f2041c36..3059ea572 100644 --- a/src/Model/Model_Validator.cpp +++ b/src/Model/Model_Validator.cpp @@ -1,8 +1,21 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: Model_Validator.cpp -// Created: 2 Jul 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2019 CEA/DEN, EDF R&D +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. +// +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. +// +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA +// +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com +// #include "Model_Validator.h" @@ -13,15 +26,18 @@ #include #include #include +#include #include -#include +#include + +#include void Model_ValidatorsFactory::registerValidator(const std::string& theID, ModelAPI_Validator* theValidator) { if (myIDs.find(theID) != myIDs.end()) { - Events_Error::send(std::string("Validator ") + theID + " is already registered"); + Events_InfoMessage("Model_Validator", "Validator %1 is already registered").arg(theID).send(); } else { myIDs[theID] = theValidator; } @@ -34,7 +50,7 @@ void Model_ValidatorsFactory::assignValidator(const std::string& theID, myFeatures[theFeatureID] = AttrValidators(); } if (myFeatures[theFeatureID].find(theID) != myFeatures[theFeatureID].end()) { - //Events_Error::send(std::string("Validator ") + theID + + //Events_Error::send(std::string("Validator ") + theID + // " for feature " + theFeatureID + "is already registered"); } else { myFeatures[theFeatureID][theID] = std::list(); @@ -50,7 +66,7 @@ void Model_ValidatorsFactory::assignValidator(const std::string& theID, } if (myFeatures[theFeatureID].find(theID) != myFeatures[theFeatureID].end()) { - //Events_Error::send(std::string("Validator ") + theID + + //Events_Error::send(std::string("Validator ") + theID + // " for feature " + theFeatureID + "is already registered"); } else { myFeatures[theFeatureID][theID] = theArguments; @@ -80,13 +96,14 @@ void Model_ValidatorsFactory::assignValidator(const std::string& theID, void Model_ValidatorsFactory::validators(const std::string& theFeatureID, Validators& theValidators) const { - std::map::const_iterator aFeatureIt = + std::map::const_iterator aFeatureIt = myFeatures.find(theFeatureID); if (aFeatureIt != myFeatures.cend()) { AttrValidators::const_iterator aValidatorsIt = aFeatureIt->second.cbegin(); for (; aValidatorsIt != aFeatureIt->second.cend(); aValidatorsIt++) { if (!validator(aValidatorsIt->first)) { - Events_Error::send(std::string("Validator ") + aValidatorsIt->first + " was not registered"); + Events_InfoMessage("Model_Validator", "Validator %1 was not registered") + .arg(aValidatorsIt->first).send(); } else { theValidators.push_back(std::make_pair(aValidatorsIt->first, aValidatorsIt->second)); } @@ -95,18 +112,21 @@ void Model_ValidatorsFactory::validators(const std::string& theFeatureID, addDefaultValidators(theValidators); } -void Model_ValidatorsFactory::validators(const std::string& theFeatureID, const std::string& theAttrID, +void Model_ValidatorsFactory::validators(const std::string& theFeatureID, + const std::string& theAttrID, Validators& theValidators) const { - std::map >::const_iterator aFeatureIt = + std::map >::const_iterator aFeatureIt = myAttrs.find(theFeatureID); if (aFeatureIt != myAttrs.cend()) { - std::map::const_iterator anAttrIt = aFeatureIt->second.find(theAttrID); + std::map::const_iterator anAttrIt = + aFeatureIt->second.find(theAttrID); if (anAttrIt != aFeatureIt->second.end()) { AttrValidators::const_iterator aValidatorsIt = anAttrIt->second.cbegin(); for (; aValidatorsIt != anAttrIt->second.cend(); aValidatorsIt++) { if (!validator(aValidatorsIt->first)) { - Events_Error::send(std::string("Validator ") + aValidatorsIt->first + " was not registered"); + Events_InfoMessage("Model_Validator", "Validator %1 was not registered") + .arg(aValidatorsIt->first).send(); } else { theValidators.push_back(std::make_pair(aValidatorsIt->first, aValidatorsIt->second)); } @@ -167,67 +187,44 @@ bool Model_ValidatorsFactory::validate(const std::shared_ptr& for(; aValidatorIt != aValidators.cend(); aValidatorIt++) { const std::string& aValidatorID = aValidatorIt->first; const std::list& anArguments = aValidatorIt->second; - // validators() checks invalid validator names - //if (!aValidator) { - // Events_Error::send(std::string("Validator ") + aValidatorID + " was not registered"); - // continue; - //} - const ModelAPI_FeatureValidator* aFValidator = + const ModelAPI_FeatureValidator* aFValidator = dynamic_cast(validator(aValidatorID)); if (aFValidator) { - std::string anError; + Events_InfoMessage anError; if (!aFValidator->isValid(theFeature, anArguments, anError)) { if (anError.empty()) anError = "Unknown error."; - anError = "Feature invalidated by \"" + aValidatorID + "\" with error: " + anError; - theFeature->setError(anError, false); + if (anError.context().empty()) { + anError.setContext(theFeature->getKind() + ":" + aValidatorID); + } + theFeature->setError(Config_Translator::translate(anError), false, false); theFeature->data()->execState(ModelAPI_StateInvalidArgument); return false; } } } } - // The default validator was retrned by validators() and was checked in previous cycle - //// check default validator - //std::map::const_iterator aDefaultVal = myIDs.find(kDefaultId); - //if(aDefaultVal != myIDs.end()) { - // static const std::list anEmptyArgList; - // const ModelAPI_FeatureValidator* aFValidator = - // dynamic_cast(aDefaultVal->second); - // if (aFValidator) { - // std::string anError; - // if (!aFValidator->isValid(theFeature, anEmptyArgList, anError)) { - // if (anError.empty()) - // anError = "Unknown error."; - // anError = "Feature invalidated by \"" + kDefaultId + "\" with error: " + anError; - // theFeature->setError(anError, false); - // theFeature->data()->execState(ModelAPI_StateInvalidArgument); - // return false; - // } - // } - //} - + // check all attributes for validity - // Validity of data is checked by "Model_FeatureValidator" (kDefaultId) - // if (!aData || !aData->isValid()) - // return false; static const std::string kAllTypes = ""; std::list aLtAttributes = aData->attributesIDs(kAllTypes); std::list::const_iterator anAttrIt = aLtAttributes.cbegin(); for (; anAttrIt != aLtAttributes.cend(); anAttrIt++) { - const std::string& anAttributeID = *anAttrIt; + const std::string& anAttributeID = *anAttrIt; AttributePtr anAttribute = theFeature->data()->attribute(anAttributeID); std::string aValidatorID; - std::string anError; + Events_InfoMessage anError; if (!validate(anAttribute, aValidatorID, anError)) { if (anError.empty()) anError = "Unknown error."; - anError = "Attribute \"" + anAttributeID + "\" invalidated by \"" + aValidatorID + "\" with error: " + anError; - theFeature->setError(anError, false); + if (anError.context().empty()) { + anError.setContext(theFeature->getKind() + ":" + anAttributeID + ":" + aValidatorID); + } + theFeature->setError(Config_Translator::translate(anError), false, false); theFeature->data()->execState(ModelAPI_StateInvalidArgument); return false; - } + } } return true; @@ -235,7 +232,7 @@ bool Model_ValidatorsFactory::validate(const std::shared_ptr& bool Model_ValidatorsFactory::validate(const std::shared_ptr& theAttribute, std::string& theValidator, - std::string& theError) const + Events_InfoMessage& theError) const { FeaturePtr aFeature = ModelAPI_Feature::feature(theAttribute->owner()); if (!aFeature.get()) { @@ -262,13 +259,14 @@ bool Model_ValidatorsFactory::validate(const std::shared_ptr if (!anAttrValidator->isValid(theAttribute, anArguments, theError)) { theValidator = aValidatorID; return false; - } + } } return true; } -void Model_ValidatorsFactory::registerNotObligatory(std::string theFeature, std::string theAttribute) +void Model_ValidatorsFactory::registerNotObligatory(std::string theFeature, + std::string theAttribute) { const static std::string kDefaultId = "Model_FeatureValidator"; std::map::const_iterator it = myIDs.find(kDefaultId); @@ -312,40 +310,93 @@ bool Model_ValidatorsFactory::isConcealed(std::string theFeature, std::string th } void Model_ValidatorsFactory::registerCase(std::string theFeature, std::string theAttribute, - std::string theSwitchId, std::string theCaseId) + const std::list >& theCases) { - std::map > > > + std::map > > > ::iterator aFindFeature = myCases.find(theFeature); if (aFindFeature == myCases.end()) { - myCases[theFeature] = std::map > >(); + myCases[theFeature] = std::map > >(); aFindFeature = myCases.find(theFeature); } - std::map > >::iterator aFindAttrID = + std::map > >::iterator aFindAttrID = aFindFeature->second.find(theAttribute); + if (aFindAttrID == aFindFeature->second.end()) { aFindFeature->second[theAttribute] = - std::pair >(theSwitchId, std::set()); + std::map >(); aFindAttrID = aFindFeature->second.find(theAttribute); } - aFindAttrID->second.second.insert(theCaseId); + std::list >::const_iterator aCasesIt = theCases.begin(), + aCasesLast = theCases.end(); + std::map > aFindCases = aFindAttrID->second; + for (; aCasesIt != aCasesLast; aCasesIt++) { + std::pair aCasePair = *aCasesIt; + std::string aSwitch = aCasePair.first; + if (aFindAttrID->second.find(aSwitch) == aFindAttrID->second.end()) { + aFindAttrID->second[aSwitch] = std::set(); + } + aFindAttrID->second[aSwitch].insert(aCasePair.second); + } } bool Model_ValidatorsFactory::isCase(FeaturePtr theFeature, std::string theAttribute) { - std::map > > > + bool anInCase = true; + std::map > > > ::iterator aFindFeature = myCases.find(theFeature->getKind()); if (aFindFeature != myCases.end()) { - std::map > >::iterator + std::map > >::iterator aFindAttrID = aFindFeature->second.find(theAttribute); if (aFindAttrID != aFindFeature->second.end()) { - // the the switch-attribute that contains the case value - AttributeStringPtr aSwitch = theFeature->string(aFindAttrID->second.first); - if (aSwitch.get()) { - // the second has the case identifier - return aFindAttrID->second.second.find(aSwitch->value()) != - aFindAttrID->second.second.end(); + std::map >::iterator + aCasesIt = aFindAttrID->second.begin(), aCasesLast = aFindAttrID->second.end(); + for (; aCasesIt != aCasesLast && anInCase; aCasesIt++) { + // the the switch-attribute that contains the case value + AttributeStringPtr aSwitch = theFeature->string(aCasesIt->first); + if (aSwitch.get()) { + // the second has the case identifier + anInCase = aCasesIt->second.find(aSwitch->value()) != aCasesIt->second.end(); + } } } } - return true; // if no additional conditions, this attribute is the case to be validated + return anInCase; // if no additional conditions, this attribute is the case to be validated +} + +void Model_ValidatorsFactory::registerMainArgument(std::string theFeature, + std::string theAttribute) +{ + std::map::iterator aFound = myMainArgument.find(theFeature); + if (aFound == myMainArgument.end()) + myMainArgument[theFeature] = theAttribute; +} + +bool Model_ValidatorsFactory::isMainArgument(std::string theFeature, std::string theAttribute) +{ + std::map::iterator aFound = myMainArgument.find(theFeature); + return aFound != myMainArgument.end() && aFound->second == theAttribute; +} + +void Model_ValidatorsFactory::registerGeometricalSelection(std::string theFeature, + std::string theAttribute) +{ + std::map >::iterator aFind = + myGeometricalSelection.find(theFeature); + if (aFind == myGeometricalSelection.end()) { + std::set aNewSet; + aNewSet.insert(theAttribute); + myGeometricalSelection[theFeature] = aNewSet; + } + else { + aFind->second.insert(theAttribute); + } +} + +bool Model_ValidatorsFactory::isGeometricalSelection(std::string theFeature, + std::string theAttribute) +{ + std::map >::iterator aFind = + myGeometricalSelection.find(theFeature); + return aFind != myGeometricalSelection.end() + && aFind->second.find(theAttribute) != aFind->second.end(); }