js_convertible_types_detail.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_JS_COMPATIBLE_OBJECTS_DETAIL_HPP
#define MOLYBDEN_JS_COMPATIBLE_OBJECTS_DETAIL_HPP
 
#include <memory>
 
#include "molybden/base/internal/is_base_and_derived.hpp"
 
namespace molybden {
 
class JsObject;
class JsProxyObject;
 
namespace internal {
 
template <class T>
struct IsJsObject {
  static constexpr bool Value();
};
 
template <class T>
constexpr bool IsJsObject<T>::Value() {
  return IsBaseAndDerived<JsObject, T>::Value();
}
 
template <class T>
struct IsJsProxyObject {
  static constexpr bool Value();
};
 
template <class T>
constexpr bool IsJsProxyObject<T>::Value() {
  return IsBaseAndDerived<JsProxyObject, T>::Value();
}
 
template <class T, class V = void>
struct IsConvertibleFromJsDirectlyInternal {
  static constexpr bool value() { return false; }
};
 
template <class T>
struct IsConvertibleFromJsDirectlyInternal<
    T,
    typename std::enable_if<std::is_integral<T>::value ||
                            std::is_floating_point<T>::value>::type> {
  static constexpr bool value() { return true; }
};
 
template <class T>
struct IsConvertibleFromJsDirectlyInternal<std::shared_ptr<T>> {
  static constexpr bool value() {
    return IsJsObject<T>::Value() || IsJsProxyObject<T>::Value();
  }
};
 
template <>
struct IsConvertibleFromJsDirectlyInternal<std::string> {
  static constexpr bool value() { return true; }
};
 
template <>
struct IsConvertibleFromJsDirectlyInternal<const char*> {
  static constexpr bool value() { return true; }
};
 
template <>
struct IsConvertibleFromJsDirectlyInternal<bool> {
  static constexpr bool value() { return true; }
};
 
template <>
struct IsConvertibleFromJsDirectlyInternal<JsValue> {
  static constexpr bool value() { return true; }
};
 
template <>
struct IsConvertibleFromJsDirectlyInternal<void> {
  static constexpr bool value() { return true; }
};
 
template <class T>
constexpr bool IsConvertibleFromJsDirectly<T>::value() {
  return IsConvertibleFromJsDirectlyInternal<
      typename std::remove_const<T>::type>::value();
}
 
template <class... T>
struct AreAllConvertibleFromJsDirectly;
 
template <class T0, class... T>
void AreAllConvertibleFromJsDirectly<T0, T...>::check() {
  static_assert(
      IsConvertibleFromJsDirectly<T0>::value(),
      "Invalid type of the JS-accessible field or the method signature. \n"
      "Supported types: \n"
      " - double\n"
      " - bool\n"
      " - std::string\n"
      " - std::shared_ptr<SomeJsObject>\n"
      " - std::shared_ptr<SomeJsProxyObject>\n"
      " - JsValue\n"
      " Accessible methods also can return void.");
  AreAllConvertibleFromJsDirectly<T...>::check();
}
 
}  // namespace internal
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_COMPATIBLE_OBJECTS_DETAIL_HPP