Configuration.h

Go to the documentation of this file.

/*
 * Copyright 2015-2019 CNRS-UM LIRMM, CNRS-AIST JRL
 */
 
#pragma once
 
#include <mc_rtc/MessagePackBuilder.h>
#include <mc_rtc/deprecated.h>
 
#include <mc_rbdyn/Gains.h>
#include <mc_rbdyn/rpy_utils.h>
 
#include <SpaceVecAlg/SpaceVecAlg>
 
#include <Eigen/Core>
#include <spdlog/fmt/fmt.h>
 
#include <array>
#include <exception>
#include <map>
#include <memory>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <unordered_set>
#include <variant>
#include <vector>
 
// The code we use to convert a Configuration value to an std::variant value requires GCC >= 8.3
// We use a less optimal recursive implementation for the case where GCC < 8.3
#if defined(__GNUC__) && !defined(__llvm__) && !defined(__INTEL_COMPILER)
#  if __GNUC__ > 8 || (__GNUC__ == 8 && __GNUC_MINOR__ > 2)
#    define MC_RTC_USE_VARIANT_WORKAROUND 0
#  else
#    define MC_RTC_USE_VARIANT_WORKAROUND 1
#  endif
#else
#  define MC_RTC_USE_VARIANT_WORKAROUND 0
#endif
 
namespace mc_rtc
{
 
struct MC_RTC_UTILS_DLLAPI ConfigurationArrayIterator;
struct MC_RTC_UTILS_DLLAPI Configuration;
 
template<typename T>
struct ConfigurationLoader
{
  static void load(const mc_rtc::Configuration &) {}
 
  static void save(const T &) {}
};
 
template<>
struct ConfigurationLoader<void>
{
  static void load(const mc_rtc::Configuration &) {}
  static void save() {}
};
 
namespace internal
{
struct _has_configuration_load_object
{
  template<typename T,
           typename std::enable_if<
               std::is_same<decltype(ConfigurationLoader<T>::load(std::declval<const Configuration &>())), T>::value,
               int>::type = 0>
  static std::true_type test(T * p);
 
  template<typename T>
  static std::false_type test(...);
};
 
template<typename T>
inline constexpr bool has_configuration_load_object_v =
    decltype(_has_configuration_load_object::test<T>(nullptr))::value;
 
struct _has_static_fromConfiguration
{
  template<typename T,
           typename = std::enable_if_t<
               std::is_same_v<decltype(T::fromConfiguration(std::declval<const Configuration &>())), T>>>
  static std::true_type test(T * p);
 
  template<typename T>
  static std::false_type test(...);
};
 
template<typename T>
inline constexpr bool has_static_fromConfiguration_v = decltype(_has_static_fromConfiguration::test<T>(nullptr))::value;
 
struct _has_configuration_save_object
{
  template<typename T,
           typename... Args,
           typename std::enable_if<
               std::is_same<decltype(ConfigurationLoader<T>::save(std::declval<const T &>(), std::declval<Args>()...)),
                            Configuration>::value,
               int>::type = 0>
  static std::true_type test(T * p);
 
  template<typename T, typename... Args>
  static std::false_type test(...);
};
 
template<typename T, typename... Args>
inline constexpr bool has_configuration_save_object_v =
    decltype(_has_configuration_save_object::test<T, Args...>(nullptr))::value;
 
struct _has_toConfiguration_method
{
  template<
      typename T,
      typename... Args,
      typename = std::enable_if_t<
          std::is_same_v<decltype(std::declval<const T &>().toConfiguration(std::declval<Args>()...)), Configuration>>>
  static std::true_type test(T * p);
 
