reflect.hpp

 
#pragma once
 
#include "toast/uid.hpp"
 
#include <any>
#include <cassert>
#include <cstdint>
#include <nlohmann/json.hpp>
#include <optional>
#include <span>
#include <string>
#include <string_view>
#include <toast/events/signal_types.hpp>
#include <toast/export.hpp>
#include <toast/log.hpp>
#include <toast/world/box.hpp>
#include <type_traits>
#include <typeinfo>
#include <utility>
 
namespace toast {
 
class Node;

enum class FieldType : uint8_t {
  bool_t,
  int_t,
  float_t,
  string_t,
  double_t,
  uid_t,
  vec2_t,
  vec3_t,
  vec4_t,
  quaternion_t,
};
 
struct TOAST_API SignalInfo {
  using SignalGetterPtr = std::vector<signals::ConnectionInfo> (*)(void*);
  using SignalConnectPtr = void (*)(void*, Node&, std::string_view, signals::ConnectionSource, bool);
  using SignalDisconnectPtr = void (*)(void*, Node&, std::string_view, signals::ConnectionSource);
  using SignalClearPtr = void (*)(void*, signals::ConnectionSource);
  using SignalFirePtr = bool (*)(void*, std::span<const std::any>);
 
  std::string_view name;
  std::string_view type;
  std::vector<const std::type_info*> args;
  nlohmann::json attributes;
 
  SignalGetterPtr get;
  SignalConnectPtr connect;
  SignalDisconnectPtr disconnect;
  SignalClearPtr clear;
  SignalFirePtr fire;
};

struct TOAST_API FieldInfo {
  using FieldGetterPtr = std::any (*)(void*);
  using FieldSetterPtr = void (*)(void*, std::any);
 
  std::string_view name;
  std::string_view type;    // C++ type name
  FieldType value_type;     // serialization kind
  nlohmann::json attributes;
  bool is_array = false;    // True if field is vector
 
  FieldGetterPtr get;
  FieldSetterPtr set;

  [[nodiscard]]
  auto attributeMap() const -> const nlohmann::json* {
    if (attributes.is_object()) {
      return &attributes;
    }
    if (attributes.is_array() && attributes.size() == 1 && attributes.front().is_object()) {
      return &attributes.front();
    }
    return nullptr;
  }

  [[nodiscard]]
  auto groupName() const -> std::string {
    return getAttribute("Group");
  }

  [[nodiscard]]
  auto hasAttribute(std::string_view attr_name) const -> bool {
    const auto* map = attributeMap();
    return map != nullptr && map->contains(std::string(attr_name));
  }

  [[nodiscard]]
  auto getAttribute(std::string_view attr_name) const -> std::string {
    const auto* map = attributeMap();
    if (map == nullptr) {
      return "";
    }
    auto it = map->find(std::string(attr_name));
    if (it == map->end() || !it->is_array() || it->empty()) {
      return "";
    }
    return it->at(0).get<std::string>();
  }
};

struct TOAST_API ParameterInfo {
  std::string_view name;
  std::string_view type;            // C++ type name, as spelled in the header
  std::optional<std::string_view> default_value;
  const std::type_info* type_id;    // typeid(std::decay_t<param>), for call-time validation
};

struct TOAST_API FunctionInfo {
  using Invoker = void (*)();

  using DynamicInvoker = std::any (*)(void* obj, std::span<const std::any> args);
 
  std::string_view name;
  std::string_view return_type;            // C++ return type name, as spelled in the header
  const std::type_info* return_type_id;    // typeid(std::decay_t<return>), for call-time validation
  std::span<const ParameterInfo> parameters;
  nlohmann::json attributes;
  Invoker invoke = nullptr;
  DynamicInvoker invoke_dynamic = nullptr;
 
  [[nodiscard]]
  auto attributeMap() const -> const nlohmann::json* {
    if (attributes.is_object()) {
      return &attributes;
    }
    if (attributes.is_array() && attributes.size() == 1 && attributes.front().is_object()) {
      return &attributes.front();
    }
    return nullptr;
  }
 
  [[nodiscard]]
  auto hasAttribute(std::string_view attr_name) const -> bool {
    const auto* map = attributeMap();
    return map != nullptr && map->contains(std::string(attr_name));
  }
 
  [[nodiscard]]
  auto getAttribute(std::string_view attr_name) const -> std::string {
    const auto* map = attributeMap();
    if (map == nullptr) {
      return "";
    }
    auto it = map->find(std::string(attr_name));
    if (it == map->end() || !it->is_array() || it->empty()) {
      return "";
    }
    return it->at(0).get<std::string>();
  }
 
