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"
#include "trait.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,
    vector_ = 16,
    vector_string_ = 17,
    vector_bool_ = 18,
    vector_int_ = 19,
    vector_float_ = 20,
    vector_double_ = 20,
};
 
inline std::string valTypeStr(ValType a) {
    if (static_cast<int>(a) & static_cast<int>(ValType::vector_)) {
        return std::string("vector<") +
               valTypeStr(static_cast<ValType>(
                   static_cast<int>(a) ^ static_cast<int>(ValType::vector_))) +
               ">";
    }
    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);
}
 
namespace traits {
template <typename T, typename U = TraitOkType>
struct EnableIfBool {};
template <typename U>
struct EnableIfBool<bool, U> {
    using Type = U;
};
} // namespace traits
 
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>
    explicit ValAdaptor(Bool value, typename traits::EnableIfBool<Bool>::Type =
                                        traits::TraitOk);
    template <typename Bool>
    auto operator=(Bool v) ->
        typename traits::EnableIfBool<Bool, ValAdaptor &>::Type;
 
    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; }
 
    static const ValAdaptor &emptyVal();
 
    bool empty() const;
 
    [[deprecated("(ver3.0〜) use asStringView() or asString() instead")]]
    std::string asStringRef() const {
        return asString();
    }
    StringView asStringView() const;
    [[deprecated("(ver3.0〜) 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 {
        if constexpr (std::is_same_v<T, ValAdaptor>) {
            return *this;
        } else {
            // ↓ 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, typename traits::EnableIfBool<bool>::Type);
extern template auto ValAdaptor::operator= <bool>(bool v) ->
    typename traits::EnableIfBool<bool, ValAdaptor &>::Type;
 
 
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;
WEBCFACE_NS_END