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 };
 
    void initStr() const;
    void initWStr() const;
 
  public:
    ValAdaptor();
 
    explicit ValAdaptor(const SharedString &str);
    ValAdaptor &operator=(const SharedString &str);
 
    explicit ValAdaptor(StringInitializer str);
    ValAdaptor &operator=(StringInitializer str);
 
    template <typename Bool, typename std::enable_if_t<
                                 std::is_same_v<Bool, bool>, bool> = true>
    explicit ValAdaptor(Bool value);
    template <typename Bool>
    auto operator=(Bool v)
        -> std::enable_if_t<std::is_same_v<Bool, bool>, ValAdaptor &>;
 
    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_same_v<T, bool> &&
                                                        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_same_v<T, bool> &&
                                                        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; }
 
    bool empty() const;
 
    [[deprecated("(ver2.10〜) use asStringView() or asString() instead")]]
    std::string asStringRef() const {
        return asString();
    }
    StringView asStringView() const;
    [[deprecated("(ver2.10〜) use asWStringView() or asWString() instead")]]
    std::wstring asWStringRef() const {
        return asWString();
    }
    WStringView asWStringView() const;
    std::string_view asU8StringView() const;
    std::string asString() const { return std::string(asStringView()); }
    std::wstring asWString() const { return std::wstring(asWStringView()); }
 
    template <typename T,
              typename std::enable_if_t<std::is_convertible_v<StringView, T>,
                                        std::nullptr_t> = nullptr>
    operator T() const {
        return asStringView();
    }
    template <typename T, typename std::enable_if_t<
                              !std::is_convertible_v<StringView, T> &&
                                  std::is_convertible_v<WStringView, T>,
                              std::nullptr_t> = nullptr>
    operator T() const {
        return asWStringView();
    }
    template <typename T, typename std::enable_if_t<
                              !std::is_convertible_v<StringView, T> &&
                                  !std::is_convertible_v<WStringView, T> &&
                                  std::is_constructible_v<T, StringView>,
                              std::nullptr_t> = nullptr>
    explicit operator T() const {
        return T(asStringView());
    }
    template <typename T, typename std::enable_if_t<
                              !std::is_convertible_v<StringView, T> &&
                                  !std::is_convertible_v<WStringView, T> &&
                                  !std::is_constructible_v<T, StringView> &&
                                  std::is_constructible_v<T, WStringView>,
                              std::nullptr_t> = nullptr>
    explicit operator T() const {
        return T(asWStringView());
    }
 
    double asDouble() const;
    int asInt() const;
    long long asLLong() const;
    template <typename T>
    T as() const {
        // ↓ MSVCでなぜかコンパイルできない
        // return static_cast<T>(*this);
        return this->operator T();
    }
    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);
    }
};
 
extern template ValAdaptor::ValAdaptor(bool value);
extern template ValAdaptor &ValAdaptor::operator= <bool>(bool v);
 
 
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 << a.asStringView();
}
 
using ValAdapter = ValAdaptor;
 
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) = args[n].as<Type>();
        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