ParameterSet.h

Go to the documentation of this file.

// ParameterSet.h: Implements a map of Key-Value pairs.
//
// Copyright (C) 2022 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef DP3_COMMON_PARAMETERSET_H_
#define DP3_COMMON_PARAMETERSET_H_
 
#include "blob/BlobIStream.h"
#include "blob/BlobOStream.h"
 
// Never #include <config.h> or #include <lofar_config.h> in a header file!
#include "ParameterSetImpl.h"
#include "KVpair.h"
 
namespace dp3 {
namespace common {
 
 
 
class ParameterSet {
 public:
  typedef ParameterSetImpl::iterator iterator;
  typedef ParameterSetImpl::const_iterator const_iterator;
 
 
  explicit ParameterSet(KeyCompare::Mode mode = KeyCompare::NORMAL);
 
  explicit ParameterSet(bool caseInsensitive);
 
  explicit ParameterSet(const std::string& theFilename,
                        KeyCompare::Mode = KeyCompare::NORMAL);
  explicit ParameterSet(const char* theFilename,
                        KeyCompare::Mode = KeyCompare::NORMAL);
 
  explicit ParameterSet(const std::string& theFilename, bool caseInsensitive);
 
  ParameterSet(const ParameterSet& that);
 
  ParameterSet& operator=(const ParameterSet& that);
 
  bool empty() const;
 
  int size() const;
 
 
  iterator begin();
  iterator end();
  const_iterator begin() const;
  const_iterator end() const;
 
  const ParameterValue& get(const std::string& aKey) const;
  const ParameterValue& operator[](const std::string& aKey) const;
 
  KeyCompare::Mode keyCompareMode() const;
 
  void clear();
 
 
  void adoptFile(const std::string& theFilename,
                 const std::string& thePrefix = "");
 
  void adoptBuffer(const std::string& theBuffer,
                   const std::string& thePrefix = "");
 
  void adoptCollection(const ParameterSet& theCollection,
                       const std::string& thePrefix = "");
 
  void adoptArguments(const std::vector<std::string>& arguments);
 
 
  void writeFile(const std::string& theFilename, bool append = false) const;
 
  void writeBuffer(std::string& theBuffer) const;
 
  void writeStream(std::ostream& os) const;
 
 
  ParameterSet makeSubset(const std::string& baseKey,
                          const std::string& prefix = "") const;
 
  void subtractSubset(const std::string& fullPrefix);
 
 
  void add(const std::string& aKey, const std::string& aValue);
  void add(const KVpair& aPair);
 
  void replace(const std::string& aKey, const std::string& aValue);
  void replace(const KVpair& aPair);
 
  void remove(const std::string& aKey);
 
 
  iterator find(const std::string& searchKey);
  const_iterator find(const std::string& searchKey) const;
 
  bool isDefined(const std::string& searchKey) const;
 
  std::string locateModule(const std::string& shortName) const;
 
  std::string fullModuleName(const std::string& shortName) const;
 
  std::vector<ParameterValue> getVector(const std::string& aKey) const;
 
  ParameterRecord getRecord(const std::string& aKey) const;
 
  bool getBool(const std::string& aKey) const;
  bool getBool(const std::string& aKey, bool aValue) const;
  int getInt(const std::string& aKey) const;
  int getInt(const std::string& aKey, int aValue) const;
  unsigned int getUint(const std::string& aKey) const;
  unsigned int getUint(const std::string& aKey, unsigned int aValue) const;
  int16_t getInt16(const std::string& aKey) const;
  int16_t getInt16(const std::string& aKey, int16_t aValue) const;
  uint16_t getUint16(const std::string& aKey) const;
  uint16_t getUint16(const std::string& aKey, uint16_t aValue) const;
  int32_t getInt32(const std::string& aKey) const;
  int32_t getInt32(const std::string& aKey, int32_t aValue) const;
  uint32_t getUint32(const std::string& aKey) const;
  uint32_t getUint32(const std::string& aKey, uint32_t aValue) const;
  int64_t getInt64(const std::string& aKey) const;
  int64_t getInt64(const std::string& aKey, int64_t aValue) const;
  uint64_t getUint64(const std::string& aKey) const;
  uint64_t getUint64(const std::string& aKey, uint64_t aValue) const;
  float getFloat(const std::string& aKey) const;
  float getFloat(const std::string& aKey, float aValue) const;
  double getDouble(const std::string& aKey) const;
  double getDouble(const std::string& aKey, double aValue) const;
  std::string getString(const std::string& aKey) const;
  std::string getString(const std::string& aKey,
                        const std::string& aValue) const;
  time_t getTime(const std::string& aKey) const;
  time_t getTime(const std::string& aKey, const time_t& aValue) const;
 