  template<typename T, typename... Args>
  static std::false_type test(...);
};
 
template<typename T, typename... Args>
inline constexpr bool has_toConfiguration_method_v =
    decltype(_has_toConfiguration_method::test<T, Args...>(nullptr))::value;
 
#if MC_RTC_USE_VARIANT_WORKAROUND
template<size_t IDX, typename... Args>
std::variant<Args...> to_variant(const Configuration & c, size_t idx);
#endif
 
} // namespace internal
 
struct MC_RTC_UTILS_DLLAPI Configuration
{
private:
  struct MC_RTC_UTILS_DLLAPI Json
  {
    bool isArray() const noexcept;
    size_t size() const noexcept;
    Json operator[](size_t idx) const;
    bool isObject() const noexcept;
    std::vector<std::string> keys() const noexcept;
    Json operator[](const std::string & key) const;
    std::optional<Json> find(const std::string & key) const;
    bool isString() const noexcept;
    bool isNumeric() const noexcept;
    bool isInteger() const noexcept;
    bool isInt32() const noexcept;
    bool isInt64() const noexcept;
    bool isUInt32() const noexcept;
    bool isUInt64() const noexcept;
    bool isDouble() const noexcept;
 
    double asDouble() const;
    void path(std::string & out) const noexcept;
    void * value_;
    std::shared_ptr<void> doc_;
  };
 
public:
  struct MC_RTC_UTILS_DLLAPI Exception : public std::exception
  {
    Exception(const std::string & msg, const Json & v);
 
    Exception(const std::string & msg, const Configuration & c) : Exception(msg, c.v) {}
 
    ~Exception() noexcept;
 
    virtual const char * what() const noexcept override;
 
    void silence() const noexcept;
 
    const std::string & msg() const noexcept;
 
  private:
    mutable std::string msg_;
    mutable Json v_;
  };
 
  MC_RTC_DEPRECATED bool isMember(const std::string & key) const;
 
  bool has(const std::string & key) const;
 
  operator bool() const;
 
  operator int8_t() const;
 
  operator uint8_t() const;
 
  operator int16_t() const;
 
  operator uint16_t() const;
 
  operator int32_t() const;
 
  operator uint32_t() const;
 
  operator int64_t() const;
 
  operator uint64_t() const;
 
  operator double() const;
 
  operator std::string() const;
 
  operator Eigen::Vector2d() const;
 
  operator Eigen::Vector3d() const;
 
  operator Eigen::Vector4d() const;
 
  operator Eigen::Vector6d() const;
 
  operator mc_rbdyn::Gains2d() const;
 
  operator mc_rbdyn::Gains3d() const;
 
  operator mc_rbdyn::Gains6d() const;
 
  operator Eigen::VectorXd() const;
 
  operator Eigen::Quaterniond() const;
 
  operator Eigen::Matrix3d() const;
 
  operator Eigen::Matrix6d() const;
 
  operator Eigen::MatrixXd() const;
 
  operator sva::PTransformd() const;
 
  operator sva::ForceVecd() const;
 
  operator sva::MotionVecd() const;
 
  operator sva::ImpedanceVecd() const;
 
  template<class T, class A>
  operator std::vector<T, A>() const
  {
    if(v.isArray())
    {
      std::vector<T, A> ret;
      for(size_t i = 0; i < v.size(); ++i) { ret.push_back(Configuration(v[i])); }
      return ret;
    }
    throw Configuration::Exception("Stored Json value is not a vector", v);
  }
 
  template<class T, std::size_t N>
  operator std::array<T, N>() const
  {
    if(v.isArray() && v.size() == N)
    {
      std::array<T, N> ret;
      for(size_t i = 0; i < N; ++i) { ret[i] = Configuration(v[i]); }
      return ret;
    }
    throw Configuration::Exception("Stored Json value is not an array or its size is incorrect", v);
  }
 
  template<class T1, class T2>
  operator std::pair<T1, T2>() const
  {
    if(v.isArray() && v.size() == 2) { return std::make_pair<T1, T2>(Configuration(v[0]), Configuration(v[1])); }
    throw Configuration::Exception("Stored Json value is not an array of size 2", v);
  }
 
  template<typename T, class C, class A>
  operator std::map<std::string, T, C, A>() const
  {
    if(v.isObject())
    {
      std::map<std::string, T, C, A> ret;
      auto keys = v.keys();
      assert(std::set<std::string>(keys.begin(), keys.end()).size() == keys.size());
      for(const auto & k : keys)
      {
        T value = Configuration(v[k]);
        ret[k] = value;
      }
      return ret;
    }
    throw Configuration::Exception("Stored Json value is not an object", v);
  }
 
