#include <MessageServicePSetValidation.h>

Public Member Functions
std::string	operator() (ParameterSet const &pset)

Private Types
typedef std::string	String

typedef std::vector< String >	vString

Private Member Functions
bool	allowedVstring (std::string const &s)

void	catBoolRestriction (ParameterSet const &pset, std::string const &psetName, std::string const &categoryName, std::string const &type)

void	categoryPSet (ParameterSet const &pset, std::string const &OuterPsetName, std::string const &categoryName)

void	categoryPSets (ParameterSet const &pset, std::string const &psetName)

void	catInts (ParameterSet const &pset, std::string const &psetName, std::string const &categoryName)

template<typename T >
void	catNone (ParameterSet const &pset, std::string const &psetName, std::string const &categoryName, std::string const &type)

void	catNoPSets (ParameterSet const &pset, std::string const &psetName, std::string const &categoryName)

template<typename T >
T	check (ParameterSet const &pset, std::string const &psetName, std::string const &parameterLabel)

bool	checkThreshold (std::string const &thresh)

void	defaultPSet (ParameterSet const &main_pset)

void	destinationPSet (ParameterSet const &pset, std::string const &psetName)

void	destinationPSets (ParameterSet const &pset)

template<typename T >
void	disallowedParam (ParameterSet const &pset, vString const &v, std::string const &psetName, std::string const &parameterLabel, std::string const &type)

bool	keywordCheck (std::string const &word)

bool	lookForMatch (vString const &v, std::string const &s)

void	messageLoggerPSet (ParameterSet const &pset)

void	noBadParams (vString const &v, vString const &params, std::string const &psetName, std::string const &parameterLabel, std::string const &type)

void	noCoutCerrClash (vString const &v, std::string const &psetName, std::string const &parameterLabel)

void	noDuplicates (vString const &v, std::string const &psetName, std::string const &parameterLabel)

void	noDuplicates (vString const &v1, vString const &v2, std::string const &psetName, std::string const &p1, std::string const &p2)

void	noKeywords (vString const &v, std::string const &psetName, std::string const &parameterLabel)

template<typename T >
void	noneExcept (ParameterSet const &pset, std::string const &psetName, std::string const &type)

template<typename T >
void	noneExcept (ParameterSet const &pset, std::string const &psetName, std::string const &type, std::string const &ok)

template<typename T >
void	noneExcept (ParameterSet const &pset, std::string const &psetName, std::string const &type, T const &ok1, T const &ok2)

template<typename T >
void	noneExcept (ParameterSet const &pset, std::string const &psetName, std::string const &type, vString const &vok)

void	noNoncategoryPsets (ParameterSet const &pset, std::string const &psetName)

void	noNonPSetUsage (ParameterSet const &pset, vString const &v, std::string const &psetName, std::string const &parameterLabel)

void	noOtherPsets (ParameterSet const &pset)

void	psetLists (ParameterSet const &pset)

void	statisticsPSet (ParameterSet const &pset, std::string const &psetName)

void	statisticsPSets (ParameterSet const &pset)

void	suppressionLists (ParameterSet const &pset)

bool	validateThreshold (std::string const &thresh, std::string const &psetName)

void	vStringsCheck (ParameterSet const &pset, std::string const &psetName)

bool	wildcard (vString const &v)

Private Attributes
std::vector< std::string >	categories_

std::vector< std::string >	debugModules_

std::vector< std::string >	destinations_

std::ostringstream	flaws_

std::vector< std::string >	statistics_

std::vector< std::string >	suppressDebug_

std::vector< std::string >	suppressError_

std::vector< std::string >	suppressFwkInfo_

std::vector< std::string >	suppressInfo_

std::vector< std::string >	suppressWarning_

Detailed Description

Definition at line 42 of file MessageServicePSetValidation.h.

Member Typedef Documentation

◆ String

typedef std::string edm::service::MessageServicePSetValidation::String

private

Definition at line 47 of file MessageServicePSetValidation.h.

◆ vString

typedef std::vector<String> edm::service::MessageServicePSetValidation::vString

private

Definition at line 48 of file MessageServicePSetValidation.h.

Member Function Documentation

◆ allowedVstring()

bool edm::service::MessageServicePSetValidation::allowedVstring ( std::string const & s )

private

Definition at line 194 of file MessageServicePSetValidation.cc.

References alignCSCRings::s.

                                                                                   {
       if (s == "destinations")
         return true;
       if (s == "statistics")
         return true;
       if (s == "destinations")
         return true;
       if (s == "categories")
         return true;
       if (s == "debugModules")
         return true;
       if (s == "suppressInfo")
         return true;
       if (s == "suppressFwkInfo")
         return true;
       if (s == "suppressDebug")
         return true;
       if (s == "suppressWarning")
         return true;
       if (s == "suppressError")
         return true;
       return false;
     }  // allowedVstring

◆ catBoolRestriction()

void edm::service::MessageServicePSetValidation::catBoolRestriction	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	categoryName,
		std::string const &	type
	)

private

Definition at line 755 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and x.

                                                                                                {
       vString x = pset.getParameterNamesForType<bool>(false);
       vString::const_iterator end = x.end();
       for (vString::const_iterator i = x.begin(); i != end; ++i) {
         if (((*i) == "placeholder") || ((*i) == "optionalPSet"))
           continue;
         flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                << (*i) << " is used as a " << type << "\n"
                << "Usage of " << type << " is not recognized here\n";
       }
       x = pset.getParameterNamesForType<bool>(true);
       end = x.end();
       for (vString::const_iterator i = x.begin(); i != end; ++i) {
         flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                << (*i) << " is used as a tracked " << type << "\n"
                << "Tracked parameters not allowed here, "
                << " and even untracked it would not be recognized\n";
       }
     }  // catBoolRestriction()

◆ categoryPSet()

void edm::service::MessageServicePSetValidation::categoryPSet	(	ParameterSet const &	pset,
		std::string const &	OuterPsetName,
		std::string const &	categoryName
	)

private

Definition at line 686 of file MessageServicePSetValidation.cc.

