Dictionary.h

Go to the documentation of this file.

// SPDX-License-Identifier: Apache-2.0
// Copyright 2022 Stéphane Caron
// Copyright 2024 Inria
/*
 * This file incorporates work covered by the following copyright and
 * permission notice:
 *
 *     Configuration and DataStore classes of mc_rtc
 *     Copyright 2015-2020 CNRS-UM LIRMM, CNRS-AIST JRL
 *     SPDX-License-Identifier: BSD-2-Clause
 */
 
#pragma once
 
#include <spdlog/spdlog.h>
 
#include <Eigen/Core>
#include <functional>
#include <memory>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <utility>
#include <vector>
 
#include "palimpsest/Value.h"
#include "palimpsest/exceptions/TypeError.h"
#include "palimpsest/json/write.h"
#include "palimpsest/mpack/Writer.h"
#include "palimpsest/mpack/read.h"
#include "palimpsest/mpack/write.h"
 
namespace palimpsest {
 
using exceptions::TypeError;
 
class Dictionary {
 public:
  Dictionary() = default;
 
  Dictionary(const Dictionary &) = delete;
 
  Dictionary &operator=(const Dictionary &) = delete;
 
  Dictionary(Dictionary &&) = default;
 
  Dictionary &operator=(Dictionary &&) = default;
 
  ~Dictionary() = default;
 
  bool is_map() const noexcept { return (value_.buffer == nullptr); }
 
  bool is_empty() const noexcept { return (is_map() && map_.size() < 1); }
 
  bool is_value() const noexcept { return (value_.buffer != nullptr); }
 
  bool has(const std::string &key) const noexcept {
    return (map_.find(key) != map_.end());
  }
 
  std::vector<std::string> keys() const noexcept;
 
  std::vector<std::pair<std::string, std::reference_wrapper<const Dictionary>>>
  items() const noexcept;
 
  std::vector<std::reference_wrapper<const Dictionary>> values() const noexcept;
 
  unsigned size() const noexcept { return map_.size(); }
 
  template <typename T>
  T &as() {
    if (!this->is_value()) {
      throw TypeError(__FILE__, __LINE__, "Object is not a value.");
    }
    return value_.get_reference<T>();
  }
 
  template <typename T>
  const T &as() const {
    if (!this->is_value()) {
      throw TypeError(__FILE__, __LINE__, "Object is not a value.");
    }
    return const_cast<const T &>(value_.get_reference<T>());
  }
 
  template <typename T>
  T &get(const std::string &key) {
    return const_cast<T &>(get_<T>(key));
  }
 
  template <typename T>
  const T &get(const std::string &key) const {
    return get_<T>(key);
  }
 
  template <typename T>
  const T &get(const std::string &key, const T &default_value) const {
    auto it = map_.find(key);
    if (it != map_.end()) {
      if (it->second->is_map()) {
        throw TypeError(__FILE__, __LINE__,
                        "Object at key \"" + key +
                            "\" is a dictionary, cannot get a single value "
                            "from it. Did you "
                            "mean to use operator()?");
      }
      try {
        return it->second->value_.get_reference<T>();
      } catch (const TypeError &e) {
        throw TypeError(
            __FILE__, __LINE__,
            "Object for key \"" + key +
                "\" does not have the same type as the stored type. Stored " +
                it->second->value_.type_name() + " but requested " +
                typeid(T).name() + ".");
      }
    }
    return default_value;
  }
 
  template <typename T, typename... ArgsT, typename... Args>
  T &insert(const std::string &key, Args &&...args) {
    if (this->is_value()) {
      throw TypeError(__FILE__, __LINE__,
                      "Cannot insert at key \"" + key +
                          "\" in non-dictionary object of type \"" +
                          value_.type_name() + "\".");
    }
    auto &child = this->operator()(key);
    if (!child.is_empty()) {
      spdlog::warn(
          "[Dictionary::insert] Key \"{}\" already exists. Returning existing "
          "value rather than creating a new one.",
          key);
      return get<T>(key);
    }
    child.value_.allocate<T>();
    new (child.value_.buffer.get()) T(std::forward<Args>(args)...);
    T &ret = child.value_.setup<T, ArgsT...>();
    return ret;
  }
 
