value.h

Go to the documentation of this file.

/*****************************************************************************
BSD 3-Clause License
 
Copyright (c) 2024, 🍀☀🌕🌥 🌊
All rights reserved.
*****************************************************************************/
 
#pragma once
 
#include "core/value_types.h"
#include "core/concepts.h"
#include <variant>
#include <string>
#include <string_view>
#include <vector>
#include <memory>
#include <optional>
#include <mutex>
#include <shared_mutex>
#include <atomic>
#include <type_traits>
#include <concepts>
 
namespace kcenon::container
{
    // Forward declarations
    class thread_safe_container;
    class value;
 
    // Note: Positions 6-9 in ValueVariant use unaliased C++ fundamental types
    // (long, unsigned long, long long, unsigned long long) instead of
    // int64_t/uint64_t. This avoids duplicate-type issues in std::variant
    // because int64_t is a typedef for long long on most platforms, which
    // would conflict with a separate long long entry. Using the unaliased
    // types ensures they are always distinct in the C++ type system:
    // - LP64 (macOS/Linux): long=64bit, long long=64bit (distinct types)
    // - LLP64 (Windows): long=32bit, long long=64bit (distinct types)
 
    struct array_variant {
        std::vector<std::shared_ptr<value>> values;
 
        array_variant() = default;
        array_variant(const array_variant& other);
        array_variant(array_variant&& other) noexcept = default;
        array_variant& operator=(const array_variant& other);
        array_variant& operator=(array_variant&& other) noexcept = default;
 
        bool operator==(const array_variant& other) const;
        bool operator!=(const array_variant& other) const { return !(*this == other); }
        bool operator<(const array_variant& other) const;
    };
 
    using ValueVariant = std::variant<
        std::monostate,                         // 0: null_value
        bool,                                   // 1: bool_value
        int16_t,                                // 2: short_value
        uint16_t,                               // 3: ushort_value
        int32_t,                                // 4: int_value
        uint32_t,                               // 5: uint_value
        long,                                   // 6: long_value (unaliased fundamental type)
        unsigned long,                          // 7: ulong_value (unaliased fundamental type)
        long long,                              // 8: llong_value (always distinct from long)
        unsigned long long,                     // 9: ullong_value (always distinct from unsigned long)
        float,                                  // 10: float_value
        double,                                 // 11: double_value
        std::string,                            // 12: string_value
        std::vector<uint8_t>,                   // 13: bytes_value
        std::shared_ptr<thread_safe_container>, // 14: container_value
        array_variant                           // 15: array_value
    >;
 
    namespace detail {
        template<typename T, typename Variant>
        constexpr size_t variant_index_of() {
            return std::variant<T, Variant>::index();
        }
 
        // Verify critical type alignments
        static_assert(std::variant_size_v<ValueVariant> == 16,
                     "ValueVariant must have exactly 16 types");
        static_assert(std::is_same_v<std::variant_alternative_t<0, ValueVariant>, std::monostate>,
                     "Index 0 must be std::monostate");
        static_assert(std::is_same_v<std::variant_alternative_t<1, ValueVariant>, bool>,
                     "Index 1 must be bool");
        static_assert(std::is_same_v<std::variant_alternative_t<12, ValueVariant>, std::string>,
                     "Index 12 must be string");
        static_assert(std::is_same_v<std::variant_alternative_t<13, ValueVariant>, std::vector<uint8_t>>,
                     "Index 13 must be bytes (vector<uint8_t>)");
        static_assert(std::is_same_v<std::variant_alternative_t<15, ValueVariant>, array_variant>,
                     "Index 15 must be array_variant");
    }
 
    class value
    {
    public:
        value() : name_(""), data_(std::in_place_index<0>) {}
 
        explicit value(std::string_view name)
            : name_(name), data_(std::in_place_index<0>) {}
 
        template<typename T>
        value(std::string_view name, T&& value)
            : name_(name), data_(std::forward<T>(value)) {}
 
