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/exceptions/TypeError.h"
#include "palimpsest/internal/Allocator.h"
#include "palimpsest/internal/is_valid_hash.h"
#include "palimpsest/internal/type_name.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 {
  class Value {
   public:
    Value() = default;
 
    Value(const Value &) = delete;
 
    Value &operator=(const Value &) = delete;
 
    Value(Value &&) = default;
 
    Value &operator=(Value &&) = default;
 
    ~Value() {
      if (this->buffer) {
        destroy_(*this);
      }
    }
 
    template <typename T>
    void allocate() {
      this->buffer.reset(
          reinterpret_cast<uint8_t *>(internal::Allocator<T>().allocate(1)));
    }
 
    void deserialize(mpack_node_t node) { deserialize_(*this, node); }
 
    void print(std::ostream &stream) const { print_(*this, stream); }
 
    void serialize(mpack::Writer &writer) const {
      serialize_(*this, writer.mpack_writer());
    }
 
    template <typename T, typename... ArgsT>
    T &setup() {
      this->type_name = &internal::type_name<T>;
      this->same = &internal::is_valid_hash<T, ArgsT...>;
      deserialize_ = [](Value &self, mpack_node_t node) {
        T *cast_buffer = reinterpret_cast<T *>(self.buffer.get());
        mpack::read<T>(node, *cast_buffer);
      };
      destroy_ = [](Value &self) {
        T *p = reinterpret_cast<T *>(self.buffer.release());
        p->~T();
        internal::Allocator<T>().deallocate(p, 1);
      };
      print_ = [](const Value &self, std::ostream &stream) {
        const T *cast_buffer = reinterpret_cast<const T *>(self.buffer.get());
        json::write<T>(stream, *cast_buffer);
      };
      serialize_ = [](const Value &self, mpack_writer_t *writer) {
        const T *cast_buffer = reinterpret_cast<const T *>(self.buffer.get());
        mpack::write<T>(writer, *cast_buffer);
      };
      return *(reinterpret_cast<T *>(this->buffer.get()));
    }
 
    template <typename T>
    T &get_reference() const {
      if (!this->same(typeid(T).hash_code())) {
        std::string cast_type = this->type_name();
        throw TypeError(__FILE__, __LINE__,
                        "Object has type \"" + cast_type +
                            "\" but is being cast to type \"" +
                            typeid(T).name() + "\".");
      }
      return *(reinterpret_cast<T *>(this->buffer.get()));
    }
 
   public:
    std::unique_ptr<uint8_t[]> buffer = nullptr;
 
    const char *(*type_name)();
 
    bool (*same)(std::size_t);
 
   private:
    void (*deserialize_)(Value &, mpack_node_t);
 
    void (*destroy_)(Value &);
 
    void (*print_)(const Value &, std::ostream &);
 
    void (*serialize_)(const Value &, mpack_writer_t *);
  };
 
 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;
 
  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>
  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;
 
  void clear() noexcept;
 
  Dictionary &operator()(const std::string &key);
 
  const Dictionary &operator()(const std::string &key) const;
 
  size_t serialize(std::vector<char> &buffer) const;
 
  void write(const std::string &filename) const;
 
  void read(const std::string &filename);
 
  void update(const char *data, size_t size);
 
  void update(mpack_node_t node);
 
  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:
  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
 
namespace fmt {
 
template <>
struct formatter<palimpsest::Dictionary> : public formatter<string_view> {
  template <typename FormatContext>
  auto format(const palimpsest::Dictionary &dict, FormatContext &ctx)
      -> decltype(ctx.out()) {
    std::ostringstream oss;
    oss << dict;
    return formatter<string_view>::format(oss.str(), ctx);
  }
};
 
}  // namespace fmt