js_accessible_method_impl_detail.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_JS_ACCESSIBLE_METHOD_IMPL_DETAIL_HPP
#define MOLYBDEN_JS_ACCESSIBLE_METHOD_IMPL_DETAIL_HPP
 
#include "molybden/js/internal/js_value_converter.hpp"
 
namespace molybden {
namespace internal {
 
template <class C, class R, class... T>
JsAccessibleMethodImplBase<C, R, T...>::JsAccessibleMethodImplBase(
    C* object,
    MethodSignature<C, R, T...> method)
    : object_(object), call_(method) {
  AreAllConvertibleFromJsDirectly<R, T...>::check();
}
 
template <class C, class R, class... T>
R JsAccessibleMethodImplBase<C, R, T...>::callInternal(T... args) {
  return (object_->*call_)(args...);
}
 
template <class C, class R, class... T>
template <std::size_t... I>
JsReturnValue JsAccessibleMethodImplBase<C, R, T...>::checkedCall(
    const std::vector<JsValue>& values,
    index_sequence<I...>) {
  if (sizeof...(T) != values.size()) {
    return JsReturnValue(
        JsError{std::to_string(values.size()) +
                " arguments were provided to the C++ method, but " +
                std::to_string(sizeof...(T)) + " are required."});
  }
  auto converter = internal::IndexedJsValueConverter<T...>(values);
  std::vector<bool> convertible{converter.template isConvertible<I>()...};
  for (int i = 0; i < convertible.size(); ++i) {
    if (!convertible[i]) {
      std::vector<std::string> arg_types{
          converter.template convertErrorTypeInfo<I>()...};
      return JsReturnValue(JsError{
          std::string("exception: the ") + std::to_string(i + 1) +
              "-th argument is not convertible to " + arg_types[i] + ".",
          ExceptionType::kTypeError});
    }
  }
  return JsReturnValue(wrappedCall(converter.template convert<I>()...));
}
 
template <class C, class R, class... T>
JsReturnValue JsAccessibleMethodImplBase<C, R, T...>::call(
    const std::vector<JsValue>& values) {
  return checkedCall(values, index_sequence_for<T...>());
}
 
template <class C, class R, class... T>
JsValue JsAccessibleMethodImpl<C, R, T...>::wrappedCall(T... args) {
  return JsValue::from(
      JsAccessibleMethodImplBase<C, R, T...>::callInternal(args...));
}
 
template <class C, class... T>
JsValue JsAccessibleMethodImpl<C, void, T...>::wrappedCall(T... args) {
  JsAccessibleMethodImplBase<C, void, T...>::callInternal(args...);
  return {};
}
 
template <class C, class R, class... T>
JsAccessibleMethodImpl<C, R, T...>::JsAccessibleMethodImpl(
    C* object,
    MethodSignature<C, R, T...> method)
    : JsAccessibleMethodImplBase<C, R, T...>(object, method) {}
 
template <class C, class... T>
JsAccessibleMethodImpl<C, void, T...>::JsAccessibleMethodImpl(
    C* object,
    MethodSignature<C, void, T...> method)
    : JsAccessibleMethodImplBase<C, void, T...>(object, method) {}
 
}  // namespace internal
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_ACCESSIBLE_METHOD_IMPL_DETAIL_HPP