References c, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                  {
       if (pset.existsAs<ParameterSet>(categoryName, true)) {
         flaws_ << OuterPsetName << " PSet: \n"
                << "Category PSet " << categoryName << " is tracked - not allowed\n";
         return;
       }
       ParameterSet empty_PSet;
       ParameterSet const& c = pset.getUntrackedParameterSet(categoryName, empty_PSet);
       std::string const& psetName(OuterPsetName);
       catInts(c, psetName, categoryName);
       catNone<unsigned int>(c, psetName, categoryName, "unsigned int");
       catBoolRestriction(c, psetName, categoryName, "bool");
       catNone<float>(c, psetName, categoryName, "float");
       catNone<double>(c, psetName, categoryName, "double");
       catNone<std::string>(c, psetName, categoryName, "string");
       catNone<vString>(c, psetName, categoryName, "vSting");
       catNoPSets(c, psetName, categoryName);
     }  // categoryPSet

◆ categoryPSets()

void edm::service::MessageServicePSetValidation::categoryPSets	(	ParameterSet const &	pset,
		std::string const &	psetName
	)

private

Definition at line 669 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, muonDTDigis_cfi::pset, and crab_NZS2018C_1::psetName.

                                                                                               {
       categoryPSet(pset, psetName, "ERROR");
       categoryPSet(pset, psetName, "WARNING");
       categoryPSet(pset, psetName, "FWKINFO");
       categoryPSet(pset, psetName, "INFO");
       categoryPSet(pset, psetName, "DEBUG");
       if (psetName != "MessageLogger")
         categoryPSet(pset, psetName, "default");
       // The above conditional is because default in the main level is treated
       // as a set of defaults differnt from those of a simple category.
       std::vector<std::string>::const_iterator end = categories_.end();
       for (std::vector<std::string>::const_iterator i = categories_.begin(); i != end; ++i) {
         categoryPSet(pset, psetName, *i);
       }
     }  // categoryPSets

◆ catInts()

void edm::service::MessageServicePSetValidation::catInts	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	categoryName
	)

private

Definition at line 707 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and x.

                                                                                             {
       vString x = pset.getParameterNamesForType<int>(false);
       vString::const_iterator end = x.end();
       for (vString::const_iterator i = x.begin(); i != end; ++i) {
         if (*i == "limit")
           continue;
         if (*i == "reportEvery")
           continue;
         if (*i == "timespan")
           continue;
         flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                << (*i) << " is not an allowed parameter within a category PSet \n";
       }
       x = pset.getParameterNamesForType<int>(true);
       end = x.end();
       for (vString::const_iterator i = x.begin(); i != end; ++i) {
         flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                << (*i) << " is used as a tracked int \n"
                << "Tracked parameters not allowed here \n";
       }
     }  // catInts()

◆ catNone()

template<typename T >

void edm::service::MessageServicePSetValidation::catNone	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	categoryName,
		std::string const &	type
	)

inlineprivate

Definition at line 233 of file MessageServicePSetValidation.h.

References mps_fire::end, flaws_, mps_fire::i, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and x.

                                           {
         vString x = pset.template getParameterNamesForType<T>(false);
         vString::const_iterator end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                  << (*i) << " is used as a " << type << "\n"
                  << "Usage of " << type << " is not recognized here\n";
         }
         x = pset.template getParameterNamesForType<T>(true);
         end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                  << (*i) << " is used as a tracked " << type << "\n"
                  << "Tracked parameters not allowed here, "
                  << " and even untracked it would not be recognized\n";
         }
       }  // catNone()

◆ catNoPSets()

void edm::service::MessageServicePSetValidation::catNoPSets	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	categoryName
	)

private

Definition at line 731 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, dqmiodumpmetadata::n, muonDTDigis_cfi::pset, and crab_NZS2018C_1::psetName.

                                                                                                {
       vString psnames;
       pset.getParameterSetNames(psnames, false);
       vString::const_iterator end = psnames.end();
       for (vString::const_iterator i = psnames.begin(); i != end; ++i) {
         flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                << *i << " is used as a  PSet\n"
                << "PSets not allowed within a category PSet\n";
       }
       psnames.clear();
       unsigned int n = pset.getParameterSetNames(psnames, true);
       if (n > 0) {
         end = psnames.end();
         for (vString::const_iterator i = psnames.begin(); i != end; ++i) {
           flaws_ << categoryName << " category PSet nested in " << psetName << " PSet: \n"
                  << *i << " is used as a tracked PSet\n"
                  << "tracked parameters not permitted, and "
                  << "PSets not allowed within a category PSet\n";
         }
       }
     }  // catNoPSets

◆ check()

template<typename T >

T edm::service::MessageServicePSetValidation::check	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	parameterLabel
	)

inlineprivate

Definition at line 94 of file MessageServicePSetValidation.h.

References MillePedeFileConverter_cfg::e, flaws_, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and heppy_batch::val.

                                                                                                     {
         T val = T();
         try {
           if (!pset.exists(parameterLabel))
             return val;
           if (pset.existsAs<T>(parameterLabel, false)) {
             val = pset.getUntrackedParameter<T>(parameterLabel, val);
             return val;
           }
           if (pset.existsAs<T>(parameterLabel, true)) {
             flaws_ << psetName << " PSet: \n" << parameterLabel << " is declared as tracked - needs to be untracked \n";
             val = pset.getParameter<T>(parameterLabel);
           } else {
             flaws_ << psetName << " PSet: \n" << parameterLabel << " is declared with incorrect type \n";
           }
           return val;
         } catch (cms::Exception& e) {
           flaws_ << psetName << " PSet: \n"
                  << parameterLabel << " is declared but causes an exception when processed: \n"
                  << e.what() << "\n";
           return val;
         }
       }  // check()

◆ checkThreshold()

bool edm::service::MessageServicePSetValidation::checkThreshold ( std::string const & thresh )

private

Definition at line 227 of file MessageServicePSetValidation.cc.

