value.hpp

#pragma once
 
#include <md/error.hpp>
 
#include <concepts>
#include <cstdint>
#include <initializer_list>
#include <memory>
#include <string>
#include <string_view>
#include <type_traits>
#include <variant>
#include <vector>
 
namespace md {
 
class Value;
class Object;
 
using Array = std::vector<Value>;
 
namespace detail {
 
// Transparent hash + equal-to lets std::unordered_map<std::string, ...> accept
// std::string_view / const char* in find/contains/erase without allocating.
struct TransparentStringHash {
    using is_transparent = void;
 
    [[nodiscard]] std::size_t operator()(const std::string_view sv) const noexcept {
        return std::hash<std::string_view>{}(sv);
    }
    [[nodiscard]] std::size_t operator()(const std::string& s) const noexcept {
        return std::hash<std::string_view>{}(s);
    }
    [[nodiscard]] std::size_t operator()(const char* s) const noexcept {
        return std::hash<std::string_view>{}(std::string_view{s});
    }
};
 
// Concepts that exclude bool and character types so that Value{true} stays
// a bool and Value{'a'} doesn't sneak in as an integer.
template <class T>
concept SignedIntLike =
    std::is_integral_v<T> && std::is_signed_v<T> && !std::is_same_v<std::remove_cv_t<T>, bool> &&
    !std::is_same_v<std::remove_cv_t<T>, char> && !std::is_same_v<std::remove_cv_t<T>, wchar_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char8_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char16_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char32_t>;
 
template <class T>
concept UnsignedIntLike =
    std::is_integral_v<T> && std::is_unsigned_v<T> && !std::is_same_v<std::remove_cv_t<T>, bool> &&
    !std::is_same_v<std::remove_cv_t<T>, char> && !std::is_same_v<std::remove_cv_t<T>, wchar_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char8_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char16_t> &&
    !std::is_same_v<std::remove_cv_t<T>, char32_t>;
 
template <class T>
concept FloatLike = std::is_floating_point_v<T>;
 
}  // namespace detail
 
class Value {
public:
    // Object is indirected through unique_ptr so Value can recursively hold an
    // Object that itself stores Values. Without indirection, std::variant
    // probes traits like is_*_constructible<Object> at instantiation time,
    // which would require Object complete here.
    using variant_type = std::variant<std::nullptr_t,
                                      bool,
                                      std::int64_t,
                                      std::uint64_t,
                                      float,
                                      double,
                                      std::string,
                                      Array,
                                      std::unique_ptr<Object>>;
 
    // Every member that touches v_ is DECLARED here and DEFINED out-of-line
    // in object.hpp. Reason: instantiating variant<..., unique_ptr<Object>>
    // operations (including the constructor's exception-handling rollback)
    // requires unique_ptr<Object>::~unique_ptr to be instantiable, which
    // requires Object complete — which isn't the case until object.hpp.
 
    Value() noexcept;
    Value(Value&& other) noexcept;
    Value& operator=(Value&& other) noexcept;
    Value(const Value& other);
    Value& operator=(const Value& other);
    ~Value();
 
    // Braced-list assignment for ergonomic in-place writes:
    //   m["tags"] = {"a", "b"};          // → Array
    //   m["sub"]  = {{"k", 1}, {"k2", 2}}; // → Object (pair-like elements)
    // The two overloads disambiguate by element type: bare values pick the
    // Array overload; brace-pair elements pick the Object overload (Value
    // has no 2-arg constructor, so they only match the pair form).
    // An empty list `= {}` is ambiguous — use `md::Array{}` or `md::Object{}`
    // explicitly when you mean empty.
    Value& operator=(std::initializer_list<Value> il);
    Value& operator=(std::initializer_list<std::pair<const std::string, Value>> il);
 
    Value(std::nullptr_t) noexcept;
 
    template <class B>
        requires std::same_as<B, bool>
    Value(B b) noexcept;
 
    template <detail::SignedIntLike T>
    Value(T x) noexcept;
 
    template <detail::UnsignedIntLike T>
    Value(T x) noexcept;
 
    // FloatLike covers float/double/long double; the constructor stores
    // single-precision input as `float` and everything else as `double`.
    template <detail::FloatLike T>
    Value(T x) noexcept;
 
    Value(std::string s);
    Value(std::string_view s);
    Value(const char* s);
 
