val_adaptor.h

Go to the documentation of this file.

#pragma once
#include <string>
#include <vector>
#include <tuple>
#include <cstdint>
#include <ostream>
#include <variant>
#include "encoding.h"
#ifdef WEBCFACE_MESON
#include "webcface-config.h"
#else
#include "webcface/common/webcface-config.h"
#endif
 
WEBCFACE_NS_BEGIN
 
enum class ValType {
    none_ = 0,
    string_ = 1,
    bool_ = 2,
    int_ = 3,
    float_ = 4,
    double_ = 4,
};
template <typename T>
ValType valTypeOf() {
    if constexpr (std::is_void_v<T>) {
        return ValType::none_;
    } else if constexpr (std::is_same_v<bool, T>) {
        return ValType::bool_;
    } else if constexpr (std::is_integral_v<T>) {
        return ValType::int_;
    } else if constexpr (std::is_floating_point_v<T>) {
        return ValType::float_;
    } else {
        return ValType::string_;
    }
}
 
inline std::string valTypeStr(ValType a) {
    switch (a) {
    case ValType::none_:
        return "none";
    case ValType::string_:
        return "string";
    case ValType::bool_:
        return "bool";
    case ValType::int_:
        return "int";
    case ValType::float_:
        return "float";
    default:
        return "unknown";
    }
}
inline std::ostream &operator<<(std::ostream &os, ValType a) {
    return os << valTypeStr(a);
}
 
class WEBCFACE_DLL ValAdaptor {
    mutable SharedString as_str;
 
    std::variant<double, std::int64_t> as_val;
    ValType type;
 
    enum ValVariant { DOUBLEV = 0, INT64V = 1 };
 
  public:
    ValAdaptor();
 
    explicit ValAdaptor(const SharedString &str);
    ValAdaptor &operator=(const SharedString &str);
 
    explicit ValAdaptor(std::string_view str);
    ValAdaptor &operator=(std::string_view str);
    explicit ValAdaptor(const char *str) : ValAdaptor(std::string_view(str)) {}
    ValAdaptor &operator=(const char *str) {
        return *this = std::string_view(str);
    }
 
    explicit ValAdaptor(std::wstring_view str);
    ValAdaptor &operator=(std::wstring_view str);
    explicit ValAdaptor(const wchar_t *str)
        : ValAdaptor(std::wstring_view(str)) {}
    ValAdaptor &operator=(const wchar_t *str) {
        return *this = std::wstring_view(str);
    }
 
    explicit ValAdaptor(bool value);
    ValAdaptor &operator=(bool v);
 
    explicit ValAdaptor(std::int64_t value);
    ValAdaptor &operator=(std::int64_t v);
 
    explicit ValAdaptor(double value);
    ValAdaptor &operator=(double v);
 
    template <typename T, typename std::enable_if_t<std::is_integral_v<T>,
                                                    std::nullptr_t> = nullptr>
    explicit ValAdaptor(T value)
        : ValAdaptor(static_cast<std::int64_t>(value)) {}
    template <typename T, typename std::enable_if_t<std::is_integral_v<T>,
                                                    std::nullptr_t> = nullptr>
    ValAdaptor &operator=(T v) {
        return *this = static_cast<std::int64_t>(v);
    }
 
    template <typename T, typename std::enable_if_t<std::is_floating_point_v<T>,
                                                    std::nullptr_t> = nullptr>
    explicit ValAdaptor(T value) : ValAdaptor(static_cast<double>(value)) {}
    template <typename T, typename std::enable_if_t<std::is_floating_point_v<T>,
                                                    std::nullptr_t> = nullptr>
    ValAdaptor &operator=(T v) {
        return *this = static_cast<double>(v);
    }
 
    ValType valType() const { return type; }
 
    static const ValAdaptor &emptyVal();
 
    bool empty() const;
 
    const std::string &asStringRef() const;
    const std::wstring &asWStringRef() const;
    const std::string &asU8StringRef() const;
    std::string asString() const { return asStringRef(); }
    std::wstring asWString() const { return asWStringRef(); }
 
    operator const std::string &() const { return asStringRef(); }
    operator const std::wstring &() const { return asWStringRef(); }
    operator const char *() const { return asStringRef().c_str(); }
    operator const wchar_t *() const { return asWStringRef().c_str(); }
 
    double asDouble() const;
    int asInt() const;
    long long asLLong() const;
    template <typename T>
    [[deprecated("use asDouble(), asInt() or asLLong() instead")]] double
    as() const {
        return static_cast<T>(asDouble());
    }
    template <typename T,
              typename std::enable_if_t<std::is_convertible_v<double, T> &&
                                            !std::is_same_v<T, bool>,
                                        std::nullptr_t> = nullptr>
    operator T() const {
        if constexpr (std::is_floating_point_v<T>) {
            return static_cast<T>(asDouble());
        } else if constexpr (sizeof(T) > sizeof(int)) {
            return static_cast<T>(asLLong());
        } else {
            return static_cast<T>(asInt());
        }
    }
 
    bool asBool() const;
    operator bool() const { return asBool(); }
 
    bool operator==(const ValAdaptor &other) const;
    bool operator!=(const ValAdaptor &other) const { return !(*this == other); }
 
    template <typename T, typename std::enable_if_t<
                              std::is_constructible_v<ValAdaptor, T> &&
                                  !std::is_same_v<ValAdaptor, T>,
                              std::nullptr_t> = nullptr>
    bool operator==(const T &other) const {
        return *this == ValAdaptor(other);
    }
    template <typename T, typename std::enable_if_t<
                              std::is_constructible_v<ValAdaptor, T> &&
                                  !std::is_same_v<ValAdaptor, T>,
                              std::nullptr_t> = nullptr>
    bool operator!=(const T &other) const {
        return *this != ValAdaptor(other);
    }
};
 
template <typename T,
          typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T> &&
                                        !std::is_same_v<ValAdaptor, T>,
                                    std::nullptr_t> = nullptr>
bool operator==(const T &other, const ValAdaptor &val) {
    return val == ValAdaptor(other);
}
template <typename T,
          typename std::enable_if_t<std::is_constructible_v<ValAdaptor, T> &&
                                        !std::is_same_v<ValAdaptor, T>,
                                    std::nullptr_t> = nullptr>
bool operator!=(const T &other, const ValAdaptor &val) {
    return val != ValAdaptor(other);
}
 
inline std::ostream &operator<<(std::ostream &os, const ValAdaptor &a) {
    return os << static_cast<std::string>(a);
}
 
template <int n = 0, typename T>
void argToTuple(const std::vector<ValAdaptor> &args, T &tuple) {
    constexpr int tuple_size = std::tuple_size<T>::value;
    if constexpr (n < tuple_size) {
        using Type = typename std::tuple_element<n, T>::type;
        std::get<n>(tuple) = static_cast<Type>(args[n]);
        argToTuple<n + 1>(args, tuple);
    }
}
 
namespace [[deprecated("symbols in webcface::encoding namespace are "
                       "now directly in webcface namespace")]] encoding {
using ValType = webcface::ValType;
template <typename T>
webcface::ValType valTypeOf() {
    return webcface::valTypeOf<T>();
}
inline std::string valTypeStr(webcface::ValType a) {
    return webcface::valTypeStr(a);
}
using ValAdaptor = webcface::ValAdaptor;
 
template <int n = 0, typename T>
void argToTuple(const std::vector<webcface::ValAdaptor> &args, T &tuple) {
    webcface::argToTuple<n>(args, tuple);
}
 
} // namespace encoding
WEBCFACE_NS_END