        value(std::string_view name, value_types type, const std::vector<uint8_t>& raw_data);
 
        value(const value& other);
 
        value(value&& other) noexcept;
 
        value& operator=(const value& other);
 
        value& operator=(value&& other) noexcept;
 
        std::string_view name() const noexcept { return name_; }
 
        value_types type() const;
 
        size_t variant_index() const {
            std::shared_lock lock(mutex_);
            return data_.index();
        }
 
        bool is_null() const {
            std::shared_lock lock(mutex_);
            return data_.index() == 0;
        }
 
        template<concepts::ValueVariantType T>
        std::optional<T> get() const {
            std::shared_lock lock(mutex_);
            if (auto* ptr = std::get_if<T>(&data_)) {
                return *ptr;
            }
            return std::nullopt;
        }
 
        template<concepts::ValueVariantType T>
        void set(T&& value) {
            std::unique_lock lock(mutex_);
            data_ = std::forward<T>(value);
            write_count_.fetch_add(1, std::memory_order_relaxed);
        }
 
        template<concepts::ValueVisitor Visitor>
        auto visit(Visitor&& vis) const {
            std::shared_lock lock(mutex_);
            read_count_.fetch_add(1, std::memory_order_relaxed);
            return std::visit(std::forward<Visitor>(vis), data_);
        }
 
        template<concepts::ValueVisitor Visitor>
        auto visit_mut(Visitor&& vis) {
            std::unique_lock lock(mutex_);
            write_count_.fetch_add(1, std::memory_order_relaxed);
            return std::visit(std::forward<Visitor>(vis), data_);
        }
 
        std::string to_string() const;
 
        std::string to_json() const;
 
        std::vector<uint8_t> serialize() const;
 
        static std::optional<value> deserialize(const std::vector<uint8_t>& data);
 
        size_t read_count() const { return read_count_.load(std::memory_order_relaxed); }
        size_t write_count() const { return write_count_.load(std::memory_order_relaxed); }
 
        bool operator==(const value& other) const;
        bool operator!=(const value& other) const { return !(*this == other); }
        bool operator<(const value& other) const;
 
    private:
        void serialize_data(std::vector<uint8_t>& result) const;
 
        static bool deserialize_data(value& result,
                                     value_types type,
                                     const std::vector<uint8_t>& data,
                                     size_t& offset);
 
        const std::string name_;  // Immutable for lock-free access
        ValueVariant data_;
        mutable std::shared_mutex mutex_;
        mutable std::atomic<size_t> read_count_{0};
        mutable std::atomic<size_t> write_count_{0};
    };
 
    template<typename T>
    struct is_variant_type_v2 : std::false_type {};
 
    // Specialize for each variant type
    template<> struct is_variant_type_v2<std::monostate> : std::true_type {};
    template<> struct is_variant_type_v2<bool> : std::true_type {};
    template<> struct is_variant_type_v2<int16_t> : std::true_type {};
    template<> struct is_variant_type_v2<uint16_t> : std::true_type {};
    template<> struct is_variant_type_v2<int32_t> : std::true_type {};
    template<> struct is_variant_type_v2<uint32_t> : std::true_type {};
    template<> struct is_variant_type_v2<int64_t> : std::true_type {};
    template<> struct is_variant_type_v2<uint64_t> : std::true_type {};
    template<> struct is_variant_type_v2<float> : std::true_type {};
    template<> struct is_variant_type_v2<double> : std::true_type {};
    template<> struct is_variant_type_v2<std::vector<uint8_t>> : std::true_type {};
    template<> struct is_variant_type_v2<std::string> : std::true_type {};
    template<> struct is_variant_type_v2<std::shared_ptr<thread_safe_container>> : std::true_type {};
    template<> struct is_variant_type_v2<array_variant> : std::true_type {};
 
    template<typename T>
    inline constexpr bool is_variant_type_v2_v = is_variant_type_v2<T>::value;
 
} // namespace kcenon::container