  std::vector<bool> getBoolVector(const std::string& aKey,
                                  bool expandable = false) const;
  std::vector<bool> getBoolVector(const std::string& aKey,
                                  const std::vector<bool>& aValue,
                                  bool expandable = false) const;
  std::vector<int> getIntVector(const std::string& aKey,
                                bool expandable = false) const;
  std::vector<int> getIntVector(const std::string& aKey,
                                const std::vector<int>& aValue,
                                bool expandable = false) const;
  std::vector<unsigned int> getUintVector(const std::string& aKey,
                                          bool expandable = false) const;
  std::vector<unsigned int> getUintVector(
      const std::string& aKey, const std::vector<unsigned int>& aValue,
      bool expandable = false) const;
  std::vector<int16_t> getInt16Vector(const std::string& aKey,
                                      bool expandable = false) const;
  std::vector<int16_t> getInt16Vector(const std::string& aKey,
                                      const std::vector<int16_t>& aValue,
                                      bool expandable = false) const;
  std::vector<uint16_t> getUint16Vector(const std::string& aKey,
                                        bool expandable = false) const;
  std::vector<uint16_t> getUint16Vector(const std::string& aKey,
                                        const std::vector<uint16_t>& aValue,
                                        bool expandable = false) const;
  std::vector<int32_t> getInt32Vector(const std::string& aKey,
                                      bool expandable = false) const;
  std::vector<int32_t> getInt32Vector(const std::string& aKey,
                                      const std::vector<int32_t>& aValue,
                                      bool expandable = false) const;
  std::vector<uint32_t> getUint32Vector(const std::string& aKey,
                                        bool expandable = false) const;
  std::vector<uint32_t> getUint32Vector(const std::string& aKey,
                                        const std::vector<uint32_t>& aValue,
                                        bool expandable = false) const;
  std::vector<int64_t> getInt64Vector(const std::string& aKey,
                                      bool expandable = false) const;
  std::vector<int64_t> getInt64Vector(const std::string& aKey,
                                      const std::vector<int64_t>& aValue,
                                      bool expandable = false) const;
  std::vector<uint64_t> getUint64Vector(const std::string& aKey,
                                        bool expandable = false) const;
  std::vector<uint64_t> getUint64Vector(const std::string& aKey,
                                        const std::vector<uint64_t>& aValue,
                                        bool expandable = false) const;
  std::vector<size_t> getSizeTVector(const std::string& aKey,
                                     bool expandable = false) const {
    static_assert(sizeof(size_t) == 8 || sizeof(size_t) == 4);
    // Lambda is necessary because returning the wrong type won't compile in the
    // main function, even when inside a if constexpr.
    auto pick_overload = [&](const std::string& aKey, bool expandable = false) {
      if constexpr (sizeof(size_t) == 8) {
        return getUint64Vector(aKey, expandable);
      } else if constexpr (sizeof(size_t) == 4) {
        return getUint32Vector(aKey, expandable);
      }
    };
    return pick_overload(aKey, expandable);
  }
  std::vector<float> getFloatVector(const std::string& aKey,
                                    bool expandable = false) const;
  std::vector<float> getFloatVector(const std::string& aKey,
                                    const std::vector<float>& aValue,
                                    bool expandable = false) const;
  std::vector<double> getDoubleVector(const std::string& aKey,
                                      bool expandable = false) const;
  std::vector<double> getDoubleVector(const std::string& aKey,
                                      const std::vector<double>& aValue,
                                      bool expandable = false) const;
  std::vector<std::string> getStringVector(const std::string& aKey,
                                           bool expandable = false) const;
  std::vector<std::string> getStringVector(
      const std::string& aKey, const std::vector<std::string>& aValue,
      bool expandable = false) const;
  std::vector<time_t> getTimeVector(const std::string& aKey,
                                    bool expandable = false) const;
  std::vector<time_t> getTimeVector(const std::string& aKey,
                                    const std::vector<time_t>& aValue,
                                    bool expandable = false) const;
 
 
  std::vector<std::string> unusedKeys() const;
 
 
  friend std::ostream& operator<<(std::ostream& os, const ParameterSet& thePS);
 