    Value(Array a);
    Value(Object o);
 
    // Build an Object directly from a pair-shaped braced list. Lets nested
    // objects parse naturally:
    //   m["sub"] = {{"a", {{"b", 1}}}};  // outer Object, inner Object
    // We deliberately do NOT add `Value(initializer_list<Value>)` for arrays
    // because that would change the meaning of `Value{42}` from scalar to
    // single-element Array.
    Value(std::initializer_list<std::pair<const std::string, Value>> il);
 
    template <class T>
    Value(T*) = delete;
 
    // --- predicates --------------------------------------------------
 
    [[nodiscard]] bool is_null() const noexcept;
    [[nodiscard]] bool is_bool() const noexcept;
    [[nodiscard]] bool is_int() const noexcept;
    [[nodiscard]] bool is_uint() const noexcept;
    [[nodiscard]] bool is_float() const noexcept;
    [[nodiscard]] bool is_double() const noexcept;
    [[nodiscard]] bool is_number() const noexcept;
    [[nodiscard]] bool is_string() const noexcept;
    [[nodiscard]] bool is_array() const noexcept;
    [[nodiscard]] bool is_object() const noexcept;
 
    // --- strict accessors -------------------------------------------
 
    [[nodiscard]] bool as_bool() const;
    [[nodiscard]] std::int64_t as_int() const;
    [[nodiscard]] std::uint64_t as_uint() const;
    [[nodiscard]] float as_float() const;
    [[nodiscard]] double as_double() const;
 
    [[nodiscard]] std::string& as_string();
    [[nodiscard]] const std::string& as_string() const;
    [[nodiscard]] Array& as_array();
    [[nodiscard]] const Array& as_array() const;
    [[nodiscard]] Object& as_object();
    [[nodiscard]] const Object& as_object() const;
 
    // --- pointer accessors (noexcept) -------------------------------
 
    [[nodiscard]] bool* as_bool_if() noexcept;
    [[nodiscard]] const bool* as_bool_if() const noexcept;
    [[nodiscard]] std::int64_t* as_int_if() noexcept;
    [[nodiscard]] const std::int64_t* as_int_if() const noexcept;
    [[nodiscard]] std::uint64_t* as_uint_if() noexcept;
    [[nodiscard]] const std::uint64_t* as_uint_if() const noexcept;
    [[nodiscard]] float* as_float_if() noexcept;
    [[nodiscard]] const float* as_float_if() const noexcept;
    [[nodiscard]] double* as_double_if() noexcept;
    [[nodiscard]] const double* as_double_if() const noexcept;
    [[nodiscard]] std::string* as_string_if() noexcept;
    [[nodiscard]] const std::string* as_string_if() const noexcept;
    [[nodiscard]] Array* as_array_if() noexcept;
    [[nodiscard]] const Array* as_array_if() const noexcept;
    [[nodiscard]] Object* as_object_if() noexcept;
    [[nodiscard]] const Object* as_object_if() const noexcept;
 
    template <class T>
    [[nodiscard]] T* get_if() noexcept;
    template <class T>
    [[nodiscard]] const T* get_if() const noexcept;
 
    template <class T>
    [[nodiscard]] T value_or(T fallback) const;
 
    [[nodiscard]] variant_type& raw() noexcept;
    [[nodiscard]] const variant_type& raw() const noexcept;
 
    [[nodiscard]] std::size_t index() const noexcept;
 
    friend bool operator==(const Value& a, const Value& b) noexcept;
    friend bool operator!=(const Value& a, const Value& b) noexcept;
 
private:
    variant_type v_;
};
 
// --- factory helper declarations ----------------------------------------
 
[[nodiscard]] Value null() noexcept;
[[nodiscard]] Value boolean(bool b) noexcept;
 
template <class T>
    requires(detail::SignedIntLike<T> || detail::UnsignedIntLike<T> || detail::FloatLike<T>)
[[nodiscard]] inline Value number(T v) noexcept {
    return Value{v};
}
 
[[nodiscard]] Value string(std::string s);
[[nodiscard]] Value string(std::string_view s);
[[nodiscard]] Value string(const char* s);
 
[[nodiscard]] inline Array array() {
    return Array{};
}
[[nodiscard]] inline Array array(const std::initializer_list<Value> il) {
    return Array(il);
}
 
// object() / object({...}) factories are defined in object.hpp.
 
}  // namespace md