data_value.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <any>
#include <glm/vec2.hpp>
#include <glm/vec3.hpp>
#include <glm/vec4.hpp>
#include <map>
#include <nlohmann/json.hpp>
#include <optional>
#include <string>
#include <toast/export.hpp>
#include <toast/log.hpp>
#include <toast/uid.hpp>
#include <toml++/toml.hpp>
#include <vector>
 
using json_t = nlohmann::json;
 
namespace assets {
 
enum class DataType : uint8_t {
  null,        // empty
  bool_t,      // bool
  int_t,       // int64_t
  float_t,     // double
  string_t,    // std::string
  node_t,      // toast::UID
  asset_t,     // toast::UID
  vec2_t,      // glm::vec2
  vec3_t,      // glm::vec3
  color3_t,    // glm::vec3
  color4_t,    // glm::vec4
  array_t,     // std::vector<DataValue>
  object_t,    // DataValue::ObjectMap
};
 
struct SchemaField;

class TOAST_API DataValue {
public:
  using ObjectMap = std::vector<std::pair<std::string, DataValue>>;
  using Array = std::vector<DataValue>;
 
  DataValue() = default;
 
  explicit DataValue(bool v) : m_type(DataType::bool_t), m_value(v) { }
 
  explicit DataValue(int64_t v) : m_type(DataType::int_t), m_value(v) { }
 
  explicit DataValue(double v) : m_type(DataType::float_t), m_value(v) { }
 
  explicit DataValue(std::string v) : m_type(DataType::string_t), m_value(std::move(v)) { }
 
  DataValue(toast::UID v, DataType kind) : m_type(kind), m_value(v) {
    TOAST_ASSERT(
        kind == DataType::node_t || kind == DataType::asset_t, "DataValue", "UID constructor requires Node or Asset DataType"
    );
  }
 
  explicit DataValue(glm::vec2 v) : m_type(DataType::vec2_t), m_value(v) { }
 
  DataValue(glm::vec3 v, DataType kind) : m_type(kind), m_value(v) {
    TOAST_ASSERT(
        kind == DataType::vec3_t || kind == DataType::color3_t, "DataValue", "vec3 constructor requires Vec3 or Color3 DataType"
    );
  }
 
  explicit DataValue(glm::vec4 v) : m_type(DataType::color4_t), m_value(v) { }
 
  static auto makeArray() -> DataValue;
  static auto makeObject() -> DataValue;
 
  [[nodiscard]]
  auto type() const noexcept -> DataType {
    return m_type;
  }
 
  [[nodiscard]]
  auto isNull() const noexcept -> bool {
    return m_type == DataType::null;
  }
 
  [[nodiscard]]
  auto isArray() const noexcept -> bool {
    return m_type == DataType::array_t;
  }
 
  [[nodiscard]]
  auto isObject() const noexcept -> bool {
    return m_type == DataType::object_t;
  }
 
  template<class T>
  [[nodiscard]]
  auto as() const -> T {
    TOAST_ASSERT(m_value.has_value(), "DataValue", "as<T>() called on a Null DataValue");
    if constexpr (std::is_same_v<T, std::string_view>) {
      // Strings are stored as std::string; the view points into it and lives as long as this DataValue
      if (const auto* str = std::any_cast<std::string>(&m_value)) {
        return T {*str};
      }
    } else if constexpr (std::is_same_v<T, float>) {
      if (const auto* ptr = std::any_cast<float>(&m_value)) {
        return *ptr;
      }
      if (const auto* ptr = std::any_cast<double>(&m_value)) {
        return static_cast<float>(*ptr);
      }
    } else if (const T* ptr = std::any_cast<T>(&m_value)) {
      return *ptr;
    }
    TOAST_ASSERT(
        false,
        "DataValue",
        "Type mismatch in DataValue::as<{}>(): requested '{}', but m_value contains '{}'",
        typeid(T).name(),
        typeid(T).name(),
        m_value.type().name()
    );
    return T {};
  }
 
  template<class T>
  [[nodiscard]]
  auto value() const -> std::optional<T> {
    if (!m_value.has_value()) {
      return std::nullopt;
    }
    if (const T* ptr = std::any_cast<T>(&m_value)) {
      return *ptr;
    }
    TOAST_WARN("DataValue", "Type mismatch in DataValue::value<T>()");
    return std::nullopt;
  }
 
  explicit operator bool() const;
  explicit operator int64_t() const;
  explicit operator int() const;
  explicit operator float() const;
  explicit operator double() const;
  explicit operator std::string() const;
  explicit operator toast::UID() const;
  explicit operator glm::vec2() const;
  explicit operator glm::vec3() const;
  explicit operator glm::vec4() const;
 
  auto operator[](std::string_view key) -> DataValue&;
  auto operator[](std::string_view key) const -> const DataValue&;
 
  [[nodiscard]]
  auto contains(std::string_view key) const noexcept -> bool;
 
  auto operator[](size_t index) -> DataValue&;
  auto operator[](size_t index) const -> const DataValue&;
 
  [[nodiscard]]
  auto size() const noexcept -> size_t;
 
  [[nodiscard]]
  auto empty() const noexcept -> bool {
    return size() == 0;
  }
 
  void push(DataValue v);                    
  void set(std::string key, DataValue v);    
  void remove(std::string_view key);         
 
  [[nodiscard]]
  auto items() -> ObjectMap&;
  [[nodiscard]]
  auto items() const -> const ObjectMap&;
 
  auto operator=(bool v) -> DataValue&;
  auto operator=(int64_t v) -> DataValue&;
  auto operator=(int v) -> DataValue&;
  auto operator=(double v) -> DataValue&;
  auto operator=(float v) -> DataValue&;
  auto operator=(std::string v) -> DataValue&;

  static auto fromToml(const toml::node& n, const SchemaField* field, const toml::table* root = nullptr) -> DataValue;

  static auto fromObject(const toml::table& t, const std::vector<SchemaField>& fields, const toml::table* root = nullptr)
      -> DataValue;

  void appendTo(toml::table& tbl, const std::string& key) const;

  void appendTo(toml::array& arr) const;

  [[nodiscard]]
  auto asTomlTable() const -> toml::table;
 
  // used as the intermediate for BSON
  [[nodiscard]]
  auto toJson() const -> json_t;

  static auto fromJson(const json_t& j, DataType hint = DataType::null) -> DataValue;
 
private:
  DataType m_type {DataType::null};
  std::any m_value;
};
 
}