 private:
  explicit ParameterSet(const std::shared_ptr<ParameterSetImpl>& set) {
    itsSet = set;
  }
 
  std::shared_ptr<ParameterSetImpl> itsSet;
};
 
blob::BlobOStream& operator<<(blob::BlobOStream&, const ParameterSet&);
blob::BlobIStream& operator>>(blob::BlobIStream&, ParameterSet&);
 
//
// ---------- inline functions ----------
//
inline bool ParameterSet::empty() const { return itsSet->empty(); }
inline int ParameterSet::size() const { return itsSet->size(); }
inline ParameterSet::iterator ParameterSet::begin() { return itsSet->begin(); }
inline ParameterSet::iterator ParameterSet::end() { return itsSet->end(); }
inline ParameterSet::const_iterator ParameterSet::begin() const {
  return itsSet->begin();
}
inline ParameterSet::const_iterator ParameterSet::end() const {
  return itsSet->end();
}
 
inline const ParameterValue& ParameterSet::get(const std::string& aKey) const {
  return itsSet->get(aKey);
}
inline const ParameterValue& ParameterSet::operator[](
    const std::string& aKey) const {
  return itsSet->get(aKey);
}
 
inline KeyCompare::Mode ParameterSet::keyCompareMode() const {
  return itsSet->keyCompareMode();
}
 
inline void ParameterSet::clear() { itsSet->clear(); }
 
inline void ParameterSet::adoptFile(const std::string& theFilename,
                                    const std::string& thePrefix) {
  itsSet->adoptFile(theFilename, thePrefix);
}
 
inline void ParameterSet::adoptBuffer(const std::string& theBuffer,
                                      const std::string& thePrefix) {
  itsSet->adoptBuffer(theBuffer, thePrefix);
}
 
inline void ParameterSet::adoptCollection(const ParameterSet& theCollection,
                                          const std::string& thePrefix) {
  itsSet->adoptCollection(*theCollection.itsSet, thePrefix);
}
 
inline void ParameterSet::adoptArguments(
    const std::vector<std::string>& arguments) {
  itsSet->adoptArguments(arguments);
}
 
inline void ParameterSet::writeFile(const std::string& theFilename,
                                    bool append) const {
  itsSet->writeFile(theFilename, append);
}
 
inline void ParameterSet::writeBuffer(std::string& theBuffer) const {
  itsSet->writeBuffer(theBuffer);
}
 
inline void ParameterSet::writeStream(std::ostream& os) const {
  itsSet->writeStream(os);
}
 
inline ParameterSet ParameterSet::makeSubset(const std::string& baseKey,
                                             const std::string& prefix) const {
  return ParameterSet(itsSet->makeSubset(baseKey, prefix));
}
 
inline void ParameterSet::subtractSubset(const std::string& fullPrefix) {
  itsSet->subtractSubset(fullPrefix);
}
 
inline void ParameterSet::add(const std::string& aKey,
                              const std::string& aValue) {
  itsSet->add(aKey, ParameterValue(aValue, false));
}
inline void ParameterSet::add(const KVpair& aPair) {
  add(aPair.first, aPair.second);
}
 
inline void ParameterSet::replace(const std::string& aKey,
                                  const std::string& aValue) {
  itsSet->replace(aKey, ParameterValue(aValue, false));
}
inline void ParameterSet::replace(const KVpair& aPair) {
  replace(aPair.first, aPair.second);
}
 
inline void ParameterSet::remove(const std::string& aKey) {
  itsSet->remove(aKey);
}
 
inline ParameterSet::iterator ParameterSet::find(const std::string& searchKey) {
  return itsSet->find(searchKey);
}
 
inline ParameterSet::const_iterator ParameterSet::find(
    const std::string& searchKey) const {
  return itsSet->find(searchKey);
}
 
inline bool ParameterSet::isDefined(const std::string& searchKey) const {
  return itsSet->isDefined(searchKey);
}
 
inline std::string ParameterSet::locateModule(
    const std::string& shortName) const {
  return (itsSet->locateModule(shortName));
}
 
inline std::string ParameterSet::fullModuleName(
    const std::string& shortName) const {
  return (itsSet->fullModuleName(shortName));
}
 
inline std::vector<ParameterValue> ParameterSet::getVector(
    const std::string& aKey) const {
  return get(aKey).getVector();
}
 
// getBool(key)
inline bool ParameterSet::getBool(const std::string& aKey) const {
  return itsSet->getBool(aKey);
}
 
// getBool(key, value), where value is returned when the key is not found
inline bool ParameterSet::getBool(const std::string& aKey, bool aValue) const {
  return itsSet->getBool(aKey, aValue);
}
 
// getInt(key)
inline int ParameterSet::getInt(const std::string& aKey) const {
  return itsSet->getInt(aKey);
}
 
// getInt(key, value), where value is returned when the key is not found
inline int ParameterSet::getInt(const std::string& aKey, int aValue) const {
  return itsSet->getInt(aKey, aValue);
}
 
// getUint(key)
inline unsigned int ParameterSet::getUint(const std::string& aKey) const {
  return itsSet->getUint(aKey);
}
 
// getUint(key, value), where value is returned when the key is not found
inline unsigned int ParameterSet::getUint(const std::string& aKey,
                                          unsigned int aValue) const {
  return itsSet->getUint(aKey, aValue);
}
 
// getInt16(key)
inline int16_t ParameterSet::getInt16(const std::string& aKey) const {
  return itsSet->getInt16(aKey);
}
 
// getInt16(key, value), where value is returned when the key is not found
inline int16_t ParameterSet::getInt16(const std::string& aKey,
                                      int16_t aValue) const {
  return itsSet->getInt16(aKey, aValue);
}
 
// getUint16(key)
inline uint16_t ParameterSet::getUint16(const std::string& aKey) const {
  return itsSet->getUint16(aKey);
}
 
// getUint16(key, value), where value is returned when the key is not found
inline uint16_t ParameterSet::getUint16(const std::string& aKey,
                                        uint16_t aValue) const {
  return itsSet->getUint16(aKey, aValue);
}
 
// getInt32(key)
inline int32_t ParameterSet::getInt32(const std::string& aKey) const {
  return itsSet->getInt32(aKey);
}
 
// getInt32(key, value), where value is returned when the key is not found
inline int32_t ParameterSet::getInt32(const std::string& aKey,
                                      int32_t aValue) const {
  return itsSet->getInt32(aKey, aValue);
}
 
// getUint32(key)
inline uint32_t ParameterSet::getUint32(const std::string& aKey) const {
  return itsSet->getUint32(aKey);
}
 
// getUint32(key, value), where value is returned when the key is not found
inline uint32_t ParameterSet::getUint32(const std::string& aKey,
                                        uint32_t aValue) const {
  return itsSet->getUint32(aKey, aValue);
}
 
// getInt64(key)
inline int64_t ParameterSet::getInt64(const std::string& aKey) const {
  return itsSet->getInt64(aKey);
}
 
// getInt64(key, value), where value is returned when the key is not found
inline int64_t ParameterSet::getInt64(const std::string& aKey,
                                      int64_t aValue) const {
  return itsSet->getInt64(aKey, aValue);
}
 
// getUint64(key)
inline uint64_t ParameterSet::getUint64(const std::string& aKey) const {
  return itsSet->getUint64(aKey);
}
 
// getUint64(key, value), where value is returned when the key is not found
inline uint64_t ParameterSet::getUint64(const std::string& aKey,
                                        uint64_t aValue) const {
  return itsSet->getUint64(aKey, aValue);
}
 
// getFloat(key)
inline float ParameterSet::getFloat(const std::string& aKey) const {
  return itsSet->getFloat(aKey);
}
 
// getFloat(key, value), where value is returned when the key is not found
inline float ParameterSet::getFloat(const std::string& aKey,
                                    float aValue) const {
  return itsSet->getFloat(aKey, aValue);
}
 
// getDouble(key)
inline double ParameterSet::getDouble(const std::string& aKey) const {
  return itsSet->getDouble(aKey);
}
 
// getDouble(key, value), where value is returned when the key is not found
inline double ParameterSet::getDouble(const std::string& aKey,
                                      double aValue) const {
  return itsSet->getDouble(aKey, aValue);
}
 
// getString(key)
inline std::string ParameterSet::getString(const std::string& aKey) const {
  return itsSet->getString(aKey);
}
 
// getString(key, value), where value is returned when the key is not found
inline std::string ParameterSet::getString(const std::string& aKey,
                                           const std::string& aValue) const {
  return itsSet->getString(aKey, aValue);
}
 
// getTime(key)
inline time_t ParameterSet::getTime(const std::string& aKey) const {
  return itsSet->getTime(aKey);
}
 
// getTime(key, value), where value is returned when the key is not found
inline time_t ParameterSet::getTime(const std::string& aKey,
                                    const time_t& aValue) const {
  return itsSet->getTime(aKey, aValue);
}
 
// getBoolVector(key)
inline std::vector<bool> ParameterSet::getBoolVector(const std::string& aKey,
                                                     bool expandable) const {
  return itsSet->getBoolVector(aKey, expandable);
}
 
// getBoolVector(key, value), where value is returned when the key is not found
inline std::vector<bool> ParameterSet::getBoolVector(
    const std::string& aKey, const std::vector<bool>& aValue,
    bool expandable) const {
  return itsSet->getBoolVector(aKey, aValue, expandable);
}
 
// getIntVector(key)
inline std::vector<int> ParameterSet::getIntVector(const std::string& aKey,
                                                   bool expandable) const {
  return itsSet->getIntVector(aKey, expandable);
}
 
// getIntVector(key, value), where value is returned when the key is not found
inline std::vector<int> ParameterSet::getIntVector(
    const std::string& aKey, const std::vector<int>& aValue,
    bool expandable) const {
  return itsSet->getIntVector(aKey, aValue, expandable);
}
 
// getUintVector(key)
inline std::vector<unsigned int> ParameterSet::getUintVector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getUintVector(aKey, expandable);
}
 
// getUintVector(key, value), where value is returned when the key is not found
inline std::vector<unsigned int> ParameterSet::getUintVector(
    const std::string& aKey, const std::vector<unsigned int>& aValue,
    bool expandable) const {
  return itsSet->getUintVector(aKey, aValue, expandable);
}
 
// getInt16Vector(key)
inline std::vector<int16_t> ParameterSet::getInt16Vector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getInt16Vector(aKey, expandable);
}
 