  template<typename T, typename C = std::less<T>, typename A = std::allocator<T>>
  operator std::set<T, C, A>() const
  {
    if(v.isArray())
    {
      std::set<T, C, A> ret;
      for(size_t i = 0; i < v.size(); ++i)
      {
        auto ins = ret.insert(Configuration(v[i]));
        if(!ins.second) { throw Configuration::Exception("Stored Json set does not hold unique values", v); }
      }
      return ret;
    }
    throw Configuration::Exception("Stored Json value is not an array", v);
  }
 
  template<typename T, typename H = std::hash<T>, typename E = std::equal_to<T>, typename A = std::allocator<T>>
  operator std::unordered_set<T, H, E, A>() const
  {
    if(v.isArray())
    {
      std::unordered_set<T, H, E, A> ret;
      for(size_t i = 0; i < v.size(); ++i)
      {
        auto ins = ret.insert(Configuration(v[i]));
        if(!ins.second) { throw Configuration::Exception("Stored Json set does not hold unique values", v); }
      }
      return ret;
    }
    throw Configuration::Exception("Stored Json value is not an array", v);
  }
 
  template<typename... Args>
  operator std::variant<Args...>() const
  {
    if(!v.isArray()) { throw Configuration::Exception("Stored Json value is not an array", v); }
    if(v.size() != 2) { throw Configuration::Exception("Stored Json value is not of size 2", v); }
    size_t idx = Configuration(v[0]);
    if(idx >= sizeof...(Args)) { throw Configuration::Exception("Variant index out of type index bound", v); }
#if MC_RTC_USE_VARIANT_WORKAROUND
    return internal::to_variant<0, Args...>(v[1], idx);
#else
    static constexpr auto table =
        std::array{+[](const Configuration & c) { return std::variant<Args...>{c.operator Args()}; }...};
    return table[idx](v[1]);
#endif
  }
 
  template<typename T, typename std::enable_if<internal::is_integral_v<T>, int>::type = 0>
  operator T() const
  {
    if constexpr(internal::is_like_int8_t<T>) { return static_cast<T>(this->operator int8_t()); }
    else if constexpr(internal::is_like_int16_t<T>) { return static_cast<T>(this->operator int16_t()); }
    else if constexpr(internal::is_like_int32_t<T>) { return static_cast<T>(this->operator int32_t()); }
    else if constexpr(internal::is_like_int64_t<T>) { return static_cast<T>(this->operator int64_t()); }
    else if constexpr(internal::is_like_uint8_t<T>) { return static_cast<T>(this->operator uint8_t()); }
    else if constexpr(internal::is_like_uint16_t<T>) { return static_cast<T>(this->operator uint16_t()); }
    else if constexpr(internal::is_like_uint32_t<T>) { return static_cast<T>(this->operator uint32_t()); }
    else if constexpr(internal::is_like_uint64_t<T>) { return static_cast<T>(this->operator uint64_t()); }
    else
    {
      static_assert(!std::is_same_v<T, T>, "T is integral but has an unsupported size");
    }
  }
 
  template<typename T,
           typename std::enable_if<internal::has_configuration_load_object_v<T>
                                       || internal::has_static_fromConfiguration_v<T>,
                                   int>::type = 0>
  operator T() const
  {
    if constexpr(internal::has_configuration_load_object_v<T>) { return ConfigurationLoader<T>::load(*this); }
    else
    {
      return T::fromConfiguration(*this);
    }
  }
 
  template<typename T>
  explicit operator std::optional<T>() const
  {
    try
    {
      return this->convert<T>();
    }
    catch(Exception & exc)
    {
      exc.silence();
      return std::nullopt;
    }
  }
 
  Configuration();
 
  Configuration(const std::string & path);
 
  Configuration(const char * path);
 
  static Configuration rootArray();
 