References GOODCOLL_filter_cfg::thresh.

                                                                                        {
       if (thresh == "WARNING")
         return true;
       if (thresh == "INFO")
         return true;
       if (thresh == "FWKINFO")
         return true;
       if (thresh == "ERROR")
         return true;
       if (thresh == "DEBUG")
         return true;
       return false;
     }

◆ defaultPSet()

void edm::service::MessageServicePSetValidation::defaultPSet ( ParameterSet const & main_pset )

private

Definition at line 521 of file MessageServicePSetValidation.cc.

References edm::ParameterSet::getUntrackedParameterSet(), muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, AlCaHLTBitMon_QueryRunRegistry::string, and GOODCOLL_filter_cfg::thresh.

                                                                                           {
       ParameterSet empty_PSet;
       ParameterSet const& pset = main_pset.getUntrackedParameterSet("default", empty_PSet);
       std::string psetName = "default (at MessageLogger main level)";
 
       // Category PSets
 
       categoryPSets(pset, psetName);
 
       // No other PSets -- unless they contain optionalPSet or placeholder=True
 
       noNoncategoryPsets(pset, psetName);
 
       // Parameters applying to the default category
 
       catInts(pset, psetName, "default");
 
       // General parameters
 
       check<bool>(pset, psetName, "placeholder");
       std::string thresh = check<std::string>(pset, "psetName", "threshold");
       if (!thresh.empty())
         validateThreshold(thresh, psetName);
       check<bool>(pset, psetName, "noLineBreaks");
       check<int>(pset, psetName, "limit");
       check<int>(pset, psetName, "reportEvery");
       check<int>(pset, psetName, "timespan");
       check<int>(pset, psetName, "lineLength");
       check<bool>(pset, psetName, "noTimeStamps");
 
       // No other parameters
       vString okint;
       okint.push_back("limit");
       okint.push_back("reportEvery");
       okint.push_back("timespan");
       okint.push_back("lineLength");
       noneExcept<int>(pset, psetName, "int", okint);
       vString okbool;
       okbool.push_back("placeholder");
       okbool.push_back("optionalPSet");
       okbool.push_back("noLineBreaks");
       okbool.push_back("noTimeStamps");
       noneExcept<bool>(pset, psetName, "bool", okbool);
       vString okstring;
       okstring.push_back("threshold");
       noneExcept<std::string>(pset, psetName, "string", okstring);
 
     }  // defaultPSet

◆ destinationPSet()

void edm::service::MessageServicePSetValidation::destinationPSet	(	ParameterSet const &	pset,
		std::string const &	psetName
	)

private

Definition at line 463 of file MessageServicePSetValidation.cc.

References muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, and GOODCOLL_filter_cfg::thresh.

                                                                                                 {
       // Category PSets
 
       categoryPSets(pset, psetName);
 
       // No other PSets -- unless they contain optionalPSet or placeholder=True
 
       noNoncategoryPsets(pset, psetName);
 
       // General parameters
 
       check<bool>(pset, psetName, "placeholder");
       {
         std::string thresh = check<std::string>(pset, "psetName", "statisticsThreshold");
         if (!thresh.empty())
           validateThreshold(thresh, psetName);
       }
       std::string thresh = check<std::string>(pset, "psetName", "threshold");
       if (!thresh.empty())
         validateThreshold(thresh, psetName);
       check<bool>(pset, psetName, "noLineBreaks");
       check<int>(pset, psetName, "lineLength");
       check<bool>(pset, psetName, "noTimeStamps");
       check<bool>(pset, psetName, "enableStatistics");
       check<bool>(pset, psetName, "resetStatistics");
       std::string s = check<std::string>(pset, "psetName", "filename");
       if ((s == "cerr") || (s == "cout")) {
         flaws_ << psetName << " PSet: \n" << s << " is not allowed as a value of filename \n";
       }
       s = check<std::string>(pset, "psetName", "extension");
       if ((s == "cerr") || (s == "cout")) {
         flaws_ << psetName << " PSet: \n" << s << " is not allowed as a value of extension \n";
       }
       s = check<std::string>(pset, "psetName", "output");
 
       // No other parameters
 
       noneExcept<int>(pset, psetName, "int", "lineLength");
 
       vString okbool;
       okbool.push_back("placeholder");
       okbool.push_back("optionalPSet");
       okbool.push_back("noLineBreaks");
       okbool.push_back("noTimeStamps");
       okbool.push_back("enableStatistics");
       okbool.push_back("resetStatistics");
       noneExcept<bool>(pset, psetName, "bool", okbool);
       vString okstring;
       okstring.push_back("statisticsThreshold");
       okstring.push_back("threshold");
       okstring.push_back("output");
       okstring.push_back("filename");
       okstring.push_back("extension");
       noneExcept<std::string>(pset, psetName, "string", okstring);
 
     }  // destinationPSet

◆ destinationPSets()

void edm::service::MessageServicePSetValidation::destinationPSets ( ParameterSet const & pset )

private

Definition at line 454 of file MessageServicePSetValidation.cc.

References ztail::d, mps_fire::end, mps_fire::i, and muonDTDigis_cfi::pset.

                                                                                           {
       ParameterSet empty_PSet;
       std::vector<std::string>::const_iterator end = destinations_.end();
       for (std::vector<std::string>::const_iterator i = destinations_.begin(); i != end; ++i) {
         ParameterSet const& d = pset.getUntrackedParameterSet(*i, empty_PSet);
         destinationPSet(d, *i);
       }
     }  // destinationPSets

◆ disallowedParam()

template<typename T >

void edm::service::MessageServicePSetValidation::disallowedParam	(	ParameterSet const &	pset,
		vString const &	v,
		std::string const &	psetName,
		std::string const &	parameterLabel,
		std::string const &	type
	)

inlineprivate

Definition at line 119 of file MessageServicePSetValidation.h.

References noBadParams(), submitPVValidationJobs::params, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and findQualityFiles::v.

                                                   {
         vString params = pset.getParameterNamesForType<T>(true);
         noBadParams(v, params, psetName, parameterLabel, type);
         params = pset.getParameterNamesForType<T>(false);
         noBadParams(v, params, psetName, parameterLabel, type);
       }  // disallowedParam()