// getInt16Vector(key, value), where value is returned when key is not found
inline std::vector<int16_t> ParameterSet::getInt16Vector(
    const std::string& aKey, const std::vector<int16_t>& aValue,
    bool expandable) const {
  return itsSet->getInt16Vector(aKey, aValue, expandable);
}
 
// getUint16Vector(key)
inline std::vector<uint16_t> ParameterSet::getUint16Vector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getUint16Vector(aKey, expandable);
}
 
// getUint16Vector(key, value), where value is returned when key is not found
inline std::vector<uint16_t> ParameterSet::getUint16Vector(
    const std::string& aKey, const std::vector<uint16_t>& aValue,
    bool expandable) const {
  return itsSet->getUint16Vector(aKey, aValue, expandable);
}
 
// getInt32Vector(key)
inline std::vector<int32_t> ParameterSet::getInt32Vector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getInt32Vector(aKey, expandable);
}
 
// getInt32Vector(key, value), where value is returned when key is not found
inline std::vector<int32_t> ParameterSet::getInt32Vector(
    const std::string& aKey, const std::vector<int32_t>& aValue,
    bool expandable) const {
  return itsSet->getInt32Vector(aKey, aValue, expandable);
}
 
// getUint32Vector(key)
inline std::vector<uint32_t> ParameterSet::getUint32Vector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getUint32Vector(aKey, expandable);
}
 
