Project CMSSW displayed by LXR CMSSW_15_1_X_2025-07-14-2300/​FWCore/​ParameterSet/​interface/​ParameterDescriptionNode.h	Source navigation Diff markup Identifier search General search
	Version: CMSSW_15_1_X_2025-07-14-2300 CMSSW_15_1_X_2025-07-13-2300 CMSSW_15_1_X_2025-07-11-2300 CMSSW_15_1_X_2025-07-10-2300 CMSSW_15_1_X_2025-07-08-2300 CMSSW_15_0_4 CMSSW_15_0_3_patch1 CMSSW_14_0_21_patch1 Revert   Change

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

 #ifndef FWCore_ParameterSet_ParameterDescriptionNode_h
 #define FWCore_ParameterSet_ParameterDescriptionNode_h
 
 // This is a base class for the class that describes
 // the parameters that are allowed or required to be
 // in a ParameterSet.  It is also a base class for
 // other more complex logical structures which describe
 // which combinations of parameters are allowed to be
 // in a ParameterSet.
 
 #include "FWCore/Utilities/interface/value_ptr.h"
 
 #include <string>
 #include <set>
 #include <iosfwd>
 #include <memory>
 #include <variant>
 #include <optional>
 #include <unordered_map>
 #include <vector>
 #include <cassert>
 
 namespace edm {
 
   class ParameterSet;
   template <typename T>
   class ParameterDescriptionCases;
   class DocFormatHelper;
 
   // Originally these were defined such that the values were the
   // same as in the ParameterSet Entry class and the validation
   // depended on that.  But at the moment I'm typing this comment,
   // the code no longer depends on the values being the same (which
   // is probably good because nothing enforces the correspondence,
   // a task for the future when someone has free time would be
   // to define the values in a common header, but that would involve
   // significant changes to ParameterSet ...)
   enum ParameterTypes {
     k_int32 = 'I',
     k_vint32 = 'i',
     k_uint32 = 'U',
     k_vuint32 = 'u',
     k_int64 = 'L',
     k_vint64 = 'l',
     k_uint64 = 'X',
     k_vuint64 = 'x',
     k_double = 'D',
     k_vdouble = 'd',
     k_bool = 'B',
     k_stringRaw = 'Z',
     k_vstringRaw = 'z',
     k_stringHex = 'S',
     k_vstringHex = 's',
     k_EventID = 'E',
     k_VEventID = 'e',
     k_LuminosityBlockID = 'M',
     k_VLuminosityBlockID = 'm',
     k_InputTag = 't',
     k_VInputTag = 'v',
     k_ESInputTag = 'g',
     k_VESInputTag = 'G',
     k_FileInPath = 'F',
     k_LuminosityBlockRange = 'A',
     k_VLuminosityBlockRange = 'a',
     k_EventRange = 'R',
     k_VEventRange = 'r',
     k_PSet = 'Q',
     k_VPSet = 'q'
   };
 
   std::string parameterTypeEnumToString(ParameterTypes iType);
 
   enum class ParameterModifier : unsigned char { kNone, kOptional, kObsolete };
   inline ParameterModifier modifierIsOptional(bool iOptional) {
     return iOptional ? ParameterModifier::kOptional : ParameterModifier::kNone;
   }
 
   namespace cfi {
     struct Paths {
       //This is the 'path' through the cms.PSet hierarchy.
       // E.g. foo.bar.tar would have a Path for foo, bar, and tar with
       // tar having a null nodes_ variable.
       std::optional<std::unordered_map<std::string, Paths>> nodes_;
     };
     struct Typed {};
     struct ClassFile {
       void parameterMustBeTyped() {
         Paths* p = &fullPaths_;
         for (auto n : presentPath_) {
           if (not p->nodes_) {
             p->nodes_ = std::unordered_map<std::string, Paths>();
           }
           p = &(p->nodes_.value().emplace(n, Paths{})).first->second;
         }
       }
       void pushNode(std::string_view iNode) { presentPath_.push_back(iNode); }
       void popNode() {
         assert(not presentPath_.empty());
         presentPath_.pop_back();
       }
 
       Paths releasePaths() { return std::move(fullPaths_); }
 
     private:
       std::vector<std::string_view> presentPath_;
       Paths fullPaths_;
     };
     struct Untyped {
       Untyped(Paths iPaths) : paths_(iPaths) {}
       bool needToSwitchToTyped(std::string_view iNode) {
         presentPath_.push_back(iNode);
         if (not paths_.nodes_.has_value()) {
           return false;
         }
         const Paths* p = &paths_;
         for (auto const& n : presentPath_) {
           if (not paths_.nodes_.has_value()) {
             return false;
           }
           auto f = paths_.nodes_->find(std::string(n));
           if (f == paths_.nodes_->end()) {
             return false;
           }
           p = &f->second;
         }
         return not p->nodes_.has_value();
       }
       void popNode() {
         assert(not presentPath_.empty());
         presentPath_.pop_back();
       }
 
     private:
       std::vector<std::string_view> presentPath_;
       Paths paths_;
     };
 
     using CfiOptions = std::variant<cfi::Typed, cfi::ClassFile, cfi::Untyped>;
 
     inline void parameterMustBeTyped(CfiOptions& iOps) noexcept {
       if (std::holds_alternative<cfi::ClassFile>(iOps)) {
         std::get<cfi::ClassFile>(iOps).parameterMustBeTyped();
       }
     }
     inline void parameterMustBeTyped(CfiOptions& iOps, std::string_view iNode) noexcept {
       if (std::holds_alternative<cfi::ClassFile>(iOps)) {
         auto& d = std::get<cfi::ClassFile>(iOps);
         d.pushNode(iNode);
         d.parameterMustBeTyped();
         d.popNode();
       }
     }
     [[nodiscard]] inline bool shouldWriteUntyped(CfiOptions const& iOps) noexcept {
       return std::holds_alternative<cfi::Untyped>(iOps);
     }
 
     struct NodeGuard {
       NodeGuard(CfiOptions& iOp) : options_(&iOp) {}
       NodeGuard() = delete;
       NodeGuard(NodeGuard const&) = delete;
       NodeGuard& operator=(NodeGuard const&) = delete;
       NodeGuard(NodeGuard&& iOther) : options_{iOther.options_} { iOther.options_ = nullptr; }
       NodeGuard& operator=(NodeGuard&& iOther) {
         NodeGuard temp{std::move(iOther)};
         options_ = temp.options_;
         temp.options_ = nullptr;
         return *this;
       }
       ~NodeGuard() {
         if (nullptr == options_) {
           return;
         }
         if (std::holds_alternative<ClassFile>(*options_)) {
           std::get<ClassFile>(*options_).popNode();
         } else if (std::holds_alternative<Untyped>(*options_)) {
           std::get<Untyped>(*options_).popNode();
         }
       }
       CfiOptions* options_;
     };
 
     [[nodiscard]] inline std::pair<bool, NodeGuard> needToSwitchToTyped(std::string_view iNode,
                                                                         CfiOptions& iOpt) noexcept {
       if (std::holds_alternative<Untyped>(iOpt)) {
         return std::pair(std::get<Untyped>(iOpt).needToSwitchToTyped(iNode), NodeGuard(iOpt));
       } else if (std::holds_alternative<ClassFile>(iOpt)) {
         std::get<ClassFile>(iOpt).pushNode(iNode);
       }
       return std::pair(false, NodeGuard(iOpt));
     }
   }  // namespace cfi
   using CfiOptions = cfi::CfiOptions;
 
   struct ParameterTypeToEnum {
     template <class T>
     static ParameterTypes toEnum();
   };
 
   class Comment {
   public:
     Comment();
     explicit Comment(std::string const& iComment);
     explicit Comment(char const* iComment);
     std::string const& comment() const { return comment_; }
 
   private:
     std::string comment_;
   };
 
   class ParameterDescriptionNode {
   public:
     using Modifier = ParameterModifier;
 
     ParameterDescriptionNode() {}
 
     explicit ParameterDescriptionNode(Comment const& iComment) : comment_(iComment.comment()) {}
 
     virtual ~ParameterDescriptionNode();
 
     virtual ParameterDescriptionNode* clone() const = 0;
 
     std::string const& comment() const { return comment_; }
     void setComment(std::string const& value);
     void setComment(char const* value);
 
     // The validate function should do one of three things, find that the
     // node "exists", make the node "exist" by inserting missing parameters
     // or throw.  The only exception to this rule occurs when the argument
     // named "modifier" is kOptional or kObsolete, which should only be possible for the
     // top level nodes of a ParameterSetDescription.  When a parameter is
     // found or inserted its label is added into the list of validatedLabels.
     void validate(ParameterSet& pset, std::set<std::string>& validatedLabels, Modifier modifier) const {
       validate_(pset, validatedLabels, modifier);
     }
 
     // As long as it has default values, this will attempt to write
     // parameters associated with a node into a cfi file that is
     // being automatically generated.  It is quite possible for
     // to produce a cfi that will fail validation.  In some cases,
     // this will imply the user is required to supply certain missing
     // parameters that do not appear in the cfi and do not have defaults
     // in the description.  It is also possible to create a pathological
     // ParameterSetDescription where the algorithm fails to write
     // a valid cfi, in some cases the description can be so pathological
     // that it is impossible to write a cfi that will pass validation.
     void writeCfi(std::ostream& os,
                   Modifier modifier,
                   bool& startWithComma,
                   int indentation,
                   CfiOptions& options,
                   bool& wroteSomething) const {
       writeCfi_(os, modifier, startWithComma, indentation, options, wroteSomething);
     }
 
     // Print out the description in human readable format
     void print(std::ostream& os, Modifier modifier, bool writeToCfi, DocFormatHelper& dfh) const;
 
     bool hasNestedContent() const { return hasNestedContent_(); }
 
     void printNestedContent(std::ostream& os, bool optional, DocFormatHelper& dfh) const;
 
     // The next three functions are only called by the logical nodes
     // on their subnodes.  When executing these functions, the
     // insertion of missing parameters does not occur.
 
     // Usually checks to see if a parameter exists in the configuration, but
     // if the node is a logical node, then it returns the value of the logical
     // expression.
     bool exists(ParameterSet const& pset) const { return exists_(pset); }
 
     // For most nodes, this simply returns the same value as the exists
     // function.  But for AND nodes this returns true if either its subnodes
     // exists.  Used by operator&& during validation, if either of an AND node's
     // subnodes exists, then both subnodes get validated.
     bool partiallyExists(ParameterSet const& pset) const { return partiallyExists_(pset); }
 
     // For most nodes, this simply returns the same value as the exists
     // function. It is different for an XOR node.  It counts
     // XOR subnodes whose exists function returns true.  And it
     // does this recursively into XOR nodes that are contained in
     // other XOR nodes.
     // Used by operator^ during validation:
     // -- if it returns more than 1, then validation will throw,
     // -- if it returns exactly one, then only the nonzero subnode gets validated
     // -- if it returns zero, then validation tries to validate the first node and
     // then rechecks to see what the missing parameter insertion did (there could
     // be side effects on the nodes that were not validated)
     int howManyXORSubNodesExist(ParameterSet const& pset) const { return howManyXORSubNodesExist_(pset); }
 
     /* Validation puts requirements on which parameters can and cannot exist
     within a ParameterSet.  The evaluation of whether a ParameterSet passes
     or fails the rules in the ParameterSetDescription is complicated by
     the fact that we allow missing parameters to be injected into the
     ParameterSet during validation.  One must worry whether injecting a
     missing parameter invalidates some other part of the ParameterSet that
     was already checked and determined to be OK.  The following restrictions
     avoid that problem.
 
         - The same parameter labels cannot occur in different nodes of the
         same ParameterSetDescription.  There are two exceptions to this.
         Nodes that are contained in the cases of a ParameterSwitch or the
         subnodes of an "exclusive or" are allowed to use the same labels.
 
         - If insertion is necessary to make an "exclusive or" node pass
         validation, then the insertion could make more than one of the
         possibilities evaluate true.  This must be checked for after the
         insertions occur. The behavior is to throw a Configuration exception
         if this problem is encountered. (Example: (A && B) ^ (A && C) where
         C already exists in the ParameterSet but A and B do not.  A and B
         get inserted by the algorithm, because it tries to make the first
         possibility true when all fail without insertion.  Then both
         parts of the "exclusive or" pass, which is a validation failure).
 
         - Another potential problem is that a parameter insertion related
         to one ParameterDescription could match unrelated wildcards causing
         other validation requirements to change from being passing to failing
         or vice versa.  This makes it almost impossible to determine if a
         ParameterSet passes validation.  Each time you try to loop through
         and check, the result of validation could change.  To avoid this problem,
         a list is maintained of the type for all wildcards.  Another list is
         maintained for the type of all parameters.  As new items are added
         we check for collisions.  The function that builds the ParameterSetDescription,
         will throw if this rule is violated.  At the moment, the criteria
         for a collision is matching types between a parameter and a wildcard.
         (This criteria is overrestrictive.  With some additional CPU and
         code development the restriction could be loosened to parameters that
         might be injected cannot match the type, trackiness, and wildcard label
         pattern of any wildcard that requires a match.  And further this
         could not apply to wildcards on different branches of a ParameterSwitch
         or "exclusive or".)
 
     These restrictions have the additional benefit that the things they prohibit
     would tend to confuse a user trying to configure a module or a module developer
     writing the code to extract the parameters from a ParameterSet.  These rules
     tend to prohibit bad design.
 
     One strategy to avoid problems with wildcard parameters is to add a nested
     ParameterSet and put the wildcard parameters in the nested ParameterSet.
     The names and types in a nested ParameterSet will not interfere with names
     in the containing ParameterSet.
     */
     void checkAndGetLabelsAndTypes(std::set<std::string>& usedLabels,
                                    std::set<ParameterTypes>& parameterTypes,
                                    std::set<ParameterTypes>& wildcardTypes) const {
       checkAndGetLabelsAndTypes_(usedLabels, parameterTypes, wildcardTypes);
     }
 
     virtual bool isWildcard() const { return false; }
     static void printSpaces(std::ostream& os, int n);
 
   protected:
     virtual void checkAndGetLabelsAndTypes_(std::set<std::string>& usedLabels,
                                             std::set<ParameterTypes>& parameterTypes,
                                             std::set<ParameterTypes>& wildcardTypes) const = 0;
 
     virtual void validate_(ParameterSet& pset, std::set<std::string>& validatedLabels, Modifier modifier) const = 0;
 
     virtual void writeCfi_(std::ostream& os,
                            Modifier modifier,
                            bool& startWithComma,
                            int indentation,
                            CfiOptions&,
                            bool& wroteSomething) const = 0;
 
     virtual void print_(std::ostream&, Modifier /*modifier*/, bool /*writeToCfi*/, DocFormatHelper&) const {}
 
     virtual bool hasNestedContent_() const { return false; }
 
     virtual void printNestedContent_(std::ostream&, bool /*optional*/, DocFormatHelper&) const {}
 
     virtual bool exists_(ParameterSet const& pset) const = 0;
 
     virtual bool partiallyExists_(ParameterSet const& pset) const = 0;
 
     virtual int howManyXORSubNodesExist_(ParameterSet const& pset) const = 0;
 
     std::string comment_;
   };
 
   template <>
   struct value_ptr_traits<ParameterDescriptionNode> {
     static ParameterDescriptionNode* clone(ParameterDescriptionNode const* p) { return p->clone(); }
     static void destroy(ParameterDescriptionNode* p) { delete p; }
   };
 
   // operator>> ---------------------------------------------
 
   std::unique_ptr<ParameterDescriptionCases<bool>> operator>>(bool caseValue, ParameterDescriptionNode const& node);
 
   std::unique_ptr<ParameterDescriptionCases<int>> operator>>(int caseValue, ParameterDescriptionNode const& node);
 
   std::unique_ptr<ParameterDescriptionCases<std::string>> operator>>(std::string const& caseValue,
                                                                      ParameterDescriptionNode const& node);
 
   std::unique_ptr<ParameterDescriptionCases<std::string>> operator>>(char const* caseValue,
                                                                      ParameterDescriptionNode const& node);
 
   std::unique_ptr<ParameterDescriptionCases<bool>> operator>>(bool caseValue,
                                                               std::unique_ptr<ParameterDescriptionNode> node);
 
   std::unique_ptr<ParameterDescriptionCases<int>> operator>>(int caseValue,
                                                              std::unique_ptr<ParameterDescriptionNode> node);
 
   std::unique_ptr<ParameterDescriptionCases<std::string>> operator>>(std::string const& caseValue,
                                                                      std::unique_ptr<ParameterDescriptionNode> node);
 
   std::unique_ptr<ParameterDescriptionCases<std::string>> operator>>(char const* caseValue,
                                                                      std::unique_ptr<ParameterDescriptionNode> node);
 
   // operator&& ---------------------------------------------
 
   std::unique_ptr<ParameterDescriptionNode> operator&&(ParameterDescriptionNode const& node_left,
                                                        ParameterDescriptionNode const& node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator&&(std::unique_ptr<ParameterDescriptionNode> node_left,
                                                        ParameterDescriptionNode const& node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator&&(ParameterDescriptionNode const& node_left,
                                                        std::unique_ptr<ParameterDescriptionNode> node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator&&(std::unique_ptr<ParameterDescriptionNode> node_left,
                                                        std::unique_ptr<ParameterDescriptionNode> node_right);
 
   // operator|| ---------------------------------------------
 
   std::unique_ptr<ParameterDescriptionNode> operator||(ParameterDescriptionNode const& node_left,
                                                        ParameterDescriptionNode const& node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator||(std::unique_ptr<ParameterDescriptionNode> node_left,
                                                        ParameterDescriptionNode const& node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator||(ParameterDescriptionNode const& node_left,
                                                        std::unique_ptr<ParameterDescriptionNode> node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator||(std::unique_ptr<ParameterDescriptionNode> node_left,
                                                        std::unique_ptr<ParameterDescriptionNode> node_right);
 
   // operator^  ---------------------------------------------
 
   std::unique_ptr<ParameterDescriptionNode> operator^(ParameterDescriptionNode const& node_left,
                                                       ParameterDescriptionNode const& node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator^(std::unique_ptr<ParameterDescriptionNode> node_left,
                                                       ParameterDescriptionNode const& node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator^(ParameterDescriptionNode const& node_left,
                                                       std::unique_ptr<ParameterDescriptionNode> node_right);
 
   std::unique_ptr<ParameterDescriptionNode> operator^(std::unique_ptr<ParameterDescriptionNode> node_left,
                                                       std::unique_ptr<ParameterDescriptionNode> node_right);
 }  // namespace edm
 #endif

This page was automatically generated by the 2.2.1 LXR engine. The LXR team