  static Configuration fromData(const std::string & data);
 
  static Configuration fromData(const char * data);
 
  static Configuration fromYAMLData(const std::string & data);
 
  static Configuration fromYAMLData(const char * data);
 
  static Configuration fromMessagePack(const char * data, size_t size);
 
  void load(const std::string & path);
 
  void load(const mc_rtc::Configuration & config);
 
  void loadData(const std::string & data);
 
  void loadYAMLData(const std::string & data);
 
  void save(const std::string & path, bool pretty = true) const;
 
  std::string dump(bool pretty = false, bool yaml = false) const;
 
  size_t toMessagePack(std::vector<char> & data) const;
 
  void toMessagePack(MessagePackBuilder & builder) const;
 
  Configuration operator()(const std::string & key) const;
 
  std::optional<Configuration> find(const std::string & key) const;
 
  template<typename... Args>
  std::optional<Configuration> find(const std::string & key, Args &&... others) const
  {
    auto out = find(key);
    return out ? out->find(std::forward<Args>(others)...) : std::nullopt;
  }
 
  template<typename T, typename... Args>
  std::optional<T> find(const std::string & key, Args &&... others) const
  {
    auto maybe_cfg = find(key, std::forward<Args>(others)...);
    if(maybe_cfg) { return maybe_cfg->operator T(); }
    return std::nullopt;
  }
 
  bool empty() const;
 
  size_t size() const;
 
  inline bool isArray() const noexcept { return v.isArray(); }
 
  inline bool isObject() const noexcept { return v.isObject(); }
 
  inline bool isString() const noexcept { return v.isString(); }
 
  inline bool isNumeric() const noexcept { return v.isNumeric(); }
  inline bool isInteger() const noexcept { return v.isInteger(); }
  inline bool isInt32() const noexcept { return v.isInt32(); }
  inline bool isInt64() const noexcept { return v.isInt64(); }
  inline bool isUInt32() const noexcept { return v.isUInt32(); }
  inline bool isUInt64() const noexcept { return v.isUInt64(); }
  inline bool isDouble() const noexcept { return v.isDouble(); }
 
  Configuration operator[](size_t i) const;
 
  template<typename T>
  T at(size_t i, const T & v) const
  {
    try
    {
      return (*this)[i].convert<T>();
    }
    catch(Exception & exc)
    {
      exc.silence();
      return v;
    }
  }
 
  template<typename T>
  void operator()(const std::string & key, T & v) const
  {
    try
    {
      v = (*this)(key).convert<T>();
    }
    catch(Exception & exc)
    {
      exc.silence();
    }
  }
 
  template<typename T>
  T operator()(const std::string & key, const T & v) const
  {
    try
    {
      return (*this)(key).convert<T>();
    }
    catch(Exception & exc)
    {
      exc.silence();
      return v;
    }
  }
 
  bool operator==(const char * rhs) const;
 
  template<typename T>
  bool operator==(const T & rhs) const
  {
    T lhs = *this;
    return lhs == rhs;
  }
 
  void add_null(const std::string & key);
 
  void add(const std::string & key, bool value);
 
  void add(const std::string & key, int8_t value);
 
  void add(const std::string & key, uint8_t value);
 
  void add(const std::string & key, int16_t value);
 
  void add(const std::string & key, uint16_t value);
 
  void add(const std::string & key, int32_t value);
 
  void add(const std::string & key, uint32_t value);
 
  void add(const std::string & key, int64_t value);
 
  void add(const std::string & key, uint64_t value);
 
  void add(const std::string & key, double value);
 
  void add(const std::string & key, const std::string & value);
 
  void add(const std::string & key, const char * value);
 
  void add(const std::string & key, const Eigen::Vector2d & value);
 
  void add(const std::string & key, const Eigen::Vector3d & value);
 
  void add(const std::string & key, const Eigen::Vector4d & value);
 
  void add(const std::string & key, const Eigen::Vector6d & value);
 
  void add(const std::string & key, const Eigen::VectorXd & value);
 
  void add(const std::string & key, const Eigen::Quaterniond & value);
 