  template <typename T>
  T &setdefault(const std::string &key, const T &default_value) {
    if (this->is_value()) {
      throw TypeError(__FILE__, __LINE__,
                      "Cannot insert at key \"" + key +
                          "\" in non-dictionary object of type \"" +
                          value_.type_name() + "\".");
    }
    auto it = map_.find(key);
    if (it != map_.end()) {
      if (it->second->is_map()) {
        throw TypeError(__FILE__, __LINE__,
                        "Object at key \"" + key +
                            "\" is a dictionary, cannot get a single value "
                            "from it. Did you "
                            "mean to use operator()?");
      }
      try {
        return it->second->value_.get_reference<T>();
      } catch (const TypeError &e) {
        throw TypeError(
            __FILE__, __LINE__,
            "Object for key \"" + key +
                "\" does not have the same type as the stored type. Stored " +
                it->second->value_.type_name() + " but requested " +
                typeid(T).name() + ".");
      }
    }
    auto &child = this->operator()(key);
    child.value_.allocate<T>();
    new (child.value_.buffer.get()) T(default_value);
    T &ret = child.value_.setup<T>();
    return ret;
  }
 
  template <typename T>
  Dictionary &operator=(const T &new_value) {
    if (this->is_map()) {
      clear();
    }
    if (this->is_empty()) {
      become<T>(new_value);
      return *this;
    }
    auto &internal_value = value_.get_reference<T>();
    internal_value = new_value;
    return *this;
  }
 
  Dictionary &operator=(const char *c_string) {
    return operator= <std::string>(std::string(c_string));
  }
 
  void remove(const std::string &key) noexcept;
 
  template <typename T>
  T pop(const std::string &key) {
    const T value = get<T>(key);
    remove(key);
    return value;
  }
 
  template <typename T>
  T pop(const std::string &key, const T &default_value) {
    auto it = map_.find(key);
    if (it == map_.end()) {
      return default_value;
    }
    if (it->second->is_map()) {
      throw TypeError(__FILE__, __LINE__,
                      "Object at key \"" + key +
                          "\" is a dictionary, cannot pop a single value "
                          "from it.");
    }
    try {
      const T value = it->second->value_.get_reference<T>();
      remove(key);
      return value;
    } catch (const TypeError &e) {
      throw TypeError(
          __FILE__, __LINE__,
          "Object for key \"" + key +
              "\" does not have the same type as the requested type. Stored " +
              it->second->value_.type_name() + " but requested " +
              typeid(T).name() + ".");
    }
  }
 
  std::pair<std::string, Dictionary> popitem();
 
  void clear() noexcept;
 
  Dictionary &operator()(const std::string &key);
 
  const Dictionary &operator()(const std::string &key) const;
 
  static Dictionary deepcopy(const Dictionary &other);
 
  template <typename Container, typename T>
  static Dictionary fromkeys(const Container &keys, const T &value) {
    Dictionary result;
    for (const auto &key : keys) {
      result(key) = value;
    }
    return result;
  }
 
  template <typename Container>
  static Dictionary fromkeys(const Container &keys) {
    Dictionary result;
    for (const auto &key : keys) {
      result(key);  // Create empty dictionary for each key
    }
    return result;
  }
 
  size_t serialize(std::vector<char> &buffer) const;
 
  void write(const std::string &filename) const;
 
  void read(const std::string &filename);
 
  void update(const Dictionary &other);
 
  void deserialize(const char *data, size_t size);
 
  Dictionary difference(const Dictionary &other) const;
 
  operator bool &() { return this->as<bool>(); }
 
