ParameterSet/interface/ParameterSet.h

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