  void add(const std::string & key, const Eigen::Matrix3d & value);
 
  void add(const std::string & key, const Eigen::Matrix6d & value);
 
  void add(const std::string & key, const Eigen::MatrixXd & value);
 
  void add(const std::string & key, const sva::PTransformd & value);
 
  void add(const std::string & key, const sva::ForceVecd & value);
 
  void add(const std::string & key, const sva::MotionVecd & value);
 
  void add(const std::string & key, const sva::ImpedanceVecd & value);
 
  void add(const std::string & key, const Configuration & value);
 
  Configuration add(const std::string & key);
 
  Configuration array(const std::string & key, size_t size = 0);
 
  void push_null();
 
  void push(bool value);
 
  void push(int8_t value);
 
  void push(uint8_t value);
 
  void push(int16_t value);
 
  void push(uint16_t value);
 
  void push(int32_t value);
 
  void push(uint32_t value);
 
  void push(int64_t value);
 
  void push(uint64_t value);
 
  void push(double value);
 
  void push(const std::string & value);
 
  void push(const char * value);
 
  void push(const Eigen::Vector2d & value);
 
  void push(const Eigen::Vector3d & value);
 
  void push(const Eigen::Vector4d & value);
 
  void push(const Eigen::Vector6d & value);
 
  void push(const Eigen::VectorXd & value);
 
  void push(const Eigen::Quaterniond & value);
 
  void push(const Eigen::Matrix3d & value);
 
  void push(const Eigen::Matrix6d & value);
 
  void push(const Eigen::MatrixXd & value);
 
  void push(const sva::PTransformd & value);
 
  void push(const sva::ForceVecd & value);
 
  void push(const sva::MotionVecd & value);
 
  void push(const sva::ImpedanceVecd & value);
 
  void push(const Configuration & value);
 
  Configuration array(size_t reserve = 0);
 
  Configuration object();
 
  template<typename T,
           typename... Args,
           typename std::enable_if<internal::has_configuration_save_object_v<T, Args...>
                                       || internal::has_toConfiguration_method_v<T, Args...>,
                                   int>::type = 0>
  void push(const T & value, Args &&... args)
  {
    if constexpr(internal::has_configuration_save_object_v<T, Args...>)
    {
      push(mc_rtc::ConfigurationLoader<T>::save(value, std::forward<Args>(args)...));
    }
    else
    {
      push(value.toConfiguration(std::forward<Args>(args)...));
    }
  }
 
  template<typename T, typename std::enable_if<internal::is_integral_v<T>, int>::type = 0>
  void push(const T & value)
  {
    if constexpr(internal::is_like_int8_t<T>) { push(static_cast<int8_t>(value)); }
    else if constexpr(internal::is_like_int16_t<T>) { push(static_cast<int16_t>(value)); }
    else if constexpr(internal::is_like_int32_t<T>) { push(static_cast<int32_t>(value)); }
    else if constexpr(internal::is_like_int64_t<T>) { push(static_cast<int64_t>(value)); }
    else if constexpr(internal::is_like_uint8_t<T>) { push(static_cast<uint8_t>(value)); }
    else if constexpr(internal::is_like_uint16_t<T>) { push(static_cast<uint16_t>(value)); }
    else if constexpr(internal::is_like_uint32_t<T>) { push(static_cast<uint32_t>(value)); }
    else if constexpr(internal::is_like_uint64_t<T>) { push(static_cast<uint64_t>(value)); }
    else
    {
      static_assert(!std::is_same_v<T, T>, "T is integral but has an unsupported size");
    }
  }
 
  template<typename T, typename A = std::allocator<T>, typename... Args>
  void add(const std::string & key, const std::vector<T, A> & value, Args &&... args)
  {
    Configuration v = array(key, value.size());
    for(const auto & vi : value) { v.push(vi, std::forward<Args>(args)...); }
  }
 
  template<typename T, std::size_t N, typename... Args>
  void add(const std::string & key, const std::array<T, N> & value, Args &&... args)
  {
    Configuration v = array(key, N);
    for(const auto & vi : value) { v.push(vi, std::forward<Args>(args)...); }
  }
 