  operator const bool &() const { return this->as<bool>(); }
 
  operator int8_t &() { return this->as<int8_t>(); }
 
  operator const int8_t &() const { return this->as<int8_t>(); }
 
  operator int16_t &() { return this->as<int16_t>(); }
 
  operator const int16_t &() const { return this->as<int16_t>(); }
 
  operator int32_t &() { return this->as<int32_t>(); }
 
  operator const int32_t &() const { return this->as<int32_t>(); }
 
  operator int64_t &() { return this->as<int64_t>(); }
 
  operator const int64_t &() const { return this->as<int64_t>(); }
 
  operator uint8_t &() { return this->as<uint8_t>(); }
 
  operator const uint8_t &() const { return this->as<uint8_t>(); }
 
  operator uint16_t &() { return this->as<uint16_t>(); }
 
  operator const uint16_t &() const { return this->as<uint16_t>(); }
 
  operator uint32_t &() { return this->as<uint32_t>(); }
 
  operator const uint32_t &() const { return this->as<uint32_t>(); }
 
  operator uint64_t &() { return this->as<uint64_t>(); }
 
  operator const uint64_t &() const { return this->as<uint64_t>(); }
 
  operator float &() { return this->as<float>(); }
 
  operator const float &() const { return this->as<float>(); }
 
  operator double &() { return this->as<double>(); }
 
  operator const double &() const { return this->as<double>(); }
 
  operator std::string &() { return this->as<std::string>(); }
 
  operator const std::string &() const { return this->as<std::string>(); }
 
  operator Eigen::Vector2d &() { return this->as<Eigen::Vector2d>(); }
 
  operator const Eigen::Vector2d &() const {
    return this->as<Eigen::Vector2d>();
  }
 
  operator Eigen::Vector3d &() { return this->as<Eigen::Vector3d>(); }
 
  operator const Eigen::Vector3d &() const {
    return this->as<Eigen::Vector3d>();
  }
 
  operator Eigen::VectorXd &() { return this->as<Eigen::VectorXd>(); }
 
  operator const Eigen::VectorXd &() const {
    return this->as<Eigen::VectorXd>();
  }
 
  operator Eigen::Quaterniond &() { return this->as<Eigen::Quaterniond>(); }
 
  operator const Eigen::Quaterniond &() const {
    return this->as<Eigen::Quaterniond>();
  }
 
  operator Eigen::Matrix3d &() { return this->as<Eigen::Matrix3d>(); }
 
  operator const Eigen::Matrix3d &() const {
    return this->as<Eigen::Matrix3d>();
  }
 
  friend std::ostream &operator<<(std::ostream &stream, const Dictionary &dict);
 
 protected:
  template <typename T, typename... ArgsT, typename... Args>
  void become(Args &&...args) {
    assert(this->is_empty());
    value_.allocate<T>();
    new (value_.buffer.get()) T(std::forward<Args>(args)...);
    value_.setup<T, ArgsT...>();
  }
 
 private:
  void deserialize_(mpack_node_t node);
 
  template <typename T>
  const T &get_(const std::string &key) const {
    const auto &child_value = get_child_value_(key);
    try {
      return child_value.get_reference<T>();
    } catch (const TypeError &e) {
      throw TypeError(__FILE__, __LINE__,
                      "Object at key \"" + key + "\" has type \"" +
                          child_value.type_name() +
                          "\", but is being cast to type \"" +
                          typeid(T).name() + "\".");
    }
  }
 
  const Value &get_child_value_(const std::string &key) const;
 
  void insert_at_key_(const std::string &key, const mpack_node_t &value);
 
  void serialize_(mpack::Writer &writer) const;
 
 protected:
  Value value_;
 
  std::unordered_map<std::string, std::unique_ptr<Dictionary>> map_;
};
 
}  // namespace palimpsest
 
#include "palimpsest/internal/fmt_formatter.h"