X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FModel%2FModel_Validator.cpp;h=41fa0f7014a03e24137734cbd4bc447925905271;hb=88be48ed1ea478b9d9d6ac2d965092418ef4dae6;hp=0aa279fcb18ad8cf89718d04402dbe309290e4c2;hpb=85afcf29664dfb5bda0bc6239c8760d6e424b1f2;p=modules%2Fshaper.git diff --git a/src/Model/Model_Validator.cpp b/src/Model/Model_Validator.cpp index 0aa279fcb..41fa0f701 100644 --- a/src/Model/Model_Validator.cpp +++ b/src/Model/Model_Validator.cpp @@ -1,8 +1,22 @@ -// Copyright (C) 2014-20xx CEA/DEN, EDF R&D - -// File: Model_Validator.cpp -// Created: 2 Jul 2014 -// Author: Mikhail PONIKAROV +// Copyright (C) 2014-2017 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" @@ -16,6 +30,8 @@ #include #include +#include + #include void Model_ValidatorsFactory::registerValidator(const std::string& theID, @@ -35,7 +51,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(); @@ -51,7 +67,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; @@ -81,7 +97,7 @@ 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(); @@ -97,11 +113,11 @@ void Model_ValidatorsFactory::validators(const std::string& theFeatureID, addDefaultValidators(theValidators); } -void Model_ValidatorsFactory::validators(const std::string& theFeatureID, +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 = @@ -172,55 +188,30 @@ 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) { Events_InfoMessage anError; if (!aFValidator->isValid(theFeature, anArguments, anError)) { if (anError.empty()) anError = "Unknown error."; - anError = aValidatorID + ": " + anError.messageString(); - theFeature->setError(anError.messageString(), 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; @@ -228,11 +219,13 @@ bool Model_ValidatorsFactory::validate(const std::shared_ptr& if (!validate(anAttribute, aValidatorID, anError)) { if (anError.empty()) anError = "Unknown error."; - anError = anAttributeID + " - " + aValidatorID + ": " + anError.messageString(); - theFeature->setError(anError.messageString(), 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; @@ -267,13 +260,13 @@ 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, +void Model_ValidatorsFactory::registerNotObligatory(std::string theFeature, std::string theAttribute) { const static std::string kDefaultId = "Model_FeatureValidator"; @@ -317,54 +310,6 @@ bool Model_ValidatorsFactory::isConcealed(std::string theFeature, std::string th return aFind != myConcealed.end() && aFind->second.find(theAttribute) != aFind->second.end(); } -void Model_ValidatorsFactory::registerUnconcealment(std::shared_ptr theUnconcealed, - std::shared_ptr theCanceledFeat) -{ - if (myUnconcealed.find(theUnconcealed) == myUnconcealed.end()) { - myUnconcealed[theUnconcealed] = std::list >(); - } - myUnconcealed[theUnconcealed].push_back(theCanceledFeat); - std::dynamic_pointer_cast(theUnconcealed->data())->updateConcealmentFlag(); -} - -void Model_ValidatorsFactory::disableUnconcealment(std::shared_ptr theUnconcealed, - std::shared_ptr theCanceledFeat) -{ - std::map, std::list > > - ::iterator aResFound = myUnconcealed.find(theUnconcealed); - if (aResFound != myUnconcealed.end()) { - std::list >::iterator anIter = aResFound->second.begin(); - for(; anIter != aResFound->second.end(); anIter++) { - if (*anIter == theCanceledFeat) { - aResFound->second.erase(anIter); - std::dynamic_pointer_cast(theUnconcealed->data())->updateConcealmentFlag(); - break; - } - } - } -} - -bool Model_ValidatorsFactory::isUnconcealed(std::shared_ptr theUnconcealed, - std::shared_ptr theCanceledFeat) -{ - std::map, std::list > > - ::iterator aResFound = myUnconcealed.find(theUnconcealed); - if (aResFound != myUnconcealed.end()) { - std::list >::iterator aFeatIter = aResFound->second.begin(); - for(; aFeatIter != aResFound->second.end(); aFeatIter++) { - if (aFeatIter->get()) { - if ((*aFeatIter)->isDisabled()) continue; - if (*aFeatIter == theCanceledFeat) - return true; // this is exactly canceled - if (theCanceledFeat->document()->isLater(*aFeatIter, theCanceledFeat)) - return true; // if unconcealed feature (from the list) is later than concealed - } else - return true; // empty attribute means that everything is canceled - } - } - return false; -} - void Model_ValidatorsFactory::registerCase(std::string theFeature, std::string theAttribute, const std::list >& theCases) { @@ -418,3 +363,17 @@ bool Model_ValidatorsFactory::isCase(FeaturePtr theFeature, std::string theAttri } 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; +}