  template<typename T1, typename T2, typename... Args>
  void add(const std::string & key, const std::pair<T1, T2> & value, Args &&... args)
  {
    Configuration v = array(key, 2);
    v.push(value.first, std::forward<Args>(args)...);
    v.push(value.second, std::forward<Args>(args)...);
  }
 
  template<typename T,
           class C = std::less<std::string>,
           class A = std::allocator<std::pair<const std::string, T>>,
           typename... Args>
  void add(const std::string & key, const std::map<std::string, T, C, A> & value, Args &&... args)
  {
    Configuration v = add(key);
    for(const auto & el : value) { v.add(el.first, el.second, std::forward<Args>(args)...); }
  }
 
  template<typename T, typename C = std::less<T>, typename A = std::allocator<T>, typename... Args>
  void add(const std::string & key, const std::set<T, C, A> & value, Args &&... args)
  {
    Configuration v = array(key, value.size());
    for(const auto & v : value) { v.push(*v, std::forward<Args>(args)...); }
  }
 
  template<typename T,
           typename H = std::hash<T>,
           typename E = std::equal_to<T>,
           typename A = std::allocator<T>,
           typename... Args>
  void add(const std::string & key, const std::unordered_set<T, H, E, A> & value, Args &&... args)
  {
    Configuration v = array(key, value.size());
    for(const auto & v : value) { v.push(*v, std::forward<Args>(args)...); }
  }
 
  template<typename... Args>
  void add(const std::string & key, const std::variant<Args...> & value)
  {
    Configuration v = array(key, 2);
    v.push(value.index());
    std::visit([&v](const auto & hold) { v.push(hold); }, value);
  }
 
  template<typename T, typename std::enable_if<internal::is_integral_v<T>, int>::type = 0>
  void add(const std::string & key, const T & value)
  {
    if constexpr(internal::is_like_int8_t<T>) { add(key, static_cast<int8_t>(value)); }
    else if constexpr(internal::is_like_int16_t<T>) { add(key, static_cast<int16_t>(value)); }
    else if constexpr(internal::is_like_int32_t<T>) { add(key, static_cast<int32_t>(value)); }
    else if constexpr(internal::is_like_int64_t<T>) { add(key, static_cast<int64_t>(value)); }
    else if constexpr(internal::is_like_uint8_t<T>) { add(key, static_cast<uint8_t>(value)); }
    else if constexpr(internal::is_like_uint16_t<T>) { add(key, static_cast<uint16_t>(value)); }
    else if constexpr(internal::is_like_uint32_t<T>) { add(key, static_cast<uint32_t>(value)); }
    else if constexpr(internal::is_like_uint64_t<T>) { add(key, static_cast<uint64_t>(value)); }
    else
    {
      static_assert(!std::is_same_v<T, T>, "T is integral but has an unsupported size");
    }
  }
 
  template<typename T,
           typename... Args,
           typename std::enable_if<internal::has_configuration_save_object_v<T, Args...>
                                       || internal::has_toConfiguration_method_v<T, Args...>,
                                   int>::type = 0>
  void add(const std::string & key, const T & value, Args &&... args)
  {
    if constexpr(internal::has_configuration_save_object_v<T, Args...>)
    {
      add(key, ConfigurationLoader<T>::save(value, std::forward<Args>(args)...));
    }
    else
    {
      add(key, value.toConfiguration(std::forward<Args>(args)...));
    }
  }
 
  template<typename T, typename A = std::allocator<T>, typename... Args>
  void push(const std::vector<T, A> & value, Args &&... args)
  {
    Configuration v = array(value.size());
    for(const auto & vi : value) { v.push(vi, std::forward<Args>(args)...); }
  }
 
  template<typename T, std::size_t N, typename... Args>
  void push(const std::array<T, N> & value, Args &&... args)
  {
    Configuration v = array(N);
    for(const auto & vi : value) { v.push(vi, std::forward<Args>(args)...); }
  }
 