◆ keywordCheck()

bool edm::service::MessageServicePSetValidation::keywordCheck ( std::string const & word )

private

Definition at line 302 of file MessageServicePSetValidation.cc.

                                                                                    {
       if (word == "default")
         return false;
       if (word == "categories")
         return false;
       if (word == "destinations")
         return false;
       if (word == "statistics")
         return false;
       if (word == "debugModules")
         return false;
       if (word == "suppressInfo")
         return false;
       if (word == "suppressFwkInfo")
         return false;
       if (word == "suppressDebug")
         return false;
       if (word == "suppressWarning")
         return false;
       if (word == "suppressError")
         return false;
       if (word == "threshold")
         return false;
       if (word == "ERROR")
         return false;
       if (word == "WARNING")
         return false;
       if (word == "FWKINFO")
         return false;
       if (word == "INFO")
         return false;
       if (word == "DEBUG")
         return false;
       if (word == "placeholder")
         return false;
       if (word == "limit")
         return false;
       if (word == "reportEvery")
         return false;
       if (word == "timespan")
         return false;
       if (word == "noLineBreaks")
         return false;
       if (word == "lineLength")
         return false;
       if (word == "noTimeStamps")
         return false;
       if (word == "output")
         return false;
       if (word == "filename")
         return false;
       if (word == "extension")
         return false;
       if (word == "reset")
         return false;
       if (word == "optionalPSet")
         return false;
       if (word == "enableStatistics")
         return false;
       if (word == "statisticsThreshold")
         return false;
       if (word == "resetStatistics")
         return false;
       return true;
     }  // keywordCheck

◆ lookForMatch()

bool edm::service::MessageServicePSetValidation::lookForMatch	(	vString const &	v,
		std::string const &	s
	)

private

Definition at line 448 of file MessageServicePSetValidation.cc.

References mps_fire::end, spr::find(), alignCSCRings::s, and findQualityFiles::v.

                                                                                                   {
       vString::const_iterator begin = v.begin();
       vString::const_iterator end = v.end();
       return (std::find(begin, end, s) != end);
     }

◆ messageLoggerPSet()

void edm::service::MessageServicePSetValidation::messageLoggerPSet ( ParameterSet const & pset )

private

Definition at line 33 of file MessageServicePSetValidation.cc.

References or, muonDTDigis_cfi::pset, AlCaHLTBitMon_QueryRunRegistry::string, and GOODCOLL_filter_cfg::thresh.

                                                                                            {
       // See if new config API is being used
       if (pset.exists("files") or
           (not(pset.exists("destinations") or pset.existsAs<std::vector<std::string>>("statistics", true) or
                pset.existsAs<std::vector<std::string>>("statistics", false) or pset.exists("categories")))) {
         return;
       }
 
       // Four types of material are allowed at the MessageLogger level:
       //   PSet lists (such as destinations or categories
       //   Suppression lists, such as SuppressInfo or debugModules
       //   General parameters, such as threshold or messageSummaryToJobReport
       //   Nested PSets, such as those for each destination
 
       // PSet lists
 
       psetLists(pset);
 
       // Suppression lists
 
       suppressionLists(pset);
 
       // No other vstrings
 
       vStringsCheck(pset, "MessageLogger");
 
       // General Parameters
 
       check<bool>(pset, "MessageLogger", "messageSummaryToJobReport");
       std::string dumps = check<std::string>(pset, "MessageLogger", "generate_preconfiguration_message");
       std::string thresh = check<std::string>(pset, "MessageLogger", "threshold");
       if (!thresh.empty())
         validateThreshold(thresh, "MessageLogger");
       check<unsigned int>(pset, "MessageLogger", "waiting_threshold");
 
       // Nested PSets
 
       destinationPSets(pset);
       defaultPSet(pset);
       statisticsPSets(pset);
       categoryPSets(pset, "MessageLogger");
 
       // No other PSets -- unless they contain optionalPSet or placeholder=True
 
       noOtherPsets(pset);
 
       // Nothing else -- look for int, unsigned int, bool, float, double, string
 
       noneExcept<int>(pset, "MessageLogger", "int");
       noneExcept<unsigned int>(pset, "MessageLogger", "unsigned int", "waiting_threshold");
       noneExcept<bool>(pset, "MessageLogger", "bool", "messageSummaryToJobReport");
       // Note - at this, the upper MessageLogger PSet level, the use of
       // optionalPSet makes no sense, so we are OK letting that be a flaw
       noneExcept<float>(pset, "MessageLogger", "float");
       noneExcept<double>(pset, "MessageLogger", "double");
       noneExcept<std::string>(pset, "MessageLogger", "string", "threshold", "generate_preconfiguration_message");
 
       // Append explanatory information if flaws were found
 
       if (!flaws_.str().empty()) {
         flaws_ << "\nThe above are from MessageLogger configuration validation.\n"
                << "In most cases, these involve lines that the logger configuration code\n"
                << "would not process, but which the cfg creator obviously meant to have "
                << "effect.\n";
       }
 
     }  // messageLoggerPSet

◆ noBadParams()

void edm::service::MessageServicePSetValidation::noBadParams	(	vString const &	v,
		vString const &	params,
		std::string const &	psetName,
		std::string const &	parameterLabel,
		std::string const &	type
	)

private

Definition at line 381 of file MessageServicePSetValidation.cc.

References mps_fire::i, dqmiolumiharvest::j, submitPVValidationJobs::params, crab_NZS2018C_1::psetName, and findQualityFiles::v.

Referenced by disallowedParam().

                                                                                         {
       vString::const_iterator end1 = v.end();
       vString::const_iterator end2 = params.end();
       for (vString::const_iterator i = v.begin(); i != end1; ++i) {
         for (vString::const_iterator j = params.begin(); j != end2; ++j) {
           if (*i == *j) {
             flaws_ << psetName << " PSet: \n"
                    << *i << " (listed in vstring " << parameterLabel << ")\n"
                    << "is used as a parameter of type " << type << " instead of as a PSet \n";
           }
         }
       }
 
     }  // noBadParams

◆ noCoutCerrClash()

