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 <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