js_value_detail.hpp

// Copyright (c) 2000-2023 TeamDev Ltd. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_JS_VALUE_DETAIL_HPP
#define MOLYBDEN_JS_VALUE_DETAIL_HPP
 
#include "molybden/js/internal/js_proxy_function_object.hpp"
 
namespace molybden {
 
namespace internal {
template <class T>
struct IsCharArray {
  static constexpr bool value = false;
};
 
template <size_t N>
struct IsCharArray<char[N]> {
  static constexpr bool value = true;
};
 
template <size_t N>
struct IsCharArray<const char[N]> {
  static constexpr bool value = true;
};
 
template <class R, class... T>
std::shared_ptr<JsProxyObject> getFunctionProxy(R (*function)(T...)) {
  return std::make_shared<internal::JsProxyFunctionObject<R, T...>>(
      std::function<R(T...)>(function));
}
 
template <class F, class R, class... T>
std::shared_ptr<JsProxyObject> getFunctionProxy(F&& function,
                                                R (F::*)(T...) const) {
  return std::make_shared<internal::JsProxyFunctionObject<R, T...>>(
      std::function<R(T...)>(function));
}
 
template <class F, class R, class... T>
std::shared_ptr<JsProxyObject> getFunctionProxy(F& function,
                                                R (F::*)(T...) const) {
  return std::make_shared<internal::JsProxyFunctionObject<R, T...>>(
      std::function<R(T...)>(function));
}
 
}  // namespace internal
 
template <class T>
JsValue JsValue::from(T&& value) {
  using TNoRef = typename std::remove_reference<T>::type;
 
  static_assert(
      internal::IsConvertibleFromJsDirectly<TNoRef>::value() ||
          internal::IsCharArray<TNoRef>::value ||
          std::is_same<TNoRef, char*>::value ||
          std::is_same<TNoRef, const char*>::value ||
          IsFunctor<TNoRef>::value ||
          std::is_function<typename std::remove_pointer<TNoRef>::type>::value,
      "Unable to construct JsValue from the given type.");
  return JsValue(std::forward<T>(value));
}
 
template <class T>
JsValue::JsValue(T value,
                 typename std::enable_if<std::is_floating_point<T>::value ||
                                             std::is_integral<T>::value,
                                         T*>::type)
    : JsValue(static_cast<double>(value)) {}
 
template <class T>
JsValue::JsValue(
    T value,
    typename std::enable_if<
        std::is_function<typename std::remove_pointer<T>::type>::value,
        T*>::type)
    : JsValue(internal::getFunctionProxy(value)) {}
 
template <class T>
JsValue::JsValue(T& value,
                 typename std::enable_if<IsFunctor<T>::value, T*>::type)
    : JsValue(
          internal::getFunctionProxy(std::forward<T>(value), &T::operator())) {}
 
template <class T>
JsValue::JsValue(T&& value,
                 typename std::enable_if<IsFunctor<T>::value, T*>::type)
    : JsValue(
          internal::getFunctionProxy(std::forward<T>(value), &T::operator())) {}
 
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_VALUE_DETAIL_HPP