cpp-reflection/include/reflection/object.h

//
//  object.h
//  reflection
//
//  Created by Sam Jaffe on 7/3/22.
//  Copyright © 2022 Sam Jaffe. All rights reserved.
//

#pragma once

#include <stdexcept>
#include <typeindex>
#include <utility>

#include "reflection/forward.h"

namespace reflection {
class Object {
public:
  template <typename T> Object(T const & data, std::string name = "this");
  template <typename T> Object(T & data, std::string name = "this");
  template <typename T> Object(T && data, std::string name = "this");
  template <typename T> Object(Proxy<T> data, std::string name = "this");

  Object own() const { return clone_(*this); }

  std::string_view name() const {
    return std::string_view(name_).substr(name_.rfind('.') + 1);
  }
  std::string_view path() const { return name_; }
  char const * type() const { return type_.name(); }

  template <typename T> bool is_a() const { return type_ == typeid(T); }

  template <typename T> operator T &() const & { return cast<T &>(); }
  template <typename T> operator T const &() const & {
    return cast<T const &>();
  }
  template <typename T> operator T() && {
    return is_a<T>() ? std::move(cast<T &>()) : cast<T const &>();
  }

  Object get(std::string_view id) & { return (this->*get_)(id); }
  Object get(std::string_view id) const & { return (this->*get_)(id); }
  Object get(std::string_view id) && { return (this->*get_)(id).own(); }

  template <typename C,
            typename = std::enable_if_t<std::is_constructible_v<
                std::string_view, decltype(*std::begin(std::declval<C>()))>>>
  Object get(C const & container) const {
    return get(*this, std::begin(container), std::end(container));
  }

private:
  template <typename It> static Object get(Object o, It it, It const end) {
    for (; it != end; ++it) {
      o = std::move(o).get(*it);
    }
    return o;
  }

  template <typename T> T cast() const {
    // Why can we decay this away?
    using V = std::remove_const_t<std::remove_reference_t<T>>;
    // 1) typeid does not respect const
    if (!is_a<V>()) { throw std::bad_cast(); }
    // 2) We guard against using mutable-reference on immutable Object here
    if (std::is_same_v<T, V &> && const_) { throw std::bad_cast(); }
    // 3) Proxy always contains mutable data
    if (proxy_) { return T(*std::static_pointer_cast<Proxy<V>>(data_)); }
    // 4) The const will be re-added by type coercion
    return *std::static_pointer_cast<V>(data_);
  }

  template <typename T> Object getter(std::string_view id) const;
  template <typename T> Object accessor(std::string_view id) const;
  template <typename T> static Object deep(Object const & obj) {
    return Object(obj.cast<T>(), obj.name_);
  }

private:
  std::type_index type_; //
  std::string name_;     // The property name as a dot-separated path
  bool proxy_{
      false}; // Are we using a proxy class to store non-trivial setter behavior
  bool const_; // Is the object immutable (const-ref or rvalue)
  std::shared_ptr<void> data_;
  Object (Object::*get_)(std::string_view) const;
  Object (*clone_)(Object const &) = [](Object const & obj) { return obj; };
};
}

#include "reflection/reflection.h"

namespace reflection {
template <typename T> Object Object::getter(std::string_view id) const {
  return Reflection<T>::getter(id)(cast<T const &>(),
                                   name_ + "." + std::string(id));
}

template <typename T> Object Object::accessor(std::string_view id) const {
  return Reflection<T>::accessor(id)(cast<T &>(),
                                     name_ + "." + std::string(id));
}

template <typename T>
Object::Object(T const & data, std::string name)
    : type_(typeid(T)), name_(std::move(name)), const_(true),
      data_(const_cast<T *>(&data), [](auto *) {}), get_(&Object::getter<T>) {}

template <typename T>
Object::Object(T & data, std::string name)
    : type_(typeid(T)), name_(std::move(name)), const_(false),
      data_(&data, [](auto *) {}), get_(&Object::accessor<T>) {}

template <typename T>
Object::Object(T && data, std::string name)
    : type_(typeid(T)), name_(std::move(name)), const_(true),
      data_(std::make_shared<T>(std::move(data))), get_(&Object::getter<T>),
      clone_(&Object::deep<T>) {}

template <typename T>
Object::Object(Proxy<T> data, std::string name)
    : type_(typeid(T)), name_(std::move(name)), proxy_(true), const_(false),
      data_(std::make_shared<Proxy<T>>(std::move(data))),
      get_(&Object::getter<T>) {}
}