void edm::service::MessageServicePSetValidation::noCoutCerrClash	(	vString const &	v,
		std::string const &	psetName,
		std::string const &	parameterLabel
	)

private

Definition at line 272 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, crab_NZS2018C_1::psetName, and findQualityFiles::v.

                                                                                                       {
       vString::const_iterator end = v.end();
       bool coutPresent = false;
       bool cerrPresent = false;
       for (vString::const_iterator i = v.begin(); i != end; ++i) {
         if (*i == "cout")
           coutPresent = true;
         if (*i == "cerr")
           cerrPresent = true;
       }
       if (coutPresent && cerrPresent) {
         flaws_ << psetName << " PSet: \n"
                << "vString " << parameterLabel << " has both cout and cerr \n";
       }
     }  // noCoutCerrClash(v)

◆ noDuplicates() [1/2]

void edm::service::MessageServicePSetValidation::noDuplicates	(	vString const &	v,
		std::string const &	psetName,
		std::string const &	parameterLabel
	)

private

Definition at line 241 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, dqmiolumiharvest::j, crab_NZS2018C_1::psetName, and findQualityFiles::v.

                                                                                                    {
       vString::const_iterator end = v.end();
       for (vString::const_iterator i = v.begin(); i != end; ++i) {
         for (vString::const_iterator j = i + 1; j != end; ++j) {
           if (*i == *j) {
             flaws_ << psetName << " PSet: \n"
                    << "in vString " << parameterLabel << " duplication of the string " << *i << "\n";
           }
         }
       }
     }  // noDuplicates(v)

◆ noDuplicates() [2/2]

void edm::service::MessageServicePSetValidation::noDuplicates	(	vString const &	v1,
		vString const &	v2,
		std::string const &	psetName,
		std::string const &	p1,
		std::string const &	p2
	)

private

Definition at line 255 of file MessageServicePSetValidation.cc.

References mps_fire::i, dqmiolumiharvest::j, LaserDQM_cfg::p1, SiStripOfflineCRack_cfg::p2, and crab_NZS2018C_1::psetName.

                                                                                        {
       vString::const_iterator end1 = v1.end();
       vString::const_iterator end2 = v2.end();
       for (vString::const_iterator i = v1.begin(); i != end1; ++i) {
         for (vString::const_iterator j = v2.begin(); j != end2; ++j) {
           if (*i == *j) {
             flaws_ << psetName << " PSet: \n"
                    << "in vStrings " << p1 << " and " << p2 << " duplication of the string " << *i << "\n";
           }
         }
       }
     }  // noDuplicates(v1,v2)

◆ noKeywords()

void edm::service::MessageServicePSetValidation::noKeywords	(	vString const &	v,
		std::string const &	psetName,
		std::string const &	parameterLabel
	)

private

Definition at line 290 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, crab_NZS2018C_1::psetName, and findQualityFiles::v.

                                                                                                  {
       vString::const_iterator end = v.end();
       for (vString::const_iterator i = v.begin(); i != end; ++i) {
         if (!keywordCheck(*i)) {
           flaws_ << psetName << " PSet: \n"
                  << "vString " << parameterLabel << " should not contain the keyword " << *i << "\n";
         }
       }
     }  // noKeywords(v)

◆ noneExcept() [1/4]

template<typename T >

void edm::service::MessageServicePSetValidation::noneExcept	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	type
	)

inlineprivate

Definition at line 131 of file MessageServicePSetValidation.h.

References mps_fire::end, flaws_, mps_fire::i, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and x.

                                                                                                   {
         vString x = pset.template getParameterNamesForType<T>(false);
         vString::const_iterator end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           flaws_ << psetName << " PSet: \n"
                  << (*i) << " is used as a " << type << "\n"
                  << "Usage of " << type << " is not recognized here\n";
         }
         x = pset.template getParameterNamesForType<T>(true);
         end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           if ((*i) == "@service_type")
             continue;
           flaws_ << psetName << " PSet: \n"
                  << (*i) << " is used as a tracked " << type << "\n"
                  << "Tracked parameters not allowed here, "
                  << " and even untracked it would not be recognized\n";
         }
       }  // noneExcept()

◆ noneExcept() [2/4]

template<typename T >

void edm::service::MessageServicePSetValidation::noneExcept	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	type,
		std::string const &	ok
	)

inlineprivate

Definition at line 152 of file MessageServicePSetValidation.h.

References mps_fire::end, flaws_, mps_fire::i, convertSQLiteXML::ok, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, AlCaHLTBitMon_QueryRunRegistry::string, heppy_batch::val, and x.

                                            {
         vString x = pset.template getParameterNamesForType<T>(false);
         vString::const_iterator end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           std::string val = (*i);
           if (val != ok) {
             flaws_ << psetName << " PSet: \n"
                    << val << " is used as a " << type << "\n"
                    << "This usage is not recognized in this type of PSet\n";
           }
         }
         x = pset.template getParameterNamesForType<T>(true);
         end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           if ((*i) == "@service_type")
             continue;
           flaws_ << psetName << " PSet: \n"
                  << (*i) << " is used as a tracked " << type << "\n"
                  << "Tracked parameters not allowed here\n";
         }
       }  // noneExcept(okValue)

◆ noneExcept() [3/4]

template<typename T >

void edm::service::MessageServicePSetValidation::noneExcept	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	type,
		T const &	ok1,
		T const &	ok2
	)

inlineprivate

Definition at line 178 of file MessageServicePSetValidation.h.

References mps_fire::end, flaws_, mps_fire::i, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, AlCaHLTBitMon_QueryRunRegistry::string, heppy_batch::val, and x.

                                                                                                                   {
         vString x = pset.template getParameterNamesForType<T>(false);
         vString::const_iterator end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           std::string val = (*i);
           if ((val != ok1) && (val != ok2)) {
             flaws_ << psetName << " PSet: \n"
                    << val << " is used as a " << type << "\n"
                    << "This usage is not recognized in this type of PSet\n";
           }
         }
         x = pset.template getParameterNamesForType<T>(true);
         end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           if ((*i) == "@service_type")
             continue;
           flaws_ << psetName << " PSet: \n"
                  << (*i) << " is used as a tracked " << type << "\n"
                  << "Tracked parameters not allowed here\n";
         }
       }  // noneExcept(okValue1, okValue2)