// getUint32Vector(key, value), where value is returned when key is not found
inline std::vector<uint32_t> ParameterSet::getUint32Vector(
    const std::string& aKey, const std::vector<uint32_t>& aValue,
    bool expandable) const {
  return itsSet->getUint32Vector(aKey, aValue, expandable);
}
 
// getInt64Vector(key)
inline std::vector<int64_t> ParameterSet::getInt64Vector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getInt64Vector(aKey, expandable);
}
 
// getInt64Vector(key, value), where value is returned when key is not found
inline std::vector<int64_t> ParameterSet::getInt64Vector(
    const std::string& aKey, const std::vector<int64_t>& aValue,
    bool expandable) const {
  return itsSet->getInt64Vector(aKey, aValue, expandable);
}
 
// getUint64Vector(key)
inline std::vector<uint64_t> ParameterSet::getUint64Vector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getUint64Vector(aKey, expandable);
}
 
// getUint64Vector(key, value), where value is returned when key is not found
inline std::vector<uint64_t> ParameterSet::getUint64Vector(
    const std::string& aKey, const std::vector<uint64_t>& aValue,
    bool expandable) const {
  return itsSet->getUint64Vector(aKey, aValue, expandable);
}
 
// getFloatVector(key)
inline std::vector<float> ParameterSet::getFloatVector(const std::string& aKey,
                                                       bool expandable) const {
  return itsSet->getFloatVector(aKey, expandable);
}
 
