js_value_converter_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_CONVERTER_DETAIL_HPP
#define MOLYBDEN_JS_VALUE_CONVERTER_DETAIL_HPP
 
#include "molybden/js/internal/js_value_converter.hpp"
 
#include <limits>
#include <cmath>
 
namespace molybden {
namespace internal {
 
template <class T, class V = void>
struct TypeName {};
 
template <class T>
struct TypeName<T, EnableIfJsObject<T>> {
  static std::string toString() { return "JsObject"; }
};
 
template <>
struct TypeName<JsArray> {
  static std::string toString();
};
 
template <class T>
T JsValueConverter<T,
                   typename std::enable_if<std::is_integral<T>::value>::type>::
    convert(const JsValue& value) {
  return static_cast<T>(value.asNumber());
}
 
inline bool isInteger(double value) {
  return std::floor(value) == value;
}
 
template <class T>
bool JsValueConverter<T,
                      typename std::enable_if<std::is_integral<T>::value>::
                          type>::isConvertible(const JsValue& value) {
  if (value.isNumber() && isInteger(value.asNumber())) {
    return value.asNumber() >= (std::numeric_limits<T>::min)() &&
           value.asNumber() <= (std::numeric_limits<T>::max)();
  }
  return false;
}
 
template <class T>
std::string
JsValueConverter<T, typename std::enable_if<std::is_integral<T>::value>::type>::
    convertErrorTypeInfo() {
  std::string result;
  if (std::is_unsigned<T>::value) {
    result += "u";
  }
  result += "int";
  result += std::to_string(sizeof(T) * 8);
  result += "_t";
  return result;
}
 
template <class T>
std::shared_ptr<T>
JsValueConverter<std::shared_ptr<T>, EnableIfJsObject<T>>::convert(
    const JsValue& value) {
  if (auto object = value.asJsObject()) {
    return object->as<T>();
  }
  return nullptr;
}
 
template <class T>
bool JsValueConverter<std::shared_ptr<T>, EnableIfJsObject<T>>::isConvertible(
    const JsValue& value) {
  return !!convert(value);
}
 
template <class T>
std::string JsValueConverter<std::shared_ptr<T>,
                             EnableIfJsObject<T>>::convertErrorTypeInfo() {
  return TypeName<T>::toString();
}
 
template <class T>
std::shared_ptr<T>
JsValueConverter<std::shared_ptr<T>, EnableIfJsProxyObject<T>>::convert(
    const JsValue& value) {
  if (auto object = value.asJsProxyObject()) {
    return object->as<T>();
  }
  return nullptr;
}
 
template <class T>
bool JsValueConverter<std::shared_ptr<T>, EnableIfJsProxyObject<T>>::
    isConvertible(const JsValue& value) {
  return !!convert(value);
}
 
template <class T>
std::string JsValueConverter<std::shared_ptr<T>,
                             EnableIfJsProxyObject<T>>::convertErrorTypeInfo() {
  return "the proxy object of the appropriate class";
}
 
template <class... T>
IndexedJsValueConverter<T...>::IndexedJsValueConverter(
    const std::vector<JsValue>& values)
    : values_(values) {}
 
template <class... T>
template <std::size_t I>
typename IndexedJsValueConverter<T...>::template TypeOfArg<I>
IndexedJsValueConverter<T...>::convert() {
  return JsValueConverter<TypeOfArg<I>>::convert(values_.at(I));
}
 
template <class... T>
template <std::size_t I>
bool IndexedJsValueConverter<T...>::isConvertible() {
  return JsValueConverter<TypeOfArg<I>>::isConvertible(values_.at(I));
}
 
template <class... T>
template <std::size_t I>
std::string IndexedJsValueConverter<T...>::convertErrorTypeInfo() {
  return JsValueConverter<TypeOfArg<I>>::convertErrorTypeInfo();
}
 
}  // namespace internal
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_VALUE_CONVERTER_DETAIL_HPP