ParameterSetImpl.h

Go to the documentation of this file.

// ParameterSetImpl.h: Implements a map of Key-Value pairs.
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_COMMON_PARAMETERSETIMPL_H
#define LOFAR_COMMON_PARAMETERSETIMPL_H
 
// Never #include <config.h> or #include <lofar_config.h> in a header file!
#include "ParameterValue.h"
#include "StringTools.h"
 
#include <map>
#include <memory>
#include <mutex>
#include <set>
 
namespace dp3 {
namespace common {
 
 
 
const char PC_QUAL_STABLE[] = {"stable"};
const char PC_QUAL_TEST[] = {"test"};
const char PC_QUAL_DEVELOP[] = {"development"};
const char PC_KEY_VERSIONNR[] = {"versionnr"};
const char PC_KEY_QUAL[] = {"qualification"};
 
typedef common::stringtools::Compare KeyCompare;
 
typedef std::map<std::string, ParameterValue, KeyCompare> KVMap;
 
class ParameterSetImpl : public KVMap {
 public:
  typedef KVMap::iterator iterator;
  typedef KVMap::const_iterator const_iterator;
 
 
  explicit ParameterSetImpl(KeyCompare::Mode mode);
 
  ~ParameterSetImpl();
 
  explicit ParameterSetImpl(const std::string& theFilename,
                            KeyCompare::Mode mode);
 
  const ParameterValue& get(const std::string& aKey) const;
 
  KeyCompare::Mode keyCompareMode() const { return itsMode; }
 
 
  void adoptFile(const std::string& theFilename,
                 const std::string& thePrefix = "");
 
  void adoptBuffer(const std::string& theBuffer,
                   const std::string& thePrefix = "");
 
  void adoptCollection(const ParameterSetImpl& 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;
 
 
  std::shared_ptr<ParameterSetImpl> makeSubset(
      const std::string& baseKey, const std::string& prefix = "") const;
 
  void subtractSubset(const std::string& fullPrefix);
 
 
  void add(const std::string& aKey, const ParameterValue& aValue);
 
  void replace(const std::string& aKey, const ParameterValue& aValue);
 
  void remove(const std::string& aKey);
 
 
  bool isDefined(const std::string& searchKey) const {
    return (find(searchKey) != end());
  };
 
  std::string locateModule(const std::string& shortName) const;
 
  std::string fullModuleName(const std::string& shortName) 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) const;
  std::vector<bool> getBoolVector(const std::string& aKey,
                                  const std::vector<bool>& aValue,
                                  bool expandable) const;
  std::vector<int> getIntVector(const std::string& aKey, bool expandable) const;
  std::vector<int> getIntVector(const std::string& aKey,
                                const std::vector<int>& aValue,
                                bool expandable) const;
  std::vector<unsigned int> getUintVector(const std::string& aKey,
                                          bool expandable) const;
  std::vector<unsigned int> getUintVector(
      const std::string& aKey, const std::vector<unsigned int>& aValue,
      bool expandable) const;
  std::vector<int16_t> getInt16Vector(const std::string& aKey,
                                      bool expandable) const;
  std::vector<int16_t> getInt16Vector(const std::string& aKey,
                                      const std::vector<int16_t>& aValue,
                                      bool expandable) const;
  std::vector<uint16_t> getUint16Vector(const std::string& aKey,
                                        bool expandable) const;
  std::vector<uint16_t> getUint16Vector(const std::string& aKey,
                                        const std::vector<uint16_t>& aValue,
                                        bool expandable) const;
  std::vector<int32_t> getInt32Vector(const std::string& aKey,
                                      bool expandable) const;
  std::vector<int32_t> getInt32Vector(const std::string& aKey,
                                      const std::vector<int32_t>& aValue,
                                      bool expandable) const;
  std::vector<uint32_t> getUint32Vector(const std::string& aKey,
                                        bool expandable) const;
  std::vector<uint32_t> getUint32Vector(const std::string& aKey,
                                        const std::vector<uint32_t>& aValue,
                                        bool expandable) const;
  std::vector<int64_t> getInt64Vector(const std::string& aKey,
                                      bool expandable) const;
  std::vector<int64_t> getInt64Vector(const std::string& aKey,
                                      const std::vector<int64_t>& aValue,
                                      bool expandable) const;
  std::vector<uint64_t> getUint64Vector(const std::string& aKey,
                                        bool expandable) const;
  std::vector<uint64_t> getUint64Vector(const std::string& aKey,
                                        const std::vector<uint64_t>& aValue,
                                        bool expandable) const;
  std::vector<float> getFloatVector(const std::string& aKey,
                                    bool expandable) const;
  std::vector<float> getFloatVector(const std::string& aKey,
                                    const std::vector<float>& aValue,
                                    bool expandable) const;
  std::vector<double> getDoubleVector(const std::string& aKey,
                                      bool expandable) const;
  std::vector<double> getDoubleVector(const std::string& aKey,
                                      const std::vector<double>& aValue,
                                      bool expandable) const;
  std::vector<std::string> getStringVector(const std::string& aKey,
                                           bool expandable) const;
  std::vector<std::string> getStringVector(
      const std::string& aKey, const std::vector<std::string>& aValue,
      bool expandable) const;
  std::vector<time_t> getTimeVector(const std::string& aKey,
                                    bool expandable) const;
  std::vector<time_t> getTimeVector(const std::string& aKey,
                                    const std::vector<time_t>& aValue,
                                    bool expandable) const;
 
 
 