// getFloatVector(key, value), where value is returned when key is not found
inline std::vector<float> ParameterSet::getFloatVector(
    const std::string& aKey, const std::vector<float>& aValue,
    bool expandable) const {
  return itsSet->getFloatVector(aKey, aValue, expandable);
}
 
// getDoubleVector(key)
inline std::vector<double> ParameterSet::getDoubleVector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getDoubleVector(aKey, expandable);
}
// getDoubleVector(key, value), where value is returned when key is not found
inline std::vector<double> ParameterSet::getDoubleVector(
    const std::string& aKey, const std::vector<double>& aValue,
    bool expandable) const {
  return itsSet->getDoubleVector(aKey, aValue, expandable);
}
 
// getStringVector(key)
inline std::vector<std::string> ParameterSet::getStringVector(
    const std::string& aKey, bool expandable) const {
  return itsSet->getStringVector(aKey, expandable);
}
 
// getStringVector(key, value), where value is returned when key is not found
inline std::vector<std::string> ParameterSet::getStringVector(
    const std::string& aKey, const std::vector<std::string>& aValue,
    bool expandable) const {
  return itsSet->getStringVector(aKey, aValue, expandable);
}
 
// getTimeVector(key)
inline std::vector<time_t> ParameterSet::getTimeVector(const std::string& aKey,
                                                       bool expandable) const {
  return itsSet->getTimeVector(aKey, expandable);
}
 
// getTimeVector(key, value), where value is returned when key is not found
inline std::vector<time_t> ParameterSet::getTimeVector(
    const std::string& aKey, const std::vector<time_t>& aValue,
    bool expandable) const {
  return itsSet->getTimeVector(aKey, aValue, expandable);
}
 
inline std::vector<std::string> ParameterSet::unusedKeys() const {
  return itsSet->unusedKeys();
}
 
}  // namespace common
}  // namespace dp3
 
#endif