js_value.hpp

// Copyright (c) 2000-2024 TeamDev. All rights reserved.
// TeamDev PROPRIETARY and CONFIDENTIAL.
// Use is subject to license terms.
 
#ifndef MOLYBDEN_JS_VALUE_HPP
#define MOLYBDEN_JS_VALUE_HPP
 
#include <functional>
#include <memory>
#include <string>
 
#include "molybden/base/internal/void_t.hpp"
 
namespace molybden {
 
class JsObject;
class JsProxyObject;
 
class JsValueImpl;
 
class JsValue {
 public:
  JsValue();
 
  template <class T>
  static JsValue from(T&& value);
 
  [[nodiscard]] bool isEmpty() const;
 
  [[nodiscard]] const std::string& asString() const;
 
  [[nodiscard]] bool isString() const;
 
  [[nodiscard]] double asNumber() const;
 
  [[nodiscard]] bool isNumber() const;
 
  [[nodiscard]] bool asBool() const;
 
  [[nodiscard]] bool isBool() const;
 
  [[nodiscard]] std::shared_ptr<JsObject> asJsObject() const;
 
  [[nodiscard]] std::shared_ptr<JsProxyObject> asJsProxyObject() const;
 
  explicit operator bool() const;
 
  JsValue& operator=(const JsValue& other);
  JsValue& operator=(JsValue&& other);
 
  JsValue(const JsValue& other);
  JsValue(JsValue&& other);
  ~JsValue();
 
 private:
  template <typename, typename = void>
  struct IsFunctor : std::false_type {};
 
  template <typename T>
  struct IsFunctor<T, internal::void_t<decltype(&T::operator())>>
      : std::true_type {};
 
  template <class T>
  using EnableIfNumber = typename std::enable_if<
      std::is_floating_point<T>::value || std::is_integral<T>::value,
      T*>::type;
  template <class T>
  using EnableIfFunction = typename std::enable_if<
      std::is_function<typename std::remove_pointer<T>::type>::value,
      T*>::type;
  template <class T>
  using EnableIfFunctor = typename std::enable_if<IsFunctor<T>::value, T*>::type;
 
  template <class T>
  explicit JsValue(T value, EnableIfNumber<T> = nullptr);
  template <class T>
  explicit JsValue(T value, EnableIfFunction<T> = nullptr);
  template <class T>
  explicit JsValue(T& value, EnableIfFunctor<T> = nullptr);
  template <class T>
  explicit JsValue(T&& value, EnableIfFunctor<T> = nullptr);
  explicit JsValue(const char* value);
  explicit JsValue(const std::string& value);
  explicit JsValue(std::string&& value);
  explicit JsValue(bool value);
  explicit JsValue(double value);
  explicit JsValue(std::shared_ptr<JsObject> value);
  explicit JsValue(std::shared_ptr<JsProxyObject> value);
 
  std::unique_ptr<JsValueImpl> impl_;
};
 
}  // namespace molybden
 
#endif  // MOLYBDEN_JS_VALUE_HPP