js_value_converter.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_JS_VALUE_CONVERTER_HPP
#define MOLYBDEN_JS_VALUE_CONVERTER_HPP
 
#include <vector>
 
#include "molybden/js/js_array.hpp"
#include "molybden/js/js_value.hpp"
 
namespace molybden {
namespace internal {
 
template <class T>
struct IsJsObject;
 
template <class T>
struct IsJsProxyObject;
 
template <class T>
using EnableIfJsObject = typename std::enable_if<IsJsObject<T>::Value()>::type;
 
template <class T>
using EnableIfJsProxyObject =
    typename std::enable_if<IsJsProxyObject<T>::Value()>::type;
 
template <class T, class V = void>
class JsValueConverter;
 
template <>
class JsValueConverter<double> {
 public:
  static double convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <>
class JsValueConverter<float> {
 public:
  static float convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <class T>
class JsValueConverter<T, typename std::enable_if<std::is_integral<T>::value>::type> {
 public:
  static T convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <>
class JsValueConverter<std::string> {
 public:
  static std::string convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <>
class JsValueConverter<bool> {
 public:
  static bool convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <>
class JsValueConverter<JsValue> {
 public:
  static JsValue convert(const JsValue& value);
  static JsValue convert(JsValue&& value);
  static constexpr bool isConvertible(const JsValue& value) {return true;}
  static std::string convertErrorTypeInfo();
};
 
template <class T>
class JsValueConverter<std::shared_ptr<T>, EnableIfJsObject<T>> {
 public:
  static std::shared_ptr<T> convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <class T>
class JsValueConverter<std::shared_ptr<T>, EnableIfJsProxyObject<T>> {
 public:
  static std::shared_ptr<T> convert(const JsValue& value);
  static bool isConvertible(const JsValue& value);
  static std::string convertErrorTypeInfo();
};
 
template <class... T>
class IndexedJsValueConverter {
 public:
  explicit IndexedJsValueConverter(const std::vector<JsValue>& values);
 
  template <std::size_t I>
  using TypeOfArg = typename std::remove_reference<decltype(std::get<I>(
      std::tuple<T...>()))>::type;
 
  template <std::size_t I>
  TypeOfArg<I> convert();
 
  template <std::size_t I>
  bool isConvertible();
 
  template <std::size_t I>
  std::string convertErrorTypeInfo();
 
 private:
  const std::vector<JsValue>& values_;
};
 
}  // namespace internal
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_VALUE_CONVERTER_HPP