◆ noneExcept() [4/4]

template<typename T >

void edm::service::MessageServicePSetValidation::noneExcept	(	ParameterSet const &	pset,
		std::string const &	psetName,
		std::string const &	type,
		vString const &	vok
	)

inlineprivate

Definition at line 202 of file MessageServicePSetValidation.h.

References mps_fire::end, flaws_, newFWLiteAna::found, mps_fire::i, muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and x.

                                           {
         vString x = pset.template getParameterNamesForType<T>(false);
         vString::const_iterator end = x.end();
         vString::const_iterator vend = vok.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           bool found = false;
           for (vString::const_iterator vit = vok.begin(); vit != vend; ++vit) {
             if (*i == *vit)
               found = true;
           }
           if (!found) {
             flaws_ << psetName << " PSet: \n"
                    << *i << " is used as a " << type << "\n"
                    << "This usage is not recognized in this type of PSet\n";
           }
         }
         x = pset.template getParameterNamesForType<T>(true);
         end = x.end();
         for (vString::const_iterator i = x.begin(); i != end; ++i) {
           if ((*i) == "@service_type")
             continue;
           flaws_ << psetName << " PSet: \n"
                  << (*i) << " is used as a tracked " << type << "\n"
                  << "Tracked parameters not allowed here\n";
         }
       }  // noneExcept(vok)

◆ noNoncategoryPsets()

void edm::service::MessageServicePSetValidation::noNoncategoryPsets	(	ParameterSet const &	pset,
		std::string const &	psetName
	)

private

Definition at line 626 of file MessageServicePSetValidation.cc.

References MillePedeFileConverter_cfg::e, mps_fire::end, edm::ParameterSet::getUntrackedParameter(), mps_fire::i, dqmiodumpmetadata::n, muonDTDigis_cfi::pset, and crab_NZS2018C_1::psetName.

                                                                                                    {
       vString psnames;
       pset.getParameterSetNames(psnames, false);
       vString::const_iterator end = psnames.end();
       for (vString::const_iterator i = psnames.begin(); i != end; ++i) {
         if (lookForMatch(categories_, *i))
           continue;
         if ((*i) == "default")
           continue;
         if ((*i) == "ERROR")
           continue;
         if ((*i) == "WARNING")
           continue;
         if ((*i) == "FWKINFO")
           continue;
         if ((*i) == "INFO")
           continue;
         if ((*i) == "DEBUG")
           continue;
         ParameterSet empty_PSet;
         bool ok_optionalPSet = false;
         try {
           ParameterSet const& culprit = pset.getUntrackedParameterSet((*i), empty_PSet);
           ok_optionalPSet = culprit.getUntrackedParameter<bool>("placeholder", ok_optionalPSet);
           ok_optionalPSet = culprit.getUntrackedParameter<bool>("optionalPSet", ok_optionalPSet);
         } catch (cms::Exception& e) {
         }
         if (ok_optionalPSet)
           continue;
         flaws_ << psetName << " PSet: \n" << *i << " is an unrecognized name for a PSet in this context \n";
       }
       psnames.clear();
       unsigned int n = pset.getParameterSetNames(psnames, true);
       if (n > 0) {
         end = psnames.end();
         for (vString::const_iterator i = psnames.begin(); i != end; ++i) {
           flaws_ << psetName << " PSet: \n"
                  << "PSet " << *i << " is tracked - not allowed\n";
         }
       }
     }  // noNoncategoryPsets

◆ noNonPSetUsage()

void edm::service::MessageServicePSetValidation::noNonPSetUsage	(	ParameterSet const &	pset,
		vString const &	v,
		std::string const &	psetName,
		std::string const &	parameterLabel
	)

private

Definition at line 368 of file MessageServicePSetValidation.cc.

References muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, and findQualityFiles::v.

                                                                                                      {
       disallowedParam<int>(pset, v, psetName, parameterLabel, "int");
       disallowedParam<unsigned int>(pset, v, psetName, parameterLabel, "uint");
       disallowedParam<bool>(pset, v, psetName, parameterLabel, "bool");
       disallowedParam<float>(pset, v, psetName, parameterLabel, "float");
       disallowedParam<double>(pset, v, psetName, parameterLabel, "double");
       disallowedParam<std::string>(pset, v, psetName, parameterLabel, "string");
       disallowedParam<std::vector<std::string>>(pset, v, psetName, parameterLabel, "vstring");
     }  // noNonPSetUsage

◆ noOtherPsets()

void edm::service::MessageServicePSetValidation::noOtherPsets ( ParameterSet const & pset )

private

Definition at line 409 of file MessageServicePSetValidation.cc.

References MillePedeFileConverter_cfg::e, mps_fire::end, edm::ParameterSet::getUntrackedParameter(), mps_fire::i, dqmiodumpmetadata::n, and muonDTDigis_cfi::pset.

                                                                                       {
       vString psnames;
       pset.getParameterSetNames(psnames, false);
       vString::const_iterator end = psnames.end();
       for (vString::const_iterator i = psnames.begin(); i != end; ++i) {
         if (lookForMatch(destinations_, *i))
           continue;
         if (lookForMatch(statistics_, *i))
           continue;
         if (lookForMatch(categories_, *i))
           continue;
         if ((*i) == "default")
           continue;
         ParameterSet empty_PSet;
         bool ok_optionalPSet = false;
         try {
           ParameterSet const& culprit = pset.getUntrackedParameterSet((*i), empty_PSet);
           ok_optionalPSet = culprit.getUntrackedParameter<bool>("placeholder", ok_optionalPSet);
           ok_optionalPSet = culprit.getUntrackedParameter<bool>("optionalPSet", ok_optionalPSet);
         } catch (cms::Exception& e) {
         }
         if (ok_optionalPSet)
           continue;
         flaws_ << "MessageLogger "
                << " PSet: \n"
                << *i << " is an unrecognized name for a PSet\n";
       }
       psnames.clear();
       unsigned int n = pset.getParameterSetNames(psnames, true);
       if (n > 0) {
         end = psnames.end();
         for (vString::const_iterator i = psnames.begin(); i != end; ++i) {
           flaws_ << "MessageLogger "
                  << " PSet: \n"
                  << "PSet " << *i << " is tracked - not allowed\n";
         }
       }
     }

