ParameterValue.h

Go to the documentation of this file.

// ParameterValue.h: The value of a parameter
//
// Copyright (C) 2020 ASTRON (Netherlands Institute for Radio Astronomy)
// SPDX-License-Identifier: GPL-3.0-or-later
 
#ifndef LOFAR_COMMON_PARAMETERVALUE_H
#define LOFAR_COMMON_PARAMETERVALUE_H
 
#include "StringTools.h"
 
namespace dp3 {
namespace common {
 
// Forward declaration.
class ParameterRecord;
 
 
class ParameterValue {
 public:
  ParameterValue() {}
 
  explicit ParameterValue(const std::string& value, bool trim = true);
 
  ParameterValue expand() const;
 
  bool isVector() const { return itsValue[0] == '['; }
 
  bool isRecord() const { return itsValue[0] == '{'; }
 
  const std::string& get() const { return itsValue; }
 
  std::vector<ParameterValue> getVector() const;
 
  ParameterRecord getRecord() const;
 
  bool getBool() const { return strToBool(itsValue); }
  int getInt() const { return strToInt(itsValue); }
  unsigned int getUint() const { return strToUint(itsValue); }
  int16_t getInt16() const { return strToInt16(itsValue); }
  uint16_t getUint16() const { return strToUint16(itsValue); }
  int32_t getInt32() const { return strToInt32(itsValue); }
  int32_t getUint32() const { return strToUint32(itsValue); }
  int64_t getInt64() const { return strToInt64(itsValue); }
  uint64_t getUint64() const { return strToUint64(itsValue); }
  float getFloat() const { return strToFloat(itsValue); }
  double getDouble() const { return strToDouble(itsValue); }
  std::string getString() const;
  time_t getTime() const { return StringToTime_t(itsValue); }
  std::vector<bool> getBoolVector() const;
  std::vector<int> getIntVector() const;
  std::vector<unsigned int> getUintVector() const;
  std::vector<int16_t> getInt16Vector() const;
  std::vector<uint16_t> getUint16Vector() const;
  std::vector<int32_t> getInt32Vector() const;
  std::vector<uint32_t> getUint32Vector() const;
  std::vector<int64_t> getInt64Vector() const;
  std::vector<uint64_t> getUint64Vector() const;
  std::vector<float> getFloatVector() const;
  std::vector<double> getDoubleVector() const;
  std::vector<std::string> getStringVector() const;
  std::vector<time_t> getTimeVector() const;
 
  operator bool() const { return getBool(); }
  operator int() const { return getInt(); }
  operator unsigned int() const { return getUint(); }
  operator float() const { return getFloat(); }
  operator double() const { return getDouble(); }
  operator std::string() const { return getString(); }
  operator time_t() const { return getTime(); }
  operator std::vector<bool>() const { return getBoolVector(); }
  operator std::vector<int>() const { return getIntVector(); }
  operator std::vector<unsigned int>() const { return getUintVector(); }
  operator std::vector<float>() const { return getFloatVector(); }
  operator std::vector<double>() const { return getDoubleVector(); }
  operator std::vector<std::string>() const { return getStringVector(); }
  operator std::vector<time_t>() const { return getTimeVector(); }
 
  static time_t StringToTime_t(const std::string& aString);
 
  friend std::ostream& operator<<(std::ostream& os,
                                  const ParameterValue& pval) {
    os << pval.itsValue;
    return os;
  }
  friend std::istream& operator>>(std::istream& os, ParameterValue& pval) {
    os >> pval.itsValue;
    return os;
  }
 
 private:
  std::vector<ParameterValue> splitValue(unsigned int st,
                                         unsigned int last) const;
 
  ParameterValue substr(int st, int end) const {
    return ParameterValue(itsValue.substr(st, end - st));
  }
 
  std::string itsValue;
};
 
}  // namespace common
}  // namespace dp3
 
#endif