js_proxy_object_detail.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_JS_PROXY_OBJECT_DETAIL_HPP
#define MOLYBDEN_JS_PROXY_OBJECT_DETAIL_HPP
 
#include <cassert>
#include "molybden/js/js_proxy_object.hpp"
 
#include <memory>
#include <type_traits>
 
#include "molybden/base/rtti.hpp"
 
namespace molybden {
namespace internal {
 
template <class>
struct sfinae_true : std::true_type {};
 
template <class C, class T>
class CustomDowncastDefined {
  // This overloaded method will only compile if the downcast method exists.
  template <typename U>
  static sfinae_true<decltype(U::downcast(std::shared_ptr<C>{}))> test(int);
 
  // This overloaded method has lower priority because `0` is best-matched as
  // `int` and that's why it is compiled only if the first alternative won't.
  template <typename U>
  static std::false_type test(long);
 
  // The compile-time bool parameter is required to allow conditional
  // compilation of this method. If compiled when the downcast method does not
  // exist, compilation of the type trait would cause error instead of having
  // the value equal to `false`.
  static constexpr bool isReturnTypeCorrect(std::true_type type) {
    using bool_type = std::integral_constant<
        bool,
        std::is_same<std::shared_ptr<T>,
                     decltype(T::downcast(std::shared_ptr<C>{}))>::value>;
    static_assert(bool_type::value,
                  "The return value of the downcast method of the class T must "
                  "be of type std::shared_ptr<T>");
    return bool_type::value;
  }
 
  static constexpr bool isReturnTypeCorrect(std::false_type) { return false; }
 
 public:
  static constexpr bool value() {
    using bool_type = decltype(test<T>(0));
 
    return bool_type::value && isReturnTypeCorrect(bool_type());
  }
 
  using BoolType = std::integral_constant<bool, value()>;
};
 
template <class C, bool rtti = RTTI::Enabled()>
class ProxyDowncaster;
 
template <class C>
class ProxyDowncaster<C, true> {
  template <class T>
  static std::shared_ptr<T> downcastImpl(std::shared_ptr<C> object,
                                         std::false_type) {
    return std::dynamic_pointer_cast<T>(std::move(object));
  }
 
  template <class T>
  static std::shared_ptr<T> downcastImpl(std::shared_ptr<C> object,
                                         std::true_type) {
    return T::downcast(std::move(object));
  }
 
 public:
  template <class T>
  static std::shared_ptr<T> downcast(std::shared_ptr<C> object) {
    auto return_value = downcastImpl<T>(
        object,
        typename CustomDowncastDefined<C, T>::BoolType());
    assert(!return_value || return_value == object);
    return return_value;
  }
 
  static std::shared_ptr<C> downcast(std::shared_ptr<C> object) {
    return object;
  }
};
 
template <class C>
class ProxyDowncaster<C, false> {
 public:
  template <class T>
  static std::shared_ptr<T> downcast(std::shared_ptr<C> object) {
    static_assert(
        CustomDowncastDefined<C, T>::value(),
        "RTTI is disabled. Cast from proxy object base class must be\n"
        "explicitly defined as the static function in the class to downcast "
        "to.\n"
        "In terms of C and T:\n"
        "class T {\n"
        "  ...\n"
        "  static std::shared_ptr<T> downcast(std::shared_ptr<T>);\n"
        "  ...\n"
        "};");
    return T::downcast(object);
  }
};
 
class ProxyObjectType {};
 
template <class T>
class ProxyObjectTypeImpl : public ProxyObjectType {
 public:
  static ProxyObjectTypeImpl* instance() {
    static ProxyObjectTypeImpl impl;
    return &impl;
  }
};
 
template <class T>
class JsProxyObjectRoot {
  template <class C>
  static constexpr C* pass(JsProxyObjectImpl<C>*) {
    return nullptr;
  }
 
  static constexpr void* pass(void*) { return nullptr; }
 
 public:
  using Type =
      typename std::remove_pointer<decltype(pass(&std::declval<T&>()))>::type;
  static constexpr bool Exists = !std::is_same<Type, void>::value;
};
 
}  // namespace internal
 
template <class T>
std::shared_ptr<T> JsProxyObject::as() {
  static_assert(internal::JsProxyObjectRoot<T>::Exists,
                "The object is not a custom proxy object.");
  using RootProxyType = typename internal::JsProxyObjectRoot<T>::Type;
  if (proxyType() == internal::ProxyObjectTypeImpl<RootProxyType>::instance()) {
    return internal::ProxyDowncaster<RootProxyType>::template downcast<T>(
        std::static_pointer_cast<RootProxyType>(shared_from_this()));
  }
  return nullptr;
}
 
template <>
std::shared_ptr<JsProxyObject> JsProxyObject::as();
 
template <class C>
internal::ProxyObjectType* JsProxyObjectImpl<C>::proxyType() {
  return internal::ProxyObjectTypeImpl<C>::instance();
}
 
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_PROXY_OBJECT_DETAIL_HPP