  template<typename R = void, typename... Args>
  auto call(void* obj, Args&&... args) const -> R {
    bool signature_ok =
        parameters.size() == sizeof...(Args) && return_type_id != nullptr && *return_type_id == typeid(std::decay_t<R>);
    if (signature_ok) {
      const std::array<const std::type_info*, sizeof...(Args)> expected = {&typeid(std::decay_t<Args>)...};
      for (std::size_t i = 0; i < expected.size(); ++i) {
        if (parameters[i].type_id == nullptr || *parameters[i].type_id != *expected[i]) {
          signature_ok = false;
          break;
        }
      }
    }
    if (!signature_ok) {
      TOAST_WARN("Reflect", "call(): signature mismatch for '{}'; invoking is undefined behavior", name);
      assert(false && "FunctionInfo::call(): argument or return type mismatch");
    }
 
    using Trampoline = R (*)(void*, std::decay_t<Args>...);
    auto* trampoline = reinterpret_cast<Trampoline>(invoke);
    return trampoline(obj, std::forward<Args>(args)...);
  }

  [[nodiscard]]
  auto callDynamic(void* obj, std::span<const std::any> args) const -> std::any {
    if (!invoke_dynamic) {
      TOAST_WARN("Reflect", "callDynamic(): no dynamic invoker for '{}' (was it compiled with an older generator?)", name);
      return {};
    }
    return invoke_dynamic(obj, args);
  }
};
 
template<class T>
class Reflect;

namespace _detail {
template<typename Tag>
struct Accessor {
  inline static typename Tag::type member;
};
 
template<typename Tag, typename Tag::type Ptr>
struct Robber {
  Robber() { Accessor<Tag>::member = Ptr; }
 
  static Robber instance;
};
 
template<typename Tag, typename Tag::type Ptr>
Robber<Tag, Ptr> Robber<Tag, Ptr>::instance;
}

template<class Class, typename FieldType, typename Tag>
struct FieldAccess {
  static auto get(void* obj) -> std::any { return static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member; }
 
  static void set(void* obj, std::any value) {
    if (auto* typed = std::any_cast<FieldType>(&value)) {
      static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member = *typed;
      return;
    }
 
    // HACK: Try integer type conversion if exact match fails
    if constexpr (std::is_integral_v<FieldType>) {
      const auto& type_info = value.type();
      if (type_info == typeid(int)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member = static_cast<FieldType>(std::any_cast<int>(value));
      } else if (type_info == typeid(unsigned int)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member =
            static_cast<FieldType>(std::any_cast<unsigned int>(value));
      } else if (type_info == typeid(long)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member = static_cast<FieldType>(std::any_cast<long>(value));
      } else if (type_info == typeid(unsigned long)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member =
            static_cast<FieldType>(std::any_cast<unsigned long>(value));
      } else if (type_info == typeid(short)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member = static_cast<FieldType>(std::any_cast<short>(value));
      } else if (type_info == typeid(unsigned short)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member =
            static_cast<FieldType>(std::any_cast<unsigned short>(value));
      } else if (type_info == typeid(char)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member = static_cast<FieldType>(std::any_cast<char>(value));
      } else if (type_info == typeid(unsigned char)) {
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member =
            static_cast<FieldType>(std::any_cast<unsigned char>(value));
      }
    }
  }
};

template<class Class, typename FieldType, typename Tag>
struct EnumFieldAccess {
  static auto get(void* obj) -> std::any {
    if constexpr (std::is_enum_v<FieldType>) {
      using Underlying = std::underlying_type_t<FieldType>;
      const Underlying value = static_cast<Underlying>(static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member);
      if constexpr (std::is_signed_v<Underlying>) {
        return std::any {static_cast<int64_t>(value)};
      } else {
        return std::any {static_cast<uint64_t>(value)};
      }
    } else {
      return FieldAccess<Class, FieldType, Tag>::get(obj);
    }
  }
 
  static void set(void* obj, std::any value) {
    if constexpr (std::is_enum_v<FieldType>) {
      auto assign = [obj](auto numeric) {
        using Underlying = std::underlying_type_t<FieldType>;
        static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member =
            static_cast<FieldType>(static_cast<Underlying>(numeric));
      };
 
      if (const auto* v = std::any_cast<int>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<unsigned int>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<int64_t>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<uint64_t>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<long>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<unsigned long>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<short>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<unsigned short>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<char>(&value)) {
        assign(*v);
      } else if (const auto* v = std::any_cast<unsigned char>(&value)) {
        assign(*v);
      }
    } else {
      FieldAccess<Class, FieldType, Tag>::set(obj, std::move(value));
    }
  }
};

template<class Class, typename T, typename Tag>
struct FieldAccess<Class, Box<T>, Tag> {
  static auto get(void* obj) -> std::any {
    Box<T>& src = static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member;
    return std::any {Box<Node>(src)};
  }
 
  static void set(void* obj, std::any value) {
    if (auto* box = std::any_cast<Box<Node>>(&value)) {
      static_cast<Class*>(obj)->*_detail::template Accessor<Tag>::member = box->as<T>();
    }
  }
};
 
}