cpp-reflection/include/reflection/reflection.h

#pragma once

#include <functional>
#include <stdexcept>
#include <string>
#include <type_traits>
#include <utility>

#include "reflection/forward.h"
#include "reflection/object.h"
#include "reflection/proxy.h"

#define REFLECTION(expr)                                                       \
  [=](Obj & obj, std::string name) { return Object(expr, std::move(name)); }
#define CONST_REFLECTION(expr)                                                 \
  [=](Obj const & obj, std::string name) {                                     \
    return Object(expr, std::move(name));                                      \
  }

namespace reflection {

template <typename T>
constexpr auto is_final_reflection =
    std::is_same_v<T, std::string> || std::is_fundamental_v<T> || std::is_enum_v<T>;

template <typename Obj, typename> class Reflection {
public:
  operator bool() const { return true; }

  static Getter<Obj> getter(std::string_view id) {
    if (auto it = const_members_.find(id); it != const_members_.end()) {
      return it->second;
    }
    throw std::out_of_range("no id in reflection");
  }

  static Accessor<Obj> accessor(std::string_view id) {
    if (auto it = members_.find(id); it != members_.end()) {
      return it->second;
    }
    throw std::out_of_range("no id in reflection");
  }

  template <typename R, typename I>
  Reflection & bind(std::string_view id, R (Obj::*get)() const,
                    void (Obj::*set)(I)) {
    using V = std::decay_t<R>;
    members_.emplace(id, REFLECTION(Proxy<V>(obj, get, set)));
    const_members_.emplace(id, CONST_REFLECTION((obj.*get)()));
    return *this;
  }
  
  template <typename R>
  Reflection & bind(std::string_view id, R (Obj::*get)() const,
                    std::decay_t<R> &(Obj::*acc)()) {
    members_.emplace(id, REFLECTION((obj.*acc)()));
    const_members_.emplace(id, CONST_REFLECTION((obj.*get)()));
    return *this;
  }
  
  template <typename T>
  Reflection & bind(std::string_view id, T (Obj::*get)() const) {
    const_members_.emplace(id, CONST_REFLECTION((obj.*get)()));
    return *this;
  }

  template <typename T> Reflection & bind(std::string_view id, T Obj::*member) {
    members_.emplace(id, REFLECTION(obj.*member));
    const_members_.emplace(id, CONST_REFLECTION(obj.*member));
    return *this;
  }

  template <typename F> Reflection & bind(std::string_view id, F func) {
    if constexpr (!std::is_const_v<decltype(func(std::declval<Obj &>()))>) {
      members_.emplace(id, REFLECTION(func(obj)));
    } else {
      members_.emplace(id, CONST_REFLECTION(func(obj)));
    }
    const_members_.emplace(id, CONST_REFLECTION(func(obj)));
    return *this;
  }

  template <typename R, typename T>
  Reflection & bind(std::string_view id, T Obj::*member) {
    if constexpr (std::is_convertible_v<T, R>) {
      return bind(id, member, [](T const &v) { return static_cast<R>(v); });
    } else {
      return bind(id, member, TypeConversion<R, T>());
    }
  }
  
  template <typename R, typename T>
  Reflection & bind(std::string_view id, T (Obj::*get)() const) {
    if constexpr (std::is_convertible_v<T, R>) {
      return bind(id, get, [](T const &v) { return static_cast<R>(v); });
    } else {
      return bind(id, get, TypeConversion<R, T>());
    }
  }
  
  template <typename T, typename F>
  Reflection & bind(std::string_view id, T Obj::*member, F convert) {
    members_.emplace(id, CONST_REFLECTION(convert(obj.*member)));
    const_members_.emplace(id, CONST_REFLECTION(convert(obj.*member)));
    return *this;
  }
  
  template <typename T, typename F>
  Reflection & bind(std::string_view id, T (Obj::*get)() const, F convert) {
    members_.emplace(id, CONST_REFLECTION(convert((obj.*get)())));
    const_members_.emplace(id, CONST_REFLECTION(convert((obj.*get)())));
    return *this;
  }

private:
  static Cache<Accessor<Obj>> members_;
  static Cache<Getter<Obj>> const_members_;
};

template <typename T>
class Reflection<T, std::enable_if_t<is_final_reflection<T>>> {
public:
  static Getter<T> getter(std::string_view) {
    throw std::logic_error("unreflectable");
  }
  static Accessor<T> accessor(std::string_view) {
    throw std::logic_error("unreflectable");
  }
};

template <typename T> class Reflection<T *> {
public:
  static auto getter(std::string_view id) {
    return [f = Reflection<T>::getter(id)](T const * ptr, std::string name) {
      return f(*ptr, std::move(name));
    };
  }

  static auto accessor(std::string_view id) {
    return [f = Reflection<T>::accessor(id)](T * ptr, std::string name) {
      return f(*ptr, std::move(name));
    };
  }
};

template <typename Obj, typename Void>
Cache<Accessor<Obj>> Reflection<Obj, Void>::members_;
template <typename Obj, typename Void>
Cache<Getter<Obj>> Reflection<Obj, Void>::const_members_;
}