Back to home page

Project CMSSW displayed by LXR

 
 

    


File indexing completed on 2021-05-31 03:10:34

0001 #ifndef FWCore_ParameterSet_ParameterSet_h
0002 #define FWCore_ParameterSet_ParameterSet_h
0003 
0004 // ----------------------------------------------------------------------
0005 // Declaration for ParameterSet(parameter set) and related types
0006 // ----------------------------------------------------------------------
0007 
0008 // ----------------------------------------------------------------------
0009 // prolog
0010 
0011 // ----------------------------------------------------------------------
0012 // prerequisite source files and headers
0013 
0014 #include "DataFormats/Provenance/interface/ParameterSetID.h"
0015 #include "FWCore/ParameterSet/interface/Entry.h"
0016 #include "FWCore/Utilities/interface/FileInPath.h"
0017 #include "FWCore/ParameterSet/interface/ParameterSetEntry.h"
0018 #include "FWCore/ParameterSet/interface/VParameterSetEntry.h"
0019 
0020 #include <iosfwd>
0021 #include <map>
0022 #include <memory>
0023 #include <string>
0024 #include <vector>
0025 #include <array>
0026 
0027 // ----------------------------------------------------------------------
0028 // contents
0029 namespace cms {
0030   class Digest;
0031 }
0032 
0033 namespace edm {
0034   class ModuleDescription;
0035   typedef std::vector<ParameterSet> VParameterSet;
0036 
0037   template <typename T>
0038   struct ParameterTypeTraits {
0039     //When specializing the template, include the following in the struct:
0040     //
0041     // using GetType = <underlying parameter type to get from the ParameterSet>;
0042     //
0043     // //Function to convert the parameter type into the requested type
0044     // static T convert(GetType, std::string const&);
0045   };
0046 
0047   class ParameterSet {
0048   public:
0049     template <typename T>
0050     friend class ParameterDescription;
0051 
0052     // default-construct
0053     ParameterSet();
0054 
0055     // construct from coded string.
0056     explicit ParameterSet(std::string const& rep);
0057 
0058     ~ParameterSet() = default;
0059     ParameterSet(ParameterSet const& other) = default;
0060     ParameterSet(ParameterSet&& other) = default;
0061     ParameterSet& operator=(ParameterSet const& other) = default;
0062     ParameterSet& operator=(ParameterSet&& other) = default;
0063 
0064     void swap(ParameterSet& other);
0065 
0066     void copyForModify(ParameterSet const& other);
0067 
0068     // identification
0069     ParameterSetID id() const;
0070     void setID(ParameterSetID const& id);
0071     bool isRegistered() const { return id_.isValid(); }
0072     ParameterSetID trackedID() const { return id(); }  // to be phased out.
0073 
0074     // Entry-handling
0075     Entry const& retrieve(char const*) const;
0076     Entry const& retrieve(std::string const&) const;
0077     Entry const* retrieveUntracked(char const*) const;
0078     Entry const* retrieveUntracked(std::string const&) const;
0079     Entry const* retrieveUnknown(char const*) const;
0080     Entry const* retrieveUnknown(std::string const&) const;
0081     ParameterSetEntry const& retrieveParameterSet(std::string const&) const;
0082     ParameterSetEntry const* retrieveUntrackedParameterSet(std::string const&) const;
0083     ParameterSetEntry const* retrieveUnknownParameterSet(std::string const&) const;
0084     VParameterSetEntry const& retrieveVParameterSet(std::string const&) const;
0085     VParameterSetEntry const* retrieveUntrackedVParameterSet(std::string const&) const;
0086     VParameterSetEntry const* retrieveUnknownVParameterSet(std::string const&) const;
0087 
0088     void insertParameterSet(bool okay_to_replace, std::string const& name, ParameterSetEntry const& entry);
0089     void insertVParameterSet(bool okay_to_replace, std::string const& name, VParameterSetEntry const& entry);
0090     void insert(bool ok_to_replace, char const*, Entry const&);
0091     void insert(bool ok_to_replace, std::string const&, Entry const&);
0092     void augment(ParameterSet const& from);
0093     void copyFrom(ParameterSet const& from, std::string const& name);
0094     std::string getParameterAsString(std::string const& name) const;
0095 
0096     // encode only tracked parameters
0097     std::string toString() const;
0098     void toString(std::string& result) const;
0099     void toDigest(cms::Digest& digest) const;
0100 
0101     //encode tracked and untracked parameters
0102     void allToString(std::string& result) const;
0103 
0104     template <typename T>
0105     T getParameter(std::string const&) const;
0106 
0107     template <typename T>
0108     T getParameter(char const*) const;
0109 
0110     ParameterSet const& getParameterSet(std::string const&) const;
0111 
0112     ParameterSet const& getParameterSet(char const*) const;
0113 
0114     ParameterSet getUntrackedParameterSet(std::string const& name, ParameterSet const& defaultValue) const;
0115 
0116     ParameterSet getUntrackedParameterSet(char const* name, ParameterSet const& defaultValue) const;
0117 
0118     ParameterSet const& getUntrackedParameterSet(std::string const& name) const;
0119 
0120     ParameterSet const& getUntrackedParameterSet(char const* name) const;
0121 
0122     VParameterSet const& getParameterSetVector(std::string const& name) const;
0123 
0124     VParameterSet const& getParameterSetVector(char const* name) const;
0125 
0126     VParameterSet getUntrackedParameterSetVector(std::string const& name, VParameterSet const& defaultValue) const;
0127 
0128     VParameterSet getUntrackedParameterSetVector(char const* name, VParameterSet const& defaultValue) const;
0129 
0130     VParameterSet const& getUntrackedParameterSetVector(std::string const& name) const;
0131 
0132     VParameterSet const& getUntrackedParameterSetVector(char const* name) const;
0133 
0134     template <typename T>
0135     void addParameter(std::string const& name, T const& value) {
0136       invalidateRegistration(name);
0137       insert(true, name, Entry(name, value, true));
0138     }
0139 
0140     template <typename T>
0141     void addParameter(char const* name, T const& value) {
0142       invalidateRegistration(name);
0143       insert(true, name, Entry(name, value, true));
0144     }
0145 
0146     template <typename T>
0147     T getUntrackedParameter(std::string const&, T const&) const;
0148 
0149     template <typename T>
0150     T getUntrackedParameter(char const*, T const&) const;
0151 
0152     template <typename T>
0153     T getUntrackedParameter(std::string const&) const;
0154 
0155     template <typename T>
0156     T getUntrackedParameter(char const*) const;
0157 
0158     /// The returned value is the number of new FileInPath objects
0159     /// pushed into the vector.
0160     /// N.B.: The vector 'output' is *not* cleared; new entries are
0161     /// added with push_back.
0162     std::vector<FileInPath>::size_type getAllFileInPaths(std::vector<FileInPath>& output) const;
0163 
0164     std::vector<std::string> getParameterNames() const;
0165 
0166     /// checks if a parameter exists
0167     bool exists(std::string const& parameterName) const;
0168 
0169     /// checks if a parameter exists as a given type
0170     template <typename T>
0171     bool existsAs(std::string const& parameterName, bool trackiness = true) const {
0172       std::vector<std::string> names = getParameterNamesForType<T>(trackiness);
0173       return std::find(names.begin(), names.end(), parameterName) != names.end();
0174     }
0175 
0176     void deprecatedInputTagWarning(std::string const& name, std::string const& label) const;
0177 
0178     template <typename T>
0179     std::vector<std::string> getParameterNamesForType(bool trackiness = true) const {
0180       std::vector<std::string> result;
0181       // This is icky, but I don't know of another way in the current
0182       // code to get at the character code that denotes type T.
0183       T value = T();
0184       Entry type_translator("", value, trackiness);
0185       char type_code = type_translator.typeCode();
0186 
0187       (void)getNamesByCode_(type_code, trackiness, result);
0188       return result;
0189     }
0190 
0191     template <typename T>
0192     void addUntrackedParameter(std::string const& name, T const& value) {
0193       insert(true, name, Entry(name, value, false));
0194     }
0195 
0196     template <typename T>
0197     void addUntrackedParameter(char const* name, T const& value) {
0198       insert(true, name, Entry(name, value, false));
0199     }
0200 
0201     bool empty() const { return tbl_.empty() && psetTable_.empty() && vpsetTable_.empty(); }
0202 
0203     ParameterSet trackedPart() const;
0204 
0205     // Return the names of all parameters of type ParameterSet,
0206     // pushing the names into the argument 'output'. Return the number
0207     // of names pushed into the vector. If 'trackiness' is true, we
0208     // return tracked parameters; if 'trackiness' is false, w return
0209     // untracked parameters.
0210     size_t getParameterSetNames(std::vector<std::string>& output, bool trackiness = true) const;
0211 
0212     // Return the names of all parameters of type
0213     // vector<ParameterSet>, pushing the names into the argument
0214     // 'output'. Return the number of names pushed into the vector. If
0215     // 'trackiness' is true, we return tracked parameters; if
0216     // 'trackiness' is false, w return untracked parameters.
0217     size_t getParameterSetVectorNames(std::vector<std::string>& output, bool trackiness = true) const;
0218 
0219     // need a simple interface for python
0220     std::string dump(unsigned int indent = 0) const;
0221 
0222     friend std::ostream& operator<<(std::ostream& os, ParameterSet const& pset);
0223 
0224     ParameterSet const& registerIt();
0225 
0226     std::unique_ptr<ParameterSet> popParameterSet(std::string const& name);
0227     void eraseSimpleParameter(std::string const& name);
0228     void eraseOrSetUntrackedParameterSet(std::string const& name);
0229 
0230     std::vector<ParameterSet> popVParameterSet(std::string const& name);
0231 
0232     typedef std::map<std::string, Entry> table;
0233     table const& tbl() const { return tbl_; }
0234 
0235     typedef std::map<std::string, ParameterSetEntry> psettable;
0236     psettable const& psetTable() const { return psetTable_; }
0237 
0238     typedef std::map<std::string, VParameterSetEntry> vpsettable;
0239     vpsettable const& vpsetTable() const { return vpsetTable_; }
0240 
0241     ParameterSet* getPSetForUpdate(std::string const& name, bool& isTracked);
0242 
0243     ParameterSet* getPSetForUpdate(std::string const& name) {
0244       bool isTracked = false;
0245       return getPSetForUpdate(name, isTracked);
0246     }
0247 
0248     VParameterSetEntry* getPSetVectorForUpdate(std::string const& name);
0249 
0250     // construct from coded string and register it.
0251     static void registerFromString(std::string const& rep);
0252 
0253     // return ID of empty parameter set without registering it.
0254     static ParameterSetID emptyParameterSetID();
0255 
0256   private:
0257     // construct from coded string and id.
0258     ParameterSet(std::string const& rep, ParameterSetID const& id);
0259 
0260     // decode
0261     bool fromString(std::string const&);
0262 
0263     void toStringImp(std::string&, bool useAll) const;
0264 
0265     table tbl_;
0266     psettable psetTable_;
0267     vpsettable vpsetTable_;
0268 
0269     // If the id_ is invalid, that means a new value should be
0270     // calculated before the value is returned. Upon registration, the
0271     // id_ is made valid. Updating any tracked parameter invalidates the id_.
0272     ParameterSetID id_;
0273 
0274     void invalidateRegistration(std::string const& nameOfTracked);
0275 
0276     void calculateID();
0277 
0278     // get the untracked Entry object, throwing an exception if it is
0279     // not found.
0280     Entry const* getEntryPointerOrThrow_(std::string const& name) const;
0281     Entry const* getEntryPointerOrThrow_(char const* name) const;
0282 
0283     // Return the names of all the entries with the given typecode and
0284     // given status (trackiness)
0285     size_t getNamesByCode_(char code, bool trackiness, std::vector<std::string>& output) const;
0286 
0287   };  // ParameterSet
0288 
0289   inline void swap(ParameterSet& a, ParameterSet& b) { a.swap(b); }
0290 
0291   bool operator==(ParameterSet const& a, ParameterSet const& b);
0292 
0293   bool isTransientEqual(ParameterSet const& a, ParameterSet const& b);
0294 
0295   inline bool operator!=(ParameterSet const& a, ParameterSet const& b) { return !(a == b); }
0296 
0297   // Free function to retrieve a parameter set, given the parameter set ID.
0298   ParameterSet const& getParameterSet(ParameterSetID const& id);
0299 
0300   ParameterSet const& getProcessParameterSetContainingModule(ModuleDescription const& moduleDescription);
0301 
0302   template <typename T>
0303   inline T ParameterSet::getParameter(std::string const& name) const {
0304     using GetType = typename ParameterTypeTraits<T>::GetType;
0305     return ParameterTypeTraits<T>::convert(getParameter<GetType>(name), name);
0306   }
0307 
0308   template <typename T>
0309   inline T ParameterSet::getParameter(const char* name) const {
0310     using GetType = typename ParameterTypeTraits<T>::GetType;
0311     return ParameterTypeTraits<T>::convert(getParameter<GetType>(name), name);
0312   }
0313   // specializations
0314   // ----------------------------------------------------------------------
0315   namespace pset::exceptions {
0316     void throwWrongNumberOfElements(std::string const& iParameterName, size_t iExpected, size_t iGot);
0317   }
0318   //Read an std::array from an std::vector
0319   template <typename T, std::size_t N>
0320   struct ParameterTypeTraits<std::array<T, N>> {
0321     using GetType = std::vector<T>;
0322     static std::array<T, N> convert(std::vector<T> iVec, std::string const& iName) {
0323       if (iVec.size() != N) {
0324         pset::exceptions::throwWrongNumberOfElements(iName, N, iVec.size());
0325       }
0326       std::array<T, N> a;
0327       std::copy_n(std::make_move_iterator(iVec.begin()), N, a.begin());
0328       return a;
0329     }
0330   };
0331   // read an std::vector<std::pair<std::string, T>> from std::vector<PSet>
0332   template <typename T>
0333   struct ParameterTypeTraits<std::vector<std::pair<std::string, T>>> {
0334     using GetType = std::vector<edm::ParameterSet>;
0335     static auto convert(std::vector<edm::ParameterSet> vpset, std::string const& iName) {
0336       std::vector<std::pair<std::string, T>> ret(vpset.size());
0337       std::transform(vpset.begin(), vpset.end(), ret.begin(), [](edm::ParameterSet const& pset) {
0338         return std::pair(pset.getParameter<std::string>("key"), pset.getParameter<T>("value"));
0339       });
0340       return ret;
0341     }
0342   };
0343   // ----------------------------------------------------------------------
0344 
0345   template <>
0346   bool ParameterSet::getParameter<bool>(std::string const& name) const;
0347 
0348   // ----------------------------------------------------------------------
0349   // Int32, vInt32
0350 
0351   template <>
0352   int ParameterSet::getParameter<int>(std::string const& name) const;
0353 
0354   template <>
0355   std::vector<int> ParameterSet::getParameter<std::vector<int>>(std::string const& name) const;
0356 
0357   // ----------------------------------------------------------------------
0358   // Int64, vInt64
0359 
0360   template <>
0361   long long ParameterSet::getParameter<long long>(std::string const& name) const;
0362 
0363   template <>
0364   std::vector<long long> ParameterSet::getParameter<std::vector<long long>>(std::string const& name) const;
0365 
0366   // ----------------------------------------------------------------------
0367   // Uint32, vUint32
0368 
0369   template <>
0370   unsigned int ParameterSet::getParameter<unsigned int>(std::string const& name) const;
0371 
0372   template <>
0373   std::vector<unsigned int> ParameterSet::getParameter<std::vector<unsigned int>>(std::string const& name) const;
0374 
0375   // ----------------------------------------------------------------------
0376   // Uint64, vUint64
0377 
0378   template <>
0379   unsigned long long ParameterSet::getParameter<unsigned long long>(std::string const& name) const;
0380 
0381   template <>
0382   std::vector<unsigned long long> ParameterSet::getParameter<std::vector<unsigned long long>>(
0383       std::string const& name) const;
0384 
0385   // ----------------------------------------------------------------------
0386   // Double, vDouble
0387 
0388   template <>
0389   double ParameterSet::getParameter<double>(std::string const& name) const;
0390 
0391   template <>
0392   std::vector<double> ParameterSet::getParameter<std::vector<double>>(std::string const& name) const;
0393 
0394   // ----------------------------------------------------------------------
0395   // String, vString
0396 
0397   template <>
0398   std::string ParameterSet::getParameter<std::string>(std::string const& name) const;
0399 
0400   template <>
0401   std::vector<std::string> ParameterSet::getParameter<std::vector<std::string>>(std::string const& name) const;
0402 
0403   // ----------------------------------------------------------------------
0404   // FileInPath
0405 
0406   template <>
0407   FileInPath ParameterSet::getParameter<FileInPath>(std::string const& name) const;
0408 
0409   // FileInPath can't default-construct something useful, so we specialize
0410   // this template
0411   template <>
0412   std::vector<std::string> ParameterSet::getParameterNamesForType<FileInPath>(bool trackiness) const;
0413 
0414   // ----------------------------------------------------------------------
0415   // InputTag
0416 
0417   template <>
0418   InputTag ParameterSet::getParameter<InputTag>(std::string const& name) const;
0419 
0420   // ----------------------------------------------------------------------
0421   // VInputTag
0422 
0423   template <>
0424   std::vector<InputTag> ParameterSet::getParameter<std::vector<InputTag>>(std::string const& name) const;
0425 
0426   // ----------------------------------------------------------------------
0427   // ESInputTag
0428 
0429   template <>
0430   ESInputTag ParameterSet::getParameter<ESInputTag>(std::string const& name) const;
0431 
0432   // ----------------------------------------------------------------------
0433   // VESInputTag
0434 
0435   template <>
0436   std::vector<ESInputTag> ParameterSet::getParameter<std::vector<ESInputTag>>(std::string const& name) const;
0437 
0438   // ----------------------------------------------------------------------
0439   // EventID
0440 
0441   template <>
0442   EventID ParameterSet::getParameter<EventID>(std::string const& name) const;
0443 
0444   // ----------------------------------------------------------------------
0445   // VEventID
0446 
0447   template <>
0448   std::vector<EventID> ParameterSet::getParameter<std::vector<EventID>>(std::string const& name) const;
0449 
0450   // ----------------------------------------------------------------------
0451   // LuminosityBlockID
0452 
0453   template <>
0454   LuminosityBlockID ParameterSet::getParameter<LuminosityBlockID>(std::string const& name) const;
0455 
0456   // ----------------------------------------------------------------------
0457   // VLuminosityBlockID
0458 
0459   template <>
0460   std::vector<LuminosityBlockID> ParameterSet::getParameter<std::vector<LuminosityBlockID>>(
0461       std::string const& name) const;
0462 
0463   // ----------------------------------------------------------------------
0464   // EventRange
0465 
0466   template <>
0467   EventRange ParameterSet::getParameter<EventRange>(std::string const& name) const;
0468 
0469   // ----------------------------------------------------------------------
0470   // VEventRange
0471 
0472   template <>
0473   std::vector<EventRange> ParameterSet::getParameter<std::vector<EventRange>>(std::string const& name) const;
0474 
0475   // ----------------------------------------------------------------------
0476   // LuminosityBlockRange
0477 
0478   template <>
0479   LuminosityBlockRange ParameterSet::getParameter<LuminosityBlockRange>(std::string const& name) const;
0480 
0481   // ----------------------------------------------------------------------
0482   // VLuminosityBlockRange
0483 
0484   template <>
0485   std::vector<LuminosityBlockRange> ParameterSet::getParameter<std::vector<LuminosityBlockRange>>(
0486       std::string const& name) const;
0487 
0488   // ----------------------------------------------------------------------
0489   // PSet, vPSet
0490 
0491   template <>
0492   ParameterSet ParameterSet::getParameter<ParameterSet>(std::string const& name) const;
0493 
0494   template <>
0495   VParameterSet ParameterSet::getParameter<VParameterSet>(std::string const& name) const;
0496 
0497   template <>
0498   void ParameterSet::addParameter<ParameterSet>(std::string const& name, ParameterSet const& value);
0499 
0500   template <>
0501   void ParameterSet::addParameter<ParameterSet>(char const* name, ParameterSet const& value);
0502 
0503   template <>
0504   void ParameterSet::addUntrackedParameter<ParameterSet>(std::string const& name, ParameterSet const& value);
0505 
0506   template <>
0507   void ParameterSet::addUntrackedParameter<ParameterSet>(char const* name, ParameterSet const& value);
0508 
0509   template <>
0510   void ParameterSet::addParameter<VParameterSet>(std::string const& name, VParameterSet const& value);
0511 
0512   template <>
0513   void ParameterSet::addParameter<VParameterSet>(char const* name, VParameterSet const& value);
0514 
0515   template <>
0516   void ParameterSet::addUntrackedParameter<VParameterSet>(std::string const& name, VParameterSet const& value);
0517 
0518   template <>
0519   void ParameterSet::addUntrackedParameter<VParameterSet>(char const* name, VParameterSet const& value);
0520 
0521   // untracked parameters
0522 
0523   // ----------------------------------------------------------------------
0524   // Bool, vBool
0525 
0526   template <>
0527   bool ParameterSet::getUntrackedParameter<bool>(std::string const& name, bool const& defaultValue) const;
0528 
0529   template <>
0530   bool ParameterSet::getUntrackedParameter<bool>(std::string const& name) const;
0531 
0532   // ----------------------------------------------------------------------
0533   // Int32, vInt32
0534 
0535   template <>
0536   int ParameterSet::getUntrackedParameter<int>(std::string const& name, int const& defaultValue) const;
0537 
0538   template <>
0539   int ParameterSet::getUntrackedParameter<int>(std::string const& name) const;
0540 
0541   template <>
0542   std::vector<int> ParameterSet::getUntrackedParameter<std::vector<int>>(std::string const& name,
0543                                                                          std::vector<int> const& defaultValue) const;
0544 
0545   template <>
0546   std::vector<int> ParameterSet::getUntrackedParameter<std::vector<int>>(std::string const& name) const;
0547 
0548   // ----------------------------------------------------------------------
0549   // Uint32, vUint32
0550 
0551   template <>
0552   unsigned int ParameterSet::getUntrackedParameter<unsigned int>(std::string const& name,
0553                                                                  unsigned int const& defaultValue) const;
0554 
0555   template <>
0556   unsigned int ParameterSet::getUntrackedParameter<unsigned int>(std::string const& name) const;
0557 
0558   template <>
0559   std::vector<unsigned int> ParameterSet::getUntrackedParameter<std::vector<unsigned int>>(
0560       std::string const& name, std::vector<unsigned int> const& defaultValue) const;
0561 
0562   template <>
0563   std::vector<unsigned int> ParameterSet::getUntrackedParameter<std::vector<unsigned int>>(
0564       std::string const& name) const;
0565 
0566   // ----------------------------------------------------------------------
0567   // Uint64, vUint64
0568 
0569   template <>
0570   unsigned long long ParameterSet::getUntrackedParameter<unsigned long long>(
0571       std::string const& name, unsigned long long const& defaultValue) const;
0572 
0573   template <>
0574   unsigned long long ParameterSet::getUntrackedParameter<unsigned long long>(std::string const& name) const;
0575 
0576   template <>
0577   std::vector<unsigned long long> ParameterSet::getUntrackedParameter<std::vector<unsigned long long>>(
0578       std::string const& name, std::vector<unsigned long long> const& defaultValue) const;
0579 
0580   template <>
0581   std::vector<unsigned long long> ParameterSet::getUntrackedParameter<std::vector<unsigned long long>>(
0582       std::string const& name) const;
0583 
0584   // ----------------------------------------------------------------------
0585   // Int64, Vint64
0586 
0587   template <>
0588   long long ParameterSet::getUntrackedParameter<long long>(std::string const& name,
0589                                                            long long const& defaultValue) const;
0590 
0591   template <>
0592   long long ParameterSet::getUntrackedParameter<long long>(std::string const& name) const;
0593 
0594   template <>
0595   std::vector<long long> ParameterSet::getUntrackedParameter<std::vector<long long>>(
0596       std::string const& name, std::vector<long long> const& defaultValue) const;
0597 
0598   template <>
0599   std::vector<long long> ParameterSet::getUntrackedParameter<std::vector<long long>>(std::string const& name) const;
0600 
0601   // ----------------------------------------------------------------------
0602   // Double, vDouble
0603 
0604   template <>
0605   double ParameterSet::getUntrackedParameter<double>(std::string const& name, double const& defaultValue) const;
0606 
0607   template <>
0608   double ParameterSet::getUntrackedParameter<double>(std::string const& name) const;
0609 
0610   template <>
0611   std::vector<double> ParameterSet::getUntrackedParameter<std::vector<double>>(
0612       std::string const& name, std::vector<double> const& defaultValue) const;
0613 
0614   template <>
0615   std::vector<double> ParameterSet::getUntrackedParameter<std::vector<double>>(std::string const& name) const;
0616 
0617   // ----------------------------------------------------------------------
0618   // String, vString
0619 
0620   template <>
0621   std::string ParameterSet::getUntrackedParameter<std::string>(std::string const& name,
0622                                                                std::string const& defaultValue) const;
0623 
0624   template <>
0625   std::string ParameterSet::getUntrackedParameter<std::string>(std::string const& name) const;
0626 
0627   template <>
0628   std::vector<std::string> ParameterSet::getUntrackedParameter<std::vector<std::string>>(
0629       std::string const& name, std::vector<std::string> const& defaultValue) const;
0630 
0631   template <>
0632   std::vector<std::string> ParameterSet::getUntrackedParameter<std::vector<std::string>>(std::string const& name) const;
0633 
0634   // ----------------------------------------------------------------------
0635   //  FileInPath
0636 
0637   template <>
0638   FileInPath ParameterSet::getUntrackedParameter<FileInPath>(std::string const& name,
0639                                                              FileInPath const& defaultValue) const;
0640 
0641   template <>
0642   FileInPath ParameterSet::getUntrackedParameter<FileInPath>(std::string const& name) const;
0643 
0644   // ----------------------------------------------------------------------
0645   // InputTag, VInputTag
0646 
0647   template <>
0648   InputTag ParameterSet::getUntrackedParameter<InputTag>(std::string const& name, InputTag const& defaultValue) const;
0649 
0650   template <>
0651   InputTag ParameterSet::getUntrackedParameter<InputTag>(std::string const& name) const;
0652 
0653   template <>
0654   std::vector<InputTag> ParameterSet::getUntrackedParameter<std::vector<InputTag>>(
0655       std::string const& name, std::vector<InputTag> const& defaultValue) const;
0656 
0657   template <>
0658   std::vector<InputTag> ParameterSet::getUntrackedParameter<std::vector<InputTag>>(std::string const& name) const;
0659 
0660   // ----------------------------------------------------------------------
0661   // EventID, VEventID
0662 
0663   template <>
0664   EventID ParameterSet::getUntrackedParameter<EventID>(std::string const& name, EventID const& defaultValue) const;
0665 
0666   template <>
0667   EventID ParameterSet::getUntrackedParameter<EventID>(std::string const& name) const;
0668 
0669   template <>
0670   std::vector<EventID> ParameterSet::getUntrackedParameter<std::vector<EventID>>(
0671       std::string const& name, std::vector<EventID> const& defaultValue) const;
0672   template <>
0673   std::vector<EventID> ParameterSet::getUntrackedParameter<std::vector<EventID>>(std::string const& name) const;
0674 
0675   // ----------------------------------------------------------------------
0676   // LuminosityBlockID, VLuminosityBlockID
0677 
0678   template <>
0679   LuminosityBlockID ParameterSet::getUntrackedParameter<LuminosityBlockID>(std::string const& name,
0680                                                                            LuminosityBlockID const& defaultValue) const;
0681 
0682   template <>
0683   LuminosityBlockID ParameterSet::getUntrackedParameter<LuminosityBlockID>(std::string const& name) const;
0684 
0685   template <>
0686   std::vector<LuminosityBlockID> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockID>>(
0687       std::string const& name, std::vector<LuminosityBlockID> const& defaultValue) const;
0688   template <>
0689   std::vector<LuminosityBlockID> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockID>>(
0690       std::string const& name) const;
0691 
0692   // ----------------------------------------------------------------------
0693   // EventRange, VEventRange
0694 
0695   template <>
0696   EventRange ParameterSet::getUntrackedParameter<EventRange>(std::string const& name,
0697                                                              EventRange const& defaultValue) const;
0698 
0699   template <>
0700   EventRange ParameterSet::getUntrackedParameter<EventRange>(std::string const& name) const;
0701 
0702   template <>
0703   std::vector<EventRange> ParameterSet::getUntrackedParameter<std::vector<EventRange>>(
0704       std::string const& name, std::vector<EventRange> const& defaultValue) const;
0705   template <>
0706   std::vector<EventRange> ParameterSet::getUntrackedParameter<std::vector<EventRange>>(std::string const& name) const;
0707 
0708   // ----------------------------------------------------------------------
0709   // LuminosityBlockRange, VLuminosityBlockRange
0710 
0711   template <>
0712   LuminosityBlockRange ParameterSet::getUntrackedParameter<LuminosityBlockRange>(
0713       std::string const& name, LuminosityBlockRange const& defaultValue) const;
0714 
0715   template <>
0716   LuminosityBlockRange ParameterSet::getUntrackedParameter<LuminosityBlockRange>(std::string const& name) const;
0717 
0718   template <>
0719   std::vector<LuminosityBlockRange> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockRange>>(
0720       std::string const& name, std::vector<LuminosityBlockRange> const& defaultValue) const;
0721   template <>
0722   std::vector<LuminosityBlockRange> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockRange>>(
0723       std::string const& name) const;
0724 
0725   // specializations
0726   // ----------------------------------------------------------------------
0727   // Bool, vBool
0728 
0729   template <>
0730   bool ParameterSet::getParameter<bool>(char const* name) const;
0731 
0732   // ----------------------------------------------------------------------
0733   // Int32, vInt32
0734 
0735   template <>
0736   int ParameterSet::getParameter<int>(char const* name) const;
0737 
0738   template <>
0739   std::vector<int> ParameterSet::getParameter<std::vector<int>>(char const* name) const;
0740 
0741   // ----------------------------------------------------------------------
0742   // Int64, vInt64
0743 
0744   template <>
0745   long long ParameterSet::getParameter<long long>(char const* name) const;
0746 
0747   template <>
0748   std::vector<long long> ParameterSet::getParameter<std::vector<long long>>(char const* name) const;
0749 
0750   // ----------------------------------------------------------------------
0751   // Uint32, vUint32
0752 
0753   template <>
0754   unsigned int ParameterSet::getParameter<unsigned int>(char const* name) const;
0755 
0756   template <>
0757   std::vector<unsigned int> ParameterSet::getParameter<std::vector<unsigned int>>(char const* name) const;
0758 
0759   // ----------------------------------------------------------------------
0760   // Uint64, vUint64
0761 
0762   template <>
0763   unsigned long long ParameterSet::getParameter<unsigned long long>(char const* name) const;
0764 
0765   template <>
0766   std::vector<unsigned long long> ParameterSet::getParameter<std::vector<unsigned long long>>(char const* name) const;
0767 
0768   // ----------------------------------------------------------------------
0769   // Double, vDouble
0770 
0771   template <>
0772   double ParameterSet::getParameter<double>(char const* name) const;
0773 
0774   template <>
0775   std::vector<double> ParameterSet::getParameter<std::vector<double>>(char const* name) const;
0776 
0777   // ----------------------------------------------------------------------
0778   // String, vString
0779 
0780   template <>
0781   std::string ParameterSet::getParameter<std::string>(char const* name) const;
0782 
0783   template <>
0784   std::vector<std::string> ParameterSet::getParameter<std::vector<std::string>>(char const* name) const;
0785 
0786   // ----------------------------------------------------------------------
0787   // FileInPath
0788 
0789   template <>
0790   FileInPath ParameterSet::getParameter<FileInPath>(char const* name) const;
0791 
0792   // ----------------------------------------------------------------------
0793   // InputTag
0794 
0795   template <>
0796   InputTag ParameterSet::getParameter<InputTag>(char const* name) const;
0797 
0798   // ----------------------------------------------------------------------
0799   // VInputTag
0800 
0801   template <>
0802   std::vector<InputTag> ParameterSet::getParameter<std::vector<InputTag>>(char const* name) const;
0803 
0804   // ----------------------------------------------------------------------
0805   // ESInputTag
0806 
0807   template <>
0808   ESInputTag ParameterSet::getParameter<ESInputTag>(char const* name) const;
0809 
0810   // ----------------------------------------------------------------------
0811   // VESInputTag
0812 
0813   template <>
0814   std::vector<ESInputTag> ParameterSet::getParameter<std::vector<ESInputTag>>(char const* name) const;
0815 
0816   // ----------------------------------------------------------------------
0817   // EventID
0818 
0819   template <>
0820   EventID ParameterSet::getParameter<EventID>(char const* name) const;
0821 
0822   // ----------------------------------------------------------------------
0823   // VEventID
0824 
0825   template <>
0826   std::vector<EventID> ParameterSet::getParameter<std::vector<EventID>>(char const* name) const;
0827 
0828   // ----------------------------------------------------------------------
0829   // LuminosityBlockID
0830 
0831   template <>
0832   LuminosityBlockID ParameterSet::getParameter<LuminosityBlockID>(char const* name) const;
0833 
0834   // ----------------------------------------------------------------------
0835   // VLuminosityBlockID
0836 
0837   template <>
0838   std::vector<LuminosityBlockID> ParameterSet::getParameter<std::vector<LuminosityBlockID>>(char const* name) const;
0839 
0840   // ----------------------------------------------------------------------
0841   // EventRange
0842 
0843   template <>
0844   EventRange ParameterSet::getParameter<EventRange>(char const* name) const;
0845 
0846   // ----------------------------------------------------------------------
0847   // VEventRange
0848 
0849   template <>
0850   std::vector<EventRange> ParameterSet::getParameter<std::vector<EventRange>>(char const* name) const;
0851 
0852   // ----------------------------------------------------------------------
0853   // LuminosityBlockRange
0854 
0855   template <>
0856   LuminosityBlockRange ParameterSet::getParameter<LuminosityBlockRange>(char const* name) const;
0857 
0858   // ----------------------------------------------------------------------
0859   // VLuminosityBlockRange
0860 
0861   template <>
0862   std::vector<LuminosityBlockRange> ParameterSet::getParameter<std::vector<LuminosityBlockRange>>(
0863       char const* name) const;
0864 
0865   // ----------------------------------------------------------------------
0866   // PSet, vPSet
0867 
0868   template <>
0869   ParameterSet ParameterSet::getParameter<ParameterSet>(char const* name) const;
0870 
0871   template <>
0872   VParameterSet ParameterSet::getParameter<VParameterSet>(char const* name) const;
0873 
0874   // untracked parameters
0875 
0876   // ----------------------------------------------------------------------
0877   // Bool, vBool
0878 
0879   template <>
0880   bool ParameterSet::getUntrackedParameter<bool>(char const* name, bool const& defaultValue) const;
0881 
0882   template <>
0883   bool ParameterSet::getUntrackedParameter<bool>(char const* name) const;
0884 
0885   // ----------------------------------------------------------------------
0886   // Int32, vInt32
0887 
0888   template <>
0889   int ParameterSet::getUntrackedParameter<int>(char const* name, int const& defaultValue) const;
0890 
0891   template <>
0892   int ParameterSet::getUntrackedParameter<int>(char const* name) const;
0893 
0894   template <>
0895   std::vector<int> ParameterSet::getUntrackedParameter<std::vector<int>>(char const* name,
0896                                                                          std::vector<int> const& defaultValue) const;
0897 
0898   template <>
0899   std::vector<int> ParameterSet::getUntrackedParameter<std::vector<int>>(char const* name) const;
0900 
0901   // ----------------------------------------------------------------------
0902   // Uint32, vUint32
0903 
0904   template <>
0905   unsigned int ParameterSet::getUntrackedParameter<unsigned int>(char const* name,
0906                                                                  unsigned int const& defaultValue) const;
0907 
0908   template <>
0909   unsigned int ParameterSet::getUntrackedParameter<unsigned int>(char const* name) const;
0910 
0911   template <>
0912   std::vector<unsigned int> ParameterSet::getUntrackedParameter<std::vector<unsigned int>>(
0913       char const* name, std::vector<unsigned int> const& defaultValue) const;
0914 
0915   template <>
0916   std::vector<unsigned int> ParameterSet::getUntrackedParameter<std::vector<unsigned int>>(char const* name) const;
0917 
0918   // ----------------------------------------------------------------------
0919   // Uint64, vUint64
0920 
0921   template <>
0922   unsigned long long ParameterSet::getUntrackedParameter<unsigned long long>(
0923       char const* name, unsigned long long const& defaultValue) const;
0924 
0925   template <>
0926   unsigned long long ParameterSet::getUntrackedParameter<unsigned long long>(char const* name) const;
0927 
0928   template <>
0929   std::vector<unsigned long long> ParameterSet::getUntrackedParameter<std::vector<unsigned long long>>(
0930       char const* name, std::vector<unsigned long long> const& defaultValue) const;
0931 
0932   template <>
0933   std::vector<unsigned long long> ParameterSet::getUntrackedParameter<std::vector<unsigned long long>>(
0934       char const* name) const;
0935 
0936   // ----------------------------------------------------------------------
0937   // Int64, Vint64
0938 
0939   template <>
0940   long long ParameterSet::getUntrackedParameter<long long>(char const* name, long long const& defaultValue) const;
0941 
0942   template <>
0943   long long ParameterSet::getUntrackedParameter<long long>(char const* name) const;
0944 
0945   template <>
0946   std::vector<long long> ParameterSet::getUntrackedParameter<std::vector<long long>>(
0947       char const* name, std::vector<long long> const& defaultValue) const;
0948 
0949   template <>
0950   std::vector<long long> ParameterSet::getUntrackedParameter<std::vector<long long>>(char const* name) const;
0951 
0952   // ----------------------------------------------------------------------
0953   // Double, vDouble
0954 
0955   template <>
0956   double ParameterSet::getUntrackedParameter<double>(char const* name, double const& defaultValue) const;
0957 
0958   template <>
0959   double ParameterSet::getUntrackedParameter<double>(char const* name) const;
0960 
0961   template <>
0962   std::vector<double> ParameterSet::getUntrackedParameter<std::vector<double>>(
0963       char const* name, std::vector<double> const& defaultValue) const;
0964 
0965   template <>
0966   std::vector<double> ParameterSet::getUntrackedParameter<std::vector<double>>(char const* name) const;
0967 
0968   // ----------------------------------------------------------------------
0969   // String, vString
0970 
0971   template <>
0972   std::string ParameterSet::getUntrackedParameter<std::string>(char const* name, std::string const& defaultValue) const;
0973 
0974   template <>
0975   std::string ParameterSet::getUntrackedParameter<std::string>(char const* name) const;
0976 
0977   template <>
0978   std::vector<std::string> ParameterSet::getUntrackedParameter<std::vector<std::string>>(
0979       char const* name, std::vector<std::string> const& defaultValue) const;
0980 
0981   template <>
0982   std::vector<std::string> ParameterSet::getUntrackedParameter<std::vector<std::string>>(char const* name) const;
0983 
0984   // ----------------------------------------------------------------------
0985   //  FileInPath
0986 
0987   template <>
0988   FileInPath ParameterSet::getUntrackedParameter<FileInPath>(char const* name, FileInPath const& defaultValue) const;
0989 
0990   template <>
0991   FileInPath ParameterSet::getUntrackedParameter<FileInPath>(char const* name) const;
0992 
0993   // ----------------------------------------------------------------------
0994   // InputTag, VInputTag
0995 
0996   template <>
0997   InputTag ParameterSet::getUntrackedParameter<InputTag>(char const* name, InputTag const& defaultValue) const;
0998 
0999   template <>
1000   InputTag ParameterSet::getUntrackedParameter<InputTag>(char const* name) const;
1001 
1002   template <>
1003   std::vector<InputTag> ParameterSet::getUntrackedParameter<std::vector<InputTag>>(
1004       char const* name, std::vector<InputTag> const& defaultValue) const;
1005 
1006   template <>
1007   std::vector<InputTag> ParameterSet::getUntrackedParameter<std::vector<InputTag>>(char const* name) const;
1008 
1009   // ----------------------------------------------------------------------
1010   // EventID, VEventID
1011 
1012   template <>
1013   EventID ParameterSet::getUntrackedParameter<EventID>(char const* name, EventID const& defaultValue) const;
1014 
1015   template <>
1016   EventID ParameterSet::getUntrackedParameter<EventID>(char const* name) const;
1017 
1018   template <>
1019   std::vector<EventID> ParameterSet::getUntrackedParameter<std::vector<EventID>>(
1020       char const* name, std::vector<EventID> const& defaultValue) const;
1021   template <>
1022   std::vector<EventID> ParameterSet::getUntrackedParameter<std::vector<EventID>>(char const* name) const;
1023 
1024   // ----------------------------------------------------------------------
1025   // LuminosityBlockID, VLuminosityBlockID
1026 
1027   template <>
1028   LuminosityBlockID ParameterSet::getUntrackedParameter<LuminosityBlockID>(char const* name,
1029                                                                            LuminosityBlockID const& defaultValue) const;
1030 
1031   template <>
1032   LuminosityBlockID ParameterSet::getUntrackedParameter<LuminosityBlockID>(char const* name) const;
1033 
1034   template <>
1035   std::vector<LuminosityBlockID> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockID>>(
1036       char const* name, std::vector<LuminosityBlockID> const& defaultValue) const;
1037   template <>
1038   std::vector<LuminosityBlockID> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockID>>(
1039       char const* name) const;
1040 
1041   // ----------------------------------------------------------------------
1042   // EventRange, VEventRange
1043 
1044   template <>
1045   EventRange ParameterSet::getUntrackedParameter<EventRange>(char const* name, EventRange const& defaultValue) const;
1046 
1047   template <>
1048   EventRange ParameterSet::getUntrackedParameter<EventRange>(char const* name) const;
1049 
1050   template <>
1051   std::vector<EventRange> ParameterSet::getUntrackedParameter<std::vector<EventRange>>(
1052       char const* name, std::vector<EventRange> const& defaultValue) const;
1053   template <>
1054   std::vector<EventRange> ParameterSet::getUntrackedParameter<std::vector<EventRange>>(char const* name) const;
1055 
1056   // ----------------------------------------------------------------------
1057   // LuminosityBlockRange, VLuminosityBlockRange
1058 
1059   template <>
1060   LuminosityBlockRange ParameterSet::getUntrackedParameter<LuminosityBlockRange>(
1061       char const* name, LuminosityBlockRange const& defaultValue) const;
1062 
1063   template <>
1064   LuminosityBlockRange ParameterSet::getUntrackedParameter<LuminosityBlockRange>(char const* name) const;
1065 
1066   template <>
1067   std::vector<LuminosityBlockRange> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockRange>>(
1068       char const* name, std::vector<LuminosityBlockRange> const& defaultValue) const;
1069   template <>
1070   std::vector<LuminosityBlockRange> ParameterSet::getUntrackedParameter<std::vector<LuminosityBlockRange>>(
1071       char const* name) const;
1072 
1073   // ----------------------------------------------------------------------
1074   // PSet, vPSet
1075 
1076   template <>
1077   ParameterSet ParameterSet::getUntrackedParameter<ParameterSet>(char const* name,
1078                                                                  ParameterSet const& defaultValue) const;
1079 
1080   template <>
1081   ParameterSet ParameterSet::getUntrackedParameter<ParameterSet>(std::string const& name,
1082                                                                  ParameterSet const& defaultValue) const;
1083 
1084   template <>
1085   ParameterSet ParameterSet::getUntrackedParameter<ParameterSet>(char const* name) const;
1086 
1087   template <>
1088   ParameterSet ParameterSet::getUntrackedParameter<ParameterSet>(std::string const& name) const;
1089 
1090   template <>
1091   VParameterSet ParameterSet::getUntrackedParameter<VParameterSet>(char const* name,
1092                                                                    VParameterSet const& defaultValue) const;
1093 
1094   template <>
1095   VParameterSet ParameterSet::getUntrackedParameter<VParameterSet>(char const* name) const;
1096 
1097   template <>
1098   VParameterSet ParameterSet::getUntrackedParameter<VParameterSet>(std::string const& name,
1099                                                                    VParameterSet const& defaultValue) const;
1100 
1101   template <>
1102   VParameterSet ParameterSet::getUntrackedParameter<VParameterSet>(std::string const& name) const;
1103 
1104   template <>
1105   std::vector<std::string> ParameterSet::getParameterNamesForType<ParameterSet>(bool trackiness) const;
1106 
1107   template <>
1108   std::vector<std::string> ParameterSet::getParameterNamesForType<VParameterSet>(bool trackiness) const;
1109 }  // namespace edm
1110 #endif