  template<typename T1, typename T2, typename... Args>
  void push(const std::pair<T1, T2> & value, Args &&... args)
  {
    Configuration v = array(2);
    v.push(value.first, std::forward<Args>(args)...);
    v.push(value.second, std::forward<Args>(args)...);
  }
 
  template<typename T,
           class C = std::less<std::string>,
           class A = std::allocator<std::pair<const std::string, T>>,
           typename... Args>
  void push(const std::map<std::string, T, C, A> & value, Args &&... args)
  {
    Configuration v = object();
    for(const auto & el : value) { v.add(el.first, el.second, std::forward<Args>(args)...); }
  }
 
  template<typename T, typename C = std::less<T>, typename A = std::allocator<T>, typename... Args>
  void push(const std::set<T, C, A> & value, Args &&... args)
  {
    Configuration v = array(value.size());
    for(const auto & v : value) { v.push(*v, std::forward<Args>(args)...); }
  }
 
  template<typename T,
           typename H = std::hash<T>,
           typename E = std::equal_to<T>,
           typename A = std::allocator<T>,
           typename... Args>
  void push(const std::unordered_set<T, H, E, A> & value, Args &&... args)
  {
    Configuration v = array(value.size());
    for(const auto & v : value) { v.push(*v, std::forward<Args>(args)...); }
  }
 
  template<typename... Args>
  void push(const std::variant<Args...> & value)
  {
    Configuration v = array(2);
    v.push(value.index());
    std::visit([&v](const auto & hold) { v.push(hold); }, value);
  }
 
  bool remove(const std::string & key);
 
  std::vector<std::string> keys() const;
 
  ConfigurationArrayIterator begin() const;
 
  ConfigurationArrayIterator end() const;
 
private:
  Json v;
  Configuration(const Json & v);
 
  template<typename T>
  T convert() const
  {
    if constexpr(std::is_same_v<T, Configuration>) { return *this; }
    else
    {
      return this->operator T();
    }
  }
};
 
struct MC_RTC_UTILS_DLLAPI ConfigurationArrayIterator
{
  ConfigurationArrayIterator(const Configuration & conf);
  bool operator!=(const ConfigurationArrayIterator & rhs) const;
  ConfigurationArrayIterator & operator++();
  Configuration operator*();
  const Configuration operator*() const;
  size_t i = 0;
  Configuration conf;
};
 
template<>
void MC_RTC_UTILS_DLLAPI Configuration::operator()(const std::string & key, std::string & v) const;
 
struct MC_RTC_UTILS_DLLAPI ConfigurationFile : public Configuration
{
  ConfigurationFile(const std::string & path);
 
  void reload();
 
  void save() const;
 
  using Configuration::save;
 
  inline const std::string & path() const noexcept { return path_; }
 
private:
  std::string path_;
};
 
#if MC_RTC_USE_VARIANT_WORKAROUND
namespace internal
{
 
template<size_t IDX, typename... Args>
std::variant<Args...> to_variant(const Configuration & c, size_t idx)
{
  // Note: this never happens because we always pass idx < sizeof...(Args)
  if constexpr(IDX >= sizeof...(Args)) { mc_rtc::log::error_and_throw("Invalid runtime index for variant"); }
  else
  {
    if(idx == IDX) { return c.operator std::variant_alternative_t<IDX, std::variant<Args...>>(); }
    else
    {
      return to_variant<IDX + 1, Args...>(c, idx);
    }
  }
}
 
} // namespace internal
#endif
 
} // namespace mc_rtc
 
MC_RTC_UTILS_DLLAPI std::ostream & operator<<(std::ostream & os, const mc_rtc::Configuration & c);
 
namespace fmt
{
 
template<>
struct formatter<mc_rtc::Configuration> : public formatter<string_view>
{
  template<typename FormatContext>
  auto format(const mc_rtc::Configuration & c, FormatContext & ctx) -> decltype(ctx.out())
  {
    return formatter<string_view>::format(static_cast<std::string>(c), ctx);
  }
};
 
} // namespace fmt