Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2025-03-26 01:51:14

0001 #include "FWCore/ParameterSet/interface/ParameterWildcard.h"
0002 
0003 #include "FWCore/ParameterSet/interface/DocFormatHelper.h"
0004 #include "FWCore/ParameterSet/interface/ParameterSetDescription.h"
0005 #include "FWCore/ParameterSet/interface/VParameterSetEntry.h"
0006 #include "FWCore/Utilities/interface/Algorithms.h"
0007 
0008 #include <cassert>
0009 #include <iomanip>
0010 #include <ostream>
0011 
0012 namespace edm {
0013 
0014   ParameterWildcard<ParameterSetDescription>::ParameterWildcard(std::string const& pattern,
0015                                                                 WildcardValidationCriteria criteria,
0016                                                                 bool isTracked)
0017       : ParameterWildcardBase(k_PSet, isTracked, criteria), psetDesc_() {
0018     throwIfInvalidPattern(pattern);
0019   }
0020 
0021   ParameterWildcard<ParameterSetDescription>::ParameterWildcard(char const* pattern,
0022                                                                 WildcardValidationCriteria criteria,
0023                                                                 bool isTracked)
0024       : ParameterWildcardBase(k_PSet, isTracked, criteria), psetDesc_() {
0025     throwIfInvalidPattern(pattern);
0026   }
0027 
0028   ParameterWildcard<ParameterSetDescription>::ParameterWildcard(std::string const& pattern,
0029                                                                 WildcardValidationCriteria criteria,
0030                                                                 bool isTracked,
0031                                                                 ParameterSetDescription const& desc)
0032       : ParameterWildcardBase(k_PSet, isTracked, criteria), psetDesc_(new ParameterSetDescription(desc)) {
0033     throwIfInvalidPattern(pattern);
0034   }
0035 
0036   ParameterWildcard<ParameterSetDescription>::ParameterWildcard(char const* pattern,
0037                                                                 WildcardValidationCriteria criteria,
0038                                                                 bool isTracked,
0039                                                                 ParameterSetDescription const& desc)
0040       : ParameterWildcardBase(k_PSet, isTracked, criteria), psetDesc_(new ParameterSetDescription(desc)) {
0041     throwIfInvalidPattern(pattern);
0042   }
0043 
0044   ParameterWildcard<ParameterSetDescription>::~ParameterWildcard() {}
0045 
0046   ParameterDescriptionNode* ParameterWildcard<ParameterSetDescription>::clone() const {
0047     return new ParameterWildcard(*this);
0048   }
0049 
0050   void ParameterWildcard<ParameterSetDescription>::validate_(ParameterSet& pset,
0051                                                              std::set<std::string>& validatedLabels,
0052                                                              Modifier modifier) const {
0053     std::vector<std::string> parameterNames = pset.getParameterNamesForType<ParameterSet>(isTracked());
0054     validateMatchingNames(parameterNames, validatedLabels, modifier == Modifier::kOptional);
0055 
0056     if (psetDesc_) {
0057       for_all(parameterNames,
0058               std::bind(&ParameterWildcard<ParameterSetDescription>::validateDescription,
0059                         this,
0060                         std::placeholders::_1,
0061                         std::ref(pset)));
0062     }
0063   }
0064 
0065   void ParameterWildcard<ParameterSetDescription>::validateDescription(std::string const& parameterName,
0066                                                                        ParameterSet& pset) const {
0067     ParameterSet* containedPSet = pset.getPSetForUpdate(parameterName);
0068     psetDesc_->validate(*containedPSet);
0069   }
0070 
0071   bool ParameterWildcard<ParameterSetDescription>::hasNestedContent_() const {
0072     if (psetDesc_)
0073       return true;
0074     return false;
0075   }
0076 
0077   void ParameterWildcard<ParameterSetDescription>::printNestedContent_(std::ostream& os,
0078                                                                        bool /*optional*/,
0079                                                                        DocFormatHelper& dfh) const {
0080     int indentation = dfh.indentation();
0081     if (dfh.parent() != DocFormatHelper::TOP) {
0082       indentation -= DocFormatHelper::offsetSectionContent();
0083     }
0084 
0085     printSpaces(os, indentation);
0086     os << "Section " << dfh.section() << "." << dfh.counter() << " description of PSet matching wildcard:";
0087     os << "\n";
0088     if (!dfh.brief())
0089       os << "\n";
0090 
0091     std::stringstream ss;
0092     ss << dfh.section() << "." << dfh.counter();
0093     std::string newSection = ss.str();
0094 
0095     DocFormatHelper new_dfh(dfh);
0096     new_dfh.setSection(newSection);
0097     new_dfh.setIndentation(indentation + DocFormatHelper::offsetSectionContent());
0098     new_dfh.setParent(DocFormatHelper::OTHER);
0099 
0100     psetDesc_->print(os, new_dfh);
0101   }
0102 
0103   bool ParameterWildcard<ParameterSetDescription>::exists_(ParameterSet const& pset) const {
0104     if (criteria() == RequireZeroOrMore)
0105       return true;
0106 
0107     std::vector<std::string> parameterNames = pset.getParameterNamesForType<ParameterSet>(isTracked());
0108 
0109     if (criteria() == RequireAtLeastOne)
0110       return !parameterNames.empty();
0111     return parameterNames.size() == 1U;
0112   }
0113 
0114   void ParameterWildcard<ParameterSetDescription>::writeTemplate(std::ostream& os,
0115                                                                  int indentation,
0116                                                                  CfiOptions& options) const {
0117     os << "PSetTemplate(";
0118     indentation += 2;
0119     if (psetDesc_) {
0120       psetDesc_->writeCfi(os, false, indentation, options);
0121     }
0122     os << ")";
0123   }
0124 
0125   // -------------------------------------------------------------------------
0126 
0127   ParameterWildcard<std::vector<ParameterSet> >::ParameterWildcard(std::string const& pattern,
0128                                                                    WildcardValidationCriteria criteria,
0129                                                                    bool isTracked)
0130       : ParameterWildcardBase(k_VPSet, isTracked, criteria), psetDesc_() {
0131     throwIfInvalidPattern(pattern);
0132   }
0133 
0134   ParameterWildcard<std::vector<ParameterSet> >::ParameterWildcard(char const* pattern,
0135                                                                    WildcardValidationCriteria criteria,
0136                                                                    bool isTracked)
0137       : ParameterWildcardBase(k_VPSet, isTracked, criteria), psetDesc_() {
0138     throwIfInvalidPattern(pattern);
0139   }
0140 
0141   ParameterWildcard<std::vector<ParameterSet> >::ParameterWildcard(std::string const& pattern,
0142                                                                    WildcardValidationCriteria criteria,
0143                                                                    bool isTracked,
0144                                                                    ParameterSetDescription const& desc)
0145       : ParameterWildcardBase(k_VPSet, isTracked, criteria), psetDesc_(new ParameterSetDescription(desc)) {
0146     throwIfInvalidPattern(pattern);
0147   }
0148 
0149   ParameterWildcard<std::vector<ParameterSet> >::ParameterWildcard(char const* pattern,
0150                                                                    WildcardValidationCriteria criteria,
0151                                                                    bool isTracked,
0152                                                                    ParameterSetDescription const& desc)
0153       : ParameterWildcardBase(k_VPSet, isTracked, criteria), psetDesc_(new ParameterSetDescription(desc)) {
0154     throwIfInvalidPattern(pattern);
0155   }
0156 
0157   ParameterWildcard<std::vector<ParameterSet> >::~ParameterWildcard() {}
0158 
0159   ParameterDescriptionNode* ParameterWildcard<std::vector<ParameterSet> >::clone() const {
0160     return new ParameterWildcard(*this);
0161   }
0162 
0163   void ParameterWildcard<std::vector<ParameterSet> >::validate_(ParameterSet& pset,
0164                                                                 std::set<std::string>& validatedLabels,
0165                                                                 Modifier modifier) const {
0166     std::vector<std::string> parameterNames = pset.getParameterNamesForType<std::vector<ParameterSet> >(isTracked());
0167     validateMatchingNames(parameterNames, validatedLabels, modifier == Modifier::kOptional);
0168 
0169     if (psetDesc_) {
0170       for_all(parameterNames,
0171               std::bind(&ParameterWildcard<std::vector<ParameterSet> >::validatePSetVector,
0172                         this,
0173                         std::placeholders::_1,
0174                         std::ref(pset)));
0175     }
0176   }
0177 
0178   void ParameterWildcard<std::vector<ParameterSet> >::validatePSetVector(std::string const& parameterName,
0179                                                                          ParameterSet& pset) const {
0180     VParameterSetEntry* vpsetEntry = pset.getPSetVectorForUpdate(parameterName);
0181     assert(vpsetEntry);
0182     for (unsigned i = 0; i < vpsetEntry->size(); ++i) {
0183       psetDesc_->validate(vpsetEntry->psetInVector(i));
0184     }
0185   }
0186 
0187   bool ParameterWildcard<std::vector<ParameterSet> >::hasNestedContent_() const {
0188     if (psetDesc_)
0189       return true;
0190     return false;
0191   }
0192 
0193   void ParameterWildcard<std::vector<ParameterSet> >::printNestedContent_(std::ostream& os,
0194                                                                           bool /*optional*/,
0195                                                                           DocFormatHelper& dfh) const {
0196     int indentation = dfh.indentation();
0197     if (dfh.parent() != DocFormatHelper::TOP) {
0198       indentation -= DocFormatHelper::offsetSectionContent();
0199     }
0200 
0201     printSpaces(os, indentation);
0202     os << "Section " << dfh.section() << "." << dfh.counter()
0203        << " description used to validate all PSets which are in the VPSet matching the wildcard:";
0204     os << "\n";
0205     if (!dfh.brief())
0206       os << "\n";
0207 
0208     std::stringstream ss;
0209     ss << dfh.section() << "." << dfh.counter();
0210     std::string newSection = ss.str();
0211 
0212     DocFormatHelper new_dfh(dfh);
0213     new_dfh.setSection(newSection);
0214     new_dfh.setIndentation(indentation + DocFormatHelper::offsetSectionContent());
0215     new_dfh.setParent(DocFormatHelper::OTHER);
0216 
0217     psetDesc_->print(os, new_dfh);
0218   }
0219 
0220   bool ParameterWildcard<std::vector<ParameterSet> >::exists_(ParameterSet const& pset) const {
0221     if (criteria() == RequireZeroOrMore)
0222       return true;
0223 
0224     std::vector<std::string> parameterNames = pset.getParameterNamesForType<std::vector<ParameterSet> >(isTracked());
0225 
0226     if (criteria() == RequireAtLeastOne)
0227       return !parameterNames.empty();
0228     return parameterNames.size() == 1U;
0229   }
0230 }  // namespace edm