◆ operator()()

std::string edm::service::MessageServicePSetValidation::operator() ( ParameterSet const & pset )

Definition at line 28 of file MessageServicePSetValidation.cc.

References muonDTDigis_cfi::pset.

                                                                                          {
       messageLoggerPSet(pset);
       return flaws_.str();
     }  // operator() to validate the PSet passed in

◆ psetLists()

void edm::service::MessageServicePSetValidation::psetLists ( ParameterSet const & pset )

private

Definition at line 101 of file MessageServicePSetValidation.cc.

References muonDTDigis_cfi::pset.

                                                                                    {
       destinations_ = check<vString>(pset, "MessageLogger", "destinations");
       noDuplicates(destinations_, "MessageLogger", "destinations");
       noKeywords(destinations_, "MessageLogger", "destinations");
       noNonPSetUsage(pset, destinations_, "MessageLogger", "destinations");
       // REMOVED: noCoutCerrClash(destinations_,"MessageLogger", "destinations");
 
       statistics_ = check<vString>(pset, "MessageLogger", "statistics");
       noDuplicates(statistics_, "MessageLogger", "statistics");
       noKeywords(statistics_, "MessageLogger", "statistics");
       noNonPSetUsage(pset, statistics_, "MessageLogger", "statistics");
 
       categories_ = check<vString>(pset, "MessageLogger", "categories");
       noDuplicates(categories_, "MessageLogger", "categories");
       noKeywords(categories_, "MessageLogger", "categories");
       noNonPSetUsage(pset, categories_, "MessageLogger", "categories");
       noDuplicates(categories_, destinations_, "MessageLogger", "categories", "destinations");
       noDuplicates(categories_, statistics_, "MessageLogger", "categories", "statistics");
 
     }  // psetLists

◆ statisticsPSet()

void edm::service::MessageServicePSetValidation::statisticsPSet	(	ParameterSet const &	pset,
		std::string const &	psetName
	)

private

Definition at line 581 of file MessageServicePSetValidation.cc.

References muonDTDigis_cfi::pset, crab_NZS2018C_1::psetName, alignCSCRings::s, AlCaHLTBitMon_QueryRunRegistry::string, and GOODCOLL_filter_cfg::thresh.

                                                                                                {
       // Category PSets
 
       categoryPSets(pset, psetName);
 
       // No other PSets -- unless they contain optionalPSet or placeholder=True
 
       noNoncategoryPsets(pset, psetName);
 
       // General parameters
 
       std::string thresh = check<std::string>(pset, "psetName", "threshold");
       if (!thresh.empty())
         validateThreshold(thresh, psetName);
       check<bool>(pset, psetName, "placeholder");
       check<bool>(pset, psetName, "reset");
       std::string s = check<std::string>(pset, "psetName", "filename");
       if ((s == "cerr") || (s == "cout")) {
         flaws_ << psetName << " PSet: \n" << s << " is not allowed as a value of filename \n";
       }
       s = check<std::string>(pset, "psetName", "extension");
       if ((s == "cerr") || (s == "cout")) {
         flaws_ << psetName << " PSet: \n" << s << " is not allowed as a value of extension \n";
       }
       s = check<std::string>(pset, "psetName", "output");
 
       // No other parameters
 
       noneExcept<int>(pset, psetName, "int");
 
       vString okbool;
       okbool.push_back("placeholder");
       okbool.push_back("optionalPSet");
       okbool.push_back("reset");
       noneExcept<bool>(pset, psetName, "bool", okbool);
       vString okstring;
       okstring.push_back("output");
       okstring.push_back("filename");
       okstring.push_back("extension");
       okstring.push_back("threshold");
       noneExcept<std::string>(pset, psetName, "string", okstring);
 
     }  // statisticsPSet

◆ statisticsPSets()

void edm::service::MessageServicePSetValidation::statisticsPSets ( ParameterSet const & pset )

private

Definition at line 570 of file MessageServicePSetValidation.cc.

References ztail::d, mps_fire::end, mps_fire::i, and muonDTDigis_cfi::pset.

                                                                                          {
       ParameterSet empty_PSet;
       std::vector<std::string>::const_iterator end = statistics_.end();
       for (std::vector<std::string>::const_iterator i = statistics_.begin(); i != end; ++i) {
         if (lookForMatch(destinations_, *i))
           continue;
         ParameterSet const& d = pset.getUntrackedParameterSet(*i, empty_PSet);
         statisticsPSet(d, *i);
       }
     }  // statisticsPSets

◆ suppressionLists()

void edm::service::MessageServicePSetValidation::suppressionLists ( ParameterSet const & pset )

private

Definition at line 122 of file MessageServicePSetValidation.cc.

References muonDTDigis_cfi::pset.

                                                                                           {
       debugModules_ = check<vString>(pset, "MessageLogger", "debugModules");
       bool dmStar = wildcard(debugModules_);
       if (dmStar && debugModules_.size() != 1) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "debugModules contains wildcard character *"
                << " and also " << debugModules_.size() - 1 << " other entries - * must be alone\n";
       }
       suppressDebug_ = check<vString>(pset, "MessageLogger", "suppressDebug");
       if ((!suppressDebug_.empty()) && (!dmStar)) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "suppressDebug contains modules, but debugModules is not *\n"
                << "Unless all the debugModules are enabled,\n"
                << "suppressing specific modules is meaningless\n";
       }
       if (wildcard(suppressDebug_)) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "Use of wildcard (*) in suppressDebug is not supported\n"
                << "By default, LogDebug is suppressed for all modules\n";
       }
       suppressInfo_ = check<vString>(pset, "MessageLogger", "suppressInfo");
       if (wildcard(suppressInfo_)) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "Use of wildcard (*) in suppressInfo is not supported\n";
       }
       suppressFwkInfo_ = check<vString>(pset, "MessageLogger", "suppressFwkInfo");
       if (wildcard(suppressFwkInfo_)) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "Use of wildcard (*) in suppressFwkInfo is not supported\n";
       }
       suppressWarning_ = check<vString>(pset, "MessageLogger", "suppressWarning");
       if (wildcard(suppressWarning_)) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "Use of wildcard (*) in suppressWarning is not supported\n";
       }
       suppressError_ = check<vString>(pset, "MessageLogger", "suppressError");
       if (wildcard(suppressError_)) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << "Use of wildcard (*) in suppressError is not supported\n";
       }
 
     }  // suppressionLists

◆ validateThreshold()

bool edm::service::MessageServicePSetValidation::validateThreshold	(	std::string const &	thresh,
		std::string const &	psetName
	)

private

Definition at line 218 of file MessageServicePSetValidation.cc.

References crab_NZS2018C_1::psetName, and GOODCOLL_filter_cfg::thresh.

                                                                                                   {
       if (checkThreshold(thresh))
         return true;
       flaws_ << psetName << " PSet: \n"
              << "threshold has value " << thresh << " which is not among {DEBUG, INFO, FWKINFO, WARNING, ERROR}\n";
       return false;
     }  // validateThreshold

◆ vStringsCheck()

void edm::service::MessageServicePSetValidation::vStringsCheck	(	ParameterSet const &	pset,
		std::string const &	psetName
	)

private

Definition at line 172 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, and muonDTDigis_cfi::pset.

                                                                                        {
       vString vStrings = pset.getParameterNamesForType<vString>(false);
       vString::const_iterator end = vStrings.end();
       for (vString::const_iterator i = vStrings.begin(); i != end; ++i) {
         if (!allowedVstring(*i)) {
           flaws_ << "MessageLogger"
                  << " PSet: \n"
                  << (*i) << " is used as a vstring, "
                  << "but no such vstring is recognized\n";
         }
       }
       vStrings = pset.getParameterNamesForType<vString>(true);
       end = vStrings.end();
       for (vString::const_iterator i = vStrings.begin(); i != end; ++i) {
         flaws_ << "MessageLogger"
                << " PSet: \n"
                << (*i) << " is used as a tracked vstring: "
                << "tracked parameters not allowed here\n";
       }
     }  // vStringsCheck

◆ wildcard()

bool edm::service::MessageServicePSetValidation::wildcard ( vString const & v )

private

Definition at line 400 of file MessageServicePSetValidation.cc.

References mps_fire::end, mps_fire::i, and findQualityFiles::v.

                                                                           {
       vString::const_iterator end = v.end();
       for (vString::const_iterator i = v.begin(); i != end; ++i) {
         if ((*i) == "*")
           return true;
       }
       return false;
     }

Member Data Documentation

◆ categories_

std::vector<std::string> edm::service::MessageServicePSetValidation::categories_

private

Definition at line 258 of file MessageServicePSetValidation.h.

◆ debugModules_

std::vector<std::string> edm::service::MessageServicePSetValidation::debugModules_

private

Definition at line 259 of file MessageServicePSetValidation.h.

◆ destinations_

std::vector<std::string> edm::service::MessageServicePSetValidation::destinations_

private

Definition at line 256 of file MessageServicePSetValidation.h.

◆ flaws_

std::ostringstream edm::service::MessageServicePSetValidation::flaws_

private

Definition at line 255 of file MessageServicePSetValidation.h.

Referenced by catNone(), check(), and noneExcept().

◆ statistics_

std::vector<std::string> edm::service::MessageServicePSetValidation::statistics_

private

Definition at line 257 of file MessageServicePSetValidation.h.

◆ suppressDebug_

std::vector<std::string> edm::service::MessageServicePSetValidation::suppressDebug_

private

Definition at line 262 of file MessageServicePSetValidation.h.

◆ suppressError_

std::vector<std::string> edm::service::MessageServicePSetValidation::suppressError_

private

Definition at line 264 of file MessageServicePSetValidation.h.

◆ suppressFwkInfo_

std::vector<std::string> edm::service::MessageServicePSetValidation::suppressFwkInfo_

private

Definition at line 261 of file MessageServicePSetValidation.h.

◆ suppressInfo_

std::vector<std::string> edm::service::MessageServicePSetValidation::suppressInfo_

private

Definition at line 260 of file MessageServicePSetValidation.h.

◆ suppressWarning_

std::vector<std::string> edm::service::MessageServicePSetValidation::suppressWarning_

private

Definition at line 263 of file MessageServicePSetValidation.h.

Public Member Functions

Private Types

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ String

◆ vString

Member Function Documentation

◆ allowedVstring()

◆ catBoolRestriction()

◆ categoryPSet()

◆ categoryPSets()

◆ catInts()

◆ catNone()

◆ catNoPSets()

◆ check()

◆ checkThreshold()

◆ defaultPSet()

◆ destinationPSet()

◆ destinationPSets()

◆ disallowedParam()

◆ keywordCheck()

◆ lookForMatch()

◆ messageLoggerPSet()

◆ noBadParams()

◆ noCoutCerrClash()

◆ noDuplicates() [1/2]

◆ noDuplicates() [2/2]

◆ noKeywords()

◆ noneExcept() [1/4]

◆ noneExcept() [2/4]

◆ noneExcept() [3/4]

◆ noneExcept() [4/4]

◆ noNoncategoryPsets()

◆ noNonPSetUsage()

◆ noOtherPsets()

◆ operator()()

◆ psetLists()

◆ statisticsPSet()

◆ statisticsPSets()

◆ suppressionLists()

◆ validateThreshold()

◆ vStringsCheck()

◆ wildcard()

Member Data Documentation

◆ categories_

◆ debugModules_

◆ destinations_

◆ flaws_

◆ statistics_

◆ suppressDebug_

◆ suppressError_

◆ suppressFwkInfo_

◆ suppressInfo_

◆ suppressWarning_