  // Allow printing the whole parameter collection.
  friend std::ostream& operator<<(std::ostream& os,
                                  const ParameterSetImpl& thePS);
 
  std::vector<std::string> unusedKeys() const;
 
 private:
  ParameterSetImpl(const ParameterSetImpl& that);
  ParameterSetImpl& operator=(const ParameterSetImpl& that);
 
  void readFile(const std::string& theFile, const std::string& prefix,
                const bool merge);
  void readBuffer(const std::string& theFile, const std::string& prefix,
                  const bool merge);
  void readStream(std::istream& inputStream, const std::string& prefix,
                  const bool merge);
 
  const_iterator findKV(const std::string& aKey, bool doThrow = true) const;
 
  void addMerge(const std::string& key, const std::string& value, bool merge);
 
  void addUnlocked(const std::string& aKey, const ParameterValue& aValue);
 
  void replaceUnlocked(const std::string& aKey, const ParameterValue& aValue);
 
  const KeyCompare::Mode itsMode;
  mutable std::set<std::string> itsAskedParms;
  mutable std::mutex itsMutex;
};
 
// -------------------- Global functions --------------------
bool isValidVersionNr(const std::string& versionNr);
 
bool isValidVersionNrRef(const std::string& versionNr);
 
// Returns the value of the given string or 0 if it is not a valid seqnr
// uint32       seqNr(const std::string& aString);
 
// When a hierarchical keyname is passed to \c fullKeyName the methods returns
std::string keyName(const std::string& fullKeyName);
 
// When a hierarchical keyname is passed to \c moduleName the methods returns
std::string moduleName(const std::string& fullKeyName);
 
std::string keyPart(const std::string& parameterLine);
 
std::string valuePart(const std::string& parameterLine);
 
int32_t indexValue(const std::string& label, const char indexMarker[2]);
 
 
inline const ParameterValue& ParameterSetImpl::get(
    const std::string& aKey) const {
  return findKV(aKey)->second;
}
 
inline bool ParameterSetImpl::getBool(const std::string& aKey) const {
  return findKV(aKey)->second.getBool();
}
 
inline bool ParameterSetImpl::getBool(const std::string& aKey,
                                      bool aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getBool();
}
 
inline int ParameterSetImpl::getInt(const std::string& aKey) const {
  return findKV(aKey)->second.getInt();
}
 
inline int ParameterSetImpl::getInt(const std::string& aKey, int aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getInt();
}
 
inline unsigned int ParameterSetImpl::getUint(const std::string& aKey) const {
  return findKV(aKey)->second.getUint();
}
 
inline unsigned int ParameterSetImpl::getUint(const std::string& aKey,
                                              unsigned int aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getUint();
}
 
inline int16_t ParameterSetImpl::getInt16(const std::string& aKey) const {
  return findKV(aKey)->second.getInt16();
}
 
inline int16_t ParameterSetImpl::getInt16(const std::string& aKey,
                                          int16_t aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getInt16();
}
 
inline uint16_t ParameterSetImpl::getUint16(const std::string& aKey) const {
  return findKV(aKey)->second.getUint16();
}
 
inline uint16_t ParameterSetImpl::getUint16(const std::string& aKey,
                                            uint16_t aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getUint16();
}
 
inline int32_t ParameterSetImpl::getInt32(const std::string& aKey) const {
  return findKV(aKey)->second.getInt32();
}
 
inline int32_t ParameterSetImpl::getInt32(const std::string& aKey,
                                          int32_t aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getInt32();
}
 
inline uint32_t ParameterSetImpl::getUint32(const std::string& aKey) const {
  return findKV(aKey)->second.getUint32();
}
 
inline uint32_t ParameterSetImpl::getUint32(const std::string& aKey,
                                            uint32_t aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getUint32();
}
 
inline int64_t ParameterSetImpl::getInt64(const std::string& aKey) const {
  return findKV(aKey)->second.getInt64();
}
 
inline int64_t ParameterSetImpl::getInt64(const std::string& aKey,
                                          int64_t aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getInt64();
}
 
inline uint64_t ParameterSetImpl::getUint64(const std::string& aKey) const {
  return findKV(aKey)->second.getUint64();
}
 
inline uint64_t ParameterSetImpl::getUint64(const std::string& aKey,
                                            uint64_t aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getUint64();
}
 
inline float ParameterSetImpl::getFloat(const std::string& aKey) const {
  return findKV(aKey)->second.getFloat();
}
 
inline float ParameterSetImpl::getFloat(const std::string& aKey,
                                        float aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getFloat();
}
 
inline double ParameterSetImpl::getDouble(const std::string& aKey) const {
  return findKV(aKey)->second.getDouble();
}
 
inline double ParameterSetImpl::getDouble(const std::string& aKey,
                                          double aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getDouble();
}
 
inline std::string ParameterSetImpl::getString(const std::string& aKey) const {
  return findKV(aKey)->second.getString();
}
 
inline std::string ParameterSetImpl::getString(
    const std::string& aKey, const std::string& aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getString();
}
 
inline time_t ParameterSetImpl::getTime(const std::string& aKey) const {
  return findKV(aKey)->second.getTime();
}
 
inline time_t ParameterSetImpl::getTime(const std::string& aKey,
                                        const time_t& aValue) const {
  const_iterator it = findKV(aKey, false);
  if (it == end()) return aValue;
  return it->second.getTime();
}
 
}  // namespace common
}  // namespace dp3
 
#endif