#include <ConfigurationDescriptions.h>

Classes
class	DescriptionCounter

Public Types
typedef std::vector< std::pair< std::string, ParameterSetDescription > >::iterator	iterator

Public Member Functions
void	add (std::string const &label, ParameterSetDescription const &psetDescription)

void	add (char const *label, ParameterSetDescription const &psetDescription)

void	addDefault (ParameterSetDescription const &psetDescription)

void	addWithDefaultLabel (ParameterSetDescription const &psetDescription)

iterator	begin ()

std::string const &	comment () const

	ConfigurationDescriptions (std::string const &baseType, std::string const &pluginName)

ParameterSetDescription *	defaultDescription ()
	Returns 0 if no default has been assigned. More...

iterator	end ()

void	print (std::ostream &os, std::string const &moduleLabel, bool brief, bool printOnlyLabels, size_t lineWidth, int indentation, int iPlugin) const

void	setComment (std::string const &value)

void	setComment (char const *value)

void	validate (ParameterSet &pset, std::string const &moduleLabel) const

void	writeCfis (std::set< std::string > &usedCfiFileNames) const

	~ConfigurationDescriptions ()

Private Member Functions
void	printForLabel (std::pair< std::string, ParameterSetDescription > const &labelAndDesc, std::ostream &os, std::string const &moduleLabel, bool brief, bool printOnlyLabels, size_t lineWidth, int indentationn, DescriptionCounter &counter) const

void	printForLabel (std::ostream &os, std::string const &label, ParameterSetDescription const &description, std::string const &moduleLabel, bool brief, bool printOnlyLabels, size_t lineWidth, int indentationn, DescriptionCounter &counter) const

Static Private Member Functions
static void	writeCfiForLabel (std::pair< std::string, ParameterSetDescription > const &labelAndDesc, std::string const &baseType, std::string const &pluginName, std::set< std::string > &usedCfiFileNames)

Private Attributes
std::string	baseType_

std::string	comment_

ParameterSetDescription	defaultDesc_

bool	defaultDescDefined_

std::vector< std::pair< std::string, ParameterSetDescription > >	descriptions_

std::string	pluginName_

Detailed Description

Definition at line 28 of file ConfigurationDescriptions.h.

Member Typedef Documentation

◆ iterator

typedef std::vector<std::pair<std::string, ParameterSetDescription> >::iterator edm::ConfigurationDescriptions::iterator

Definition at line 30 of file ConfigurationDescriptions.h.

Constructor & Destructor Documentation

◆ ConfigurationDescriptions()

ConfigurationDescriptions::ConfigurationDescriptions	(	std::string const &	baseType,
		std::string const &	pluginName
	)

Definition at line 43 of file ConfigurationDescriptions.cc.

44 : baseType_(baseType), pluginName_(pluginName), defaultDescDefined_(false) {}

edm::ConfigurationDescriptions::defaultDescDefined_

bool defaultDescDefined_

Definition: ConfigurationDescriptions.h:117

crabTemplate.pluginName

pluginName

Definition: crabTemplate.py:17

edm::ConfigurationDescriptions::pluginName_

std::string pluginName_

Definition: ConfigurationDescriptions.h:110

edm::ConfigurationDescriptions::baseType_

std::string baseType_

Definition: ConfigurationDescriptions.h:109

◆ ~ConfigurationDescriptions()

ConfigurationDescriptions::~ConfigurationDescriptions ( )

Definition at line 46 of file ConfigurationDescriptions.cc.

46 {}

Member Function Documentation

◆ add() [1/2]

void ConfigurationDescriptions::add	(	std::string const &	label,
		ParameterSetDescription const &	psetDescription
	)

Definition at line 57 of file ConfigurationDescriptions.cc.

References baseType_, defaultDescDefined_, descriptions_, Exception, k_source, kService, edm::kSource, label, and edm::errors::LogicError.

                                                                                                             {
     if (0 == strcmp(baseType_.c_str(), kSource)) {
       if (0 != strcmp(label.c_str(), k_source)) {
         throw edm::Exception(edm::errors::LogicError,
                              "ConfigurationDescriptions::add, when adding a ParameterSetDescription for a source the "
                              "label must be \"source\"\n");
       }
       if (!descriptions_.empty() || defaultDescDefined_ == true) {
         throw edm::Exception(
             edm::errors::LogicError,
             "ConfigurationDescriptions::add, for a source only 1 ParameterSetDescription may be added\n");
       }
     } else if (0 == strcmp(baseType_.c_str(), kService)) {
       if (!descriptions_.empty() || defaultDescDefined_ == true) {
         throw edm::Exception(
             edm::errors::LogicError,
             "ConfigurationDescriptions::add, for a service only 1 ParameterSetDescription may be added\n");
       }
     }
 
     // To minimize the number of copies involved create an empty description first
     // and push it into the vector.  Then perform the copy.
     std::pair<std::string, ParameterSetDescription> pairWithEmptyDescription;
     descriptions_.push_back(pairWithEmptyDescription);
     std::pair<std::string, ParameterSetDescription>& pair = descriptions_.back();
 
     pair.first = label;
     pair.second = psetDescription;
   }

◆ add() [2/2]

void ConfigurationDescriptions::add	(	char const *	label,
		ParameterSetDescription const &	psetDescription
	)

Definition at line 52 of file ConfigurationDescriptions.cc.

References add(), label, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by counter.Counter::register(), SequenceTypes._TaskBase::remove(), and SequenceTypes._TaskBase::replace().

                                                                                                        {
     std::string labelString(label);
     add(labelString, psetDescription);
   }

◆ addDefault()

void ConfigurationDescriptions::addDefault ( ParameterSetDescription const & psetDescription )

Definition at line 99 of file ConfigurationDescriptions.cc.

References baseType_, defaultDesc_, defaultDescDefined_, descriptions_, Exception, kService, edm::kSource, and edm::errors::LogicError.

                                                                                            {
     if (0 == strcmp(baseType_.c_str(), kSource) || 0 == strcmp(baseType_.c_str(), kService)) {
       if (!descriptions_.empty() || defaultDescDefined_ == true) {
         throw edm::Exception(edm::errors::LogicError,
                              "ConfigurationDescriptions::addDefault, for a source or service only 1 "
                              "ParameterSetDescription may be added\n");
       }
     }
 
     defaultDescDefined_ = true;
     defaultDesc_ = psetDescription;
   }

◆ addWithDefaultLabel()

void ConfigurationDescriptions::addWithDefaultLabel ( ParameterSetDescription const & psetDescription )

Definition at line 87 of file ConfigurationDescriptions.cc.

References add(), baseType_, edm::defaultModuleLabel(), kService, edm::kSource, label, pluginName_, and AlCaHLTBitMon_QueryRunRegistry::string.

                                                                                                     {
     std::string label;
     if (kService == baseType_) {
       label = pluginName_;
     } else if (kSource == baseType_) {
       label = "source";
     } else {
       label = defaultModuleLabel(pluginName_);
     }
     add(label, psetDescription);
   }

◆ begin()

ConfigurationDescriptions::iterator ConfigurationDescriptions::begin ( void )

Definition at line 119 of file ConfigurationDescriptions.cc.

References descriptions_.

119 { return descriptions_.begin(); }

edm::ConfigurationDescriptions::descriptions_

std::vector< std::pair< std::string, ParameterSetDescription > > descriptions_

Definition: ConfigurationDescriptions.h:112

◆ comment()

std::string const& edm::ConfigurationDescriptions::comment ( ) const

inline

Definition at line 44 of file ConfigurationDescriptions.h.

References comment_.

Referenced by print().

44 { return comment_; }

edm::ConfigurationDescriptions::comment_

std::string comment_

Definition: ConfigurationDescriptions.h:116

◆ defaultDescription()

ParameterSetDescription * ConfigurationDescriptions::defaultDescription ( )

Returns 0 if no default has been assigned.

Definition at line 112 of file ConfigurationDescriptions.cc.

References defaultDesc_, and defaultDescDefined_.

Referenced by edm::edmodule_mightGet_config(), cms::alpakatools::module_backend_config(), and edm::eventsetup::ESProductResolverProvider::prevalidate().

                                                                          {
     if (defaultDescDefined_) {
       return &defaultDesc_;
     }
     return nullptr;
   }

◆ end()

ConfigurationDescriptions::iterator ConfigurationDescriptions::end ( void )

Definition at line 121 of file ConfigurationDescriptions.cc.

References descriptions_.

Referenced by Types.LuminosityBlockRange::cppID(), and Types.EventRange::cppID().

121 { return descriptions_.end(); }

edm::ConfigurationDescriptions::descriptions_

std::vector< std::pair< std::string, ParameterSetDescription > > descriptions_

Definition: ConfigurationDescriptions.h:112

◆ print()

void ConfigurationDescriptions::print	(	std::ostream &	os,
		std::string const &	moduleLabel,
		bool	brief,
		bool	printOnlyLabels,
		size_t	lineWidth,
		int	indentation,
		int	iPlugin
	)		const

Definition at line 223 of file ConfigurationDescriptions.cc.

References comment(), counter, ztail::d, defaultDesc_, defaultDescDefined_, descriptions_, relativeConstraints::empty, printContent_cfi::indentation, edm::ParameterSetDescription::isUnknown(), RecoTauValidation_cfi::lineWidth, HerwigMaxPtPartonFilter_cfi::moduleLabel, edm::DocFormatHelper::offsetModuleLabel(), printForLabel(), contentValuesCheck::ss, AlCaHLTBitMon_QueryRunRegistry::string, mitigatedMETSequence_cff::U, and edm::DocFormatHelper::wrapAndPrintText().

                                                            {
     if (!brief) {
       if (!comment().empty()) {
         DocFormatHelper::wrapAndPrintText(os, comment(), indentation, lineWidth);
       }
       os << "\n";
     }
 
     if (descriptions_.empty() && !defaultDescDefined_) {
       char oldFill = os.fill();
       indentation += DocFormatHelper::offsetModuleLabel();
       os << std::setfill(' ') << std::setw(indentation) << "";
       os << "There are no PSet descriptions defined for this plugin.\n";
       os << std::setfill(' ') << std::setw(indentation) << "";
       os << "PSets will not be validated and no cfi files will be generated.\n";
       os << std::setfill(oldFill);
       if (!brief)
         os << "\n";
       return;
     }
 
     if (descriptions_.empty() && defaultDescDefined_ && defaultDesc_.isUnknown()) {
       indentation += DocFormatHelper::offsetModuleLabel();
       char oldFill = os.fill();
       os << std::setfill(' ') << std::setw(indentation) << "";
       os << "This plugin has not implemented the function which defines its\n";
       os << std::setfill(' ') << std::setw(indentation) << "";
       os << "configuration descriptions yet. No descriptions are available.\n";
       os << std::setfill(' ') << std::setw(indentation) << "";
       os << "Its PSets will not be validated, and no cfi files will be generated.\n";
       os << std::setfill(oldFill);
       if (!brief)
         os << "\n";
       return;
     }
 
     if (!brief) {
       std::stringstream ss;
       if (defaultDescDefined_) {
         if (descriptions_.empty()) {
           ss << "This plugin has only one PSet description. "
              << "This description is always used to validate configurations. "
              << "Because this configuration has no label, no cfi files will be generated.";
         } else {
           ss << "This plugin has " << (descriptions_.size() + 1U) << " PSet descriptions. "
              << "The description used to validate a configuration is selected by "
              << "matching the module labels. If none match, then the last description, "
              << "which has no label, is selected. "
              << "A cfi file will be generated for each configuration with a module label.";
         }
       } else {
         if (descriptions_.size() == 1U) {
           ss << "This plugin has " << descriptions_.size() << " PSet description. "
              << "This description is always used to validate configurations. "
              << "The label below is used when generating the cfi file.";
         } else {
           ss << "This plugin has " << descriptions_.size() << " PSet descriptions. "
              << "The description used to validate a configuration is selected by "
              << "matching the module labels. If none match the first description below is used. "
              << "The module labels below are also used when generating the cfi files.";
         }
       }
       DocFormatHelper::wrapAndPrintText(os, ss.str(), indentation, lineWidth);
       os << "\n";
     }
 
     indentation += DocFormatHelper::offsetModuleLabel();
 
     DescriptionCounter counter;
     counter.iPlugin = iPlugin;
     counter.iSelectedModule = 0;
     counter.iModule = 0;
 
     for (auto const& d : descriptions_) {
       printForLabel(d, os, moduleLabel, brief, printOnlyLabels, lineWidth, indentation, counter);
     }
 
     if (defaultDescDefined_) {
       printForLabel(os,
                     std::string("@default"),
                     defaultDesc_,
                     moduleLabel,
                     brief,
                     printOnlyLabels,
                     lineWidth,
                     indentation,
                     counter);
     }
   }

◆ printForLabel() [1/2]

void ConfigurationDescriptions::printForLabel	(	std::pair< std::string, ParameterSetDescription > const &	labelAndDesc,
		std::ostream &	os,
		std::string const &	moduleLabel,
		bool	brief,
		bool	printOnlyLabels,
		size_t	lineWidth,
		int	indentationn,
		DescriptionCounter &	counter
	)		const

private

Definition at line 319 of file ConfigurationDescriptions.cc.

References printContent_cfi::indentation, RecoTauValidation_cfi::lineWidth, and HerwigMaxPtPartonFilter_cfi::moduleLabel.

Referenced by print().

                                                                                    {
     printForLabel(os,
                   labelAndDesc.first,
                   labelAndDesc.second,
                   moduleLabel,
                   brief,
                   printOnlyLabels,
                   lineWidth,
                   indentation,
                   counter);
   }

◆ printForLabel() [2/2]

void ConfigurationDescriptions::printForLabel	(	std::ostream &	os,
		std::string const &	label,
		ParameterSetDescription const &	description,
		std::string const &	moduleLabel,
		bool	brief,
		bool	printOnlyLabels,
		size_t	lineWidth,
		int	indentationn,
		DescriptionCounter &	counter
	)		const

private

Definition at line 338 of file ConfigurationDescriptions.cc.

                                                                                    {
     ++counter.iModule;
     if (!moduleLabel.empty() && label != moduleLabel)
       return;
     ++counter.iSelectedModule;
 
     std::stringstream ss;
     ss << counter.iPlugin << "." << counter.iSelectedModule;
     std::string section = ss.str();
 
     char oldFill = os.fill();
     os << std::setfill(' ') << std::setw(indentation) << "" << std::setfill(oldFill);
     os << section << " ";
     if (label == std::string("@default")) {
       os << "description without a module label\n";
     } else {
       if (!brief) {
         if (0 == strcmp(baseType_.c_str(), kSource) || 0 == strcmp(baseType_.c_str(), kService)) {
           os << "label: ";
         } else {
           os << "module label: ";
         }
       }
       os << label << "\n";
     }
 
     if (!brief) {
       if (!description.comment().empty()) {
         DocFormatHelper::wrapAndPrintText(os, description.comment(), indentation, lineWidth - indentation);
       }
       os << "\n";
     }
     if (printOnlyLabels)
       return;
 
     DocFormatHelper dfh;
     dfh.setBrief(brief);
     dfh.setLineWidth(lineWidth);
     dfh.setIndentation(indentation + DocFormatHelper::offsetTopLevelPSet());
     dfh.setSection(section);
     dfh.setParent(DocFormatHelper::TOP);
 
     description.print(os, dfh);
   }

◆ setComment() [1/2]

void ConfigurationDescriptions::setComment ( std::string const & value )

Definition at line 48 of file ConfigurationDescriptions.cc.

References comment_, and relativeConstraints::value.

48 { comment_ = value; }

edm::ConfigurationDescriptions::comment_

std::string comment_

Definition: ConfigurationDescriptions.h:116

relativeConstraints.value

value

Definition: relativeConstraints.py:53

◆ setComment() [2/2]

void ConfigurationDescriptions::setComment ( char const * value )

Definition at line 50 of file ConfigurationDescriptions.cc.

References comment_, and relativeConstraints::value.

Referenced by ConfigToolBase.ConfigToolBase::apply().

50 { comment_ = value; }

edm::ConfigurationDescriptions::comment_

std::string comment_

Definition: ConfigurationDescriptions.h:116

relativeConstraints.value

value

Definition: relativeConstraints.py:53

◆ validate()

void ConfigurationDescriptions::validate	(	ParameterSet &	pset,
		std::string const &	moduleLabel
	)		const

Definition at line 123 of file ConfigurationDescriptions.cc.

References defaultDesc_, defaultDescDefined_, descriptions_, edm::for_all(), HerwigMaxPtPartonFilter_cfi::moduleLabel, muonDTDigis_cfi::pset, and edm::ParameterSetDescription::validate().

Referenced by edm::eventsetup::ComponentMaker< edm::eventsetup::LooperMakerTraits, TType >::addTo(), and edm::Maker::makeModule().

                                                                                                  {
     ParameterSetDescription const* psetDesc = nullptr;
     for_all(descriptions_, std::bind(&matchLabel, std::placeholders::_1, std::cref(moduleLabel), std::ref(psetDesc)));
 
     // If there is a matching label
     if (psetDesc != nullptr) {
       psetDesc->validate(pset);
     }
     // Is there an explicit description to be used for a non standard label
     else if (defaultDescDefined_) {
       defaultDesc_.validate(pset);
     }
     // Otherwise use the first one.
     else if (!descriptions_.empty()) {
       descriptions_[0].second.validate(pset);
     }
     // It is possible for no descriptions to be defined and no validation occurs
     // for this module ever.
   }

◆ writeCfiForLabel()

void ConfigurationDescriptions::writeCfiForLabel	(	std::pair< std::string, ParameterSetDescription > const &	labelAndDesc,
		std::string const &	baseType,
		std::string const &	pluginName,
		std::set< std::string > &	usedCfiFileNames
	)

staticprivate

Definition at line 152 of file ConfigurationDescriptions.cc.

References cms::Exception::addContext(), gather_cfg::cout, Exception, printContent_cfi::indentation, kService, edm::kSource, edm::errors::LogicError, L1TdeCSCTF_cfi::outFile, crabTemplate::pluginName, and AlCaHLTBitMon_QueryRunRegistry::string.

Referenced by writeCfis().

                                                                                         {
     if (0 == strcmp(baseType.c_str(), kService) && labelAndDesc.first != pluginName) {
       throw edm::Exception(edm::errors::LogicError,
                            "ConfigurationDescriptions::writeCfiForLabel\nFor a service the label and the plugin name "
                            "must be the same.\n")
           << "This error is probably caused by an incorrect label being passed\nto the ConfigurationDescriptions::add "
              "function earlier.\n"
           << "plugin name = \"" << pluginName << "\"  label name = \"" << labelAndDesc.first << "\"\n";
     }
 
     std::string cfi_filename;
     if (0 == strcmp(baseType.c_str(), kSource)) {
       cfi_filename = pluginName + "_cfi.py";
     } else {
       cfi_filename = labelAndDesc.first + "_cfi.py";
     }
     if (!usedCfiFileNames.insert(cfi_filename).second) {
       edm::Exception ex(edm::errors::LogicError,
                         "Two cfi files are being generated with the same name in the same directory.\n");
       ex << "The cfi file name is '" << cfi_filename << "' and\n"
          << "the module label is \'" << labelAndDesc.first << "\'.\n"
          << "This error is probably caused by an error in one or more fillDescriptions functions\n"
          << "where duplicate module labels are being passed to the ConfigurationDescriptions::add\n"
          << "function. All such module labels must be unique within a package.\n"
          << "If you do not want the generated cfi file and do not need more than one\n"
          << "description for a plugin, then a way to fix this is to use the addDefault\n"
          << "function instead of the add function.\n"
          << "There are 3 common ways this problem can happen.\n"
          << "1. This can happen when a module label is explicitly duplicated in one or more\n"
          << "fillDescriptions functions. Fix these by changing the module labels to be unique.\n"
          << "2. This can also happen when a module class is a template class and plugins are\n"
          << "defined by instantiations with differing template parameters and these plugins\n"
          << "share the same fillDescriptions function. Fix these by specializing the fillDescriptions\n"
          << "function for each template instantiation.\n"
          << "3. This can also happen when there is an inheritance heirarchy and multiple plugin modules\n"
          << "are defined using derived classes and the base class which share the same fillDescriptions\n"
          << "function. Fix these by redefining the fillDescriptions function in each derived class.\n";
       ex.addContext("Executing function ConfigurationDescriptions::writeCfiForLabel");
       throw ex;
     }
     std::ofstream outFile(cfi_filename.c_str());
     if (outFile.fail()) {
       edm::Exception ex(edm::errors::LogicError, "Creating cfi file failed.\n");
       ex << "Opening a file '" << cfi_filename << "' for module '" << labelAndDesc.first << "' failed.\n";
       ex << "Error code from errno " << errno << ": " << std::strerror(errno) << "\n";
 
       ex.addContext("Executing function ConfigurationDescriptions::writeCfiForLabel");
       throw ex;
     }
 
     outFile << "import FWCore.ParameterSet.Config as cms\n\n";
     outFile << labelAndDesc.first << " = cms." << baseType << "('" << pluginName << "'";
 
     bool startWithComma = true;
     int indentation = 2;
     labelAndDesc.second.writeCfi(outFile, startWithComma, indentation);
 
     outFile << ")\n";
 
     outFile.close();
 
     if (0 == strcmp(baseType.c_str(), kSource)) {
       std::cout << pluginName << "\n";
     } else {
       std::cout << labelAndDesc.first << "\n";
     }
   }

◆ writeCfis()

void ConfigurationDescriptions::writeCfis ( std::set< std::string > & usedCfiFileNames ) const

Definition at line 143 of file ConfigurationDescriptions.cc.

References baseType_, descriptions_, edm::for_all(), pluginName_, and writeCfiForLabel().

                                                                                      {
     for_all(descriptions_,
             std::bind(&ConfigurationDescriptions::writeCfiForLabel,
                       std::placeholders::_1,
                       std::cref(baseType_),
                       std::cref(pluginName_),
                       std::ref(usedCfiFileNames)));
   }