kcenon::container::value Class Reference

Enhanced type-safe value with perfect legacy compatibility. More...

#include <value.h>

Collaboration diagram for kcenon::container::value:

Public Member Functions
	value ()
	Default constructor - creates null value.
	value (std::string_view name)
	Construct with name (null value)
template<typename T >
	value (std::string_view name, T &&value)
	Construct with name and typed value.
	value (std::string_view name, value_types type, const std::vector< uint8_t > &raw_data)
	Construct from value_types and raw data (legacy compatibility)
	value (const value &other)
	Copy constructor (thread-safe)
	value (value &&other) noexcept
	Move constructor.
value &	operator= (const value &other)
	Copy assignment (thread-safe)
value &	operator= (value &&other) noexcept
	Move assignment.
std::string_view	name () const noexcept
	Get the name of this value (lock-free, immutable)
value_types	type () const
	Get the value_types enum (NOT variant::index()!)
size_t	variant_index () const
	Get variant index (for internal use only)
bool	is_null () const
	Check if null value.
template<concepts::ValueVariantType T>
std::optional< T >	get () const
	Type-safe getter with optional return.
template<concepts::ValueVariantType T>
void	set (T &&value)
	Type-safe setter.
template<concepts::ValueVisitor Visitor>
auto	visit (Visitor &&vis) const
	Apply visitor to contained value (const)
template<concepts::ValueVisitor Visitor>
auto	visit_mut (Visitor &&vis)
	Apply visitor to contained value (mutable)
std::string	to_string () const
	Convert to string representation.
std::string	to_json () const
	Convert to JSON representation.
std::vector< uint8_t >	serialize () const
	Serialize to binary format (legacy compatible)
size_t	read_count () const
	Get read/write statistics.
size_t	write_count () const
bool	operator== (const value &other) const
	Comparison operators (thread-safe)
bool	operator!= (const value &other) const
bool	operator< (const value &other) const

Static Public Member Functions
static std::optional< value >	deserialize (const std::vector< uint8_t > &data)
	Deserialize from binary format (legacy compatible)

Private Member Functions
void	serialize_data (std::vector< uint8_t > &result) const
	Serialize data portion based on type.

Static Private Member Functions
static bool	deserialize_data (value &result, value_types type, const std::vector< uint8_t > &data, size_t &offset)
	Deserialize data portion based on type.

Private Attributes
const std::string	name_
ValueVariant	data_
std::shared_mutex	mutex_
std::atomic< size_t >	read_count_ {0}
std::atomic< size_t >	write_count_ {0}

Detailed Description

Enhanced type-safe value with perfect legacy compatibility.

Key improvements over variant_value:

1. Type indices match value_types enum exactly
2. Support for array_value (type 15)
3. Platform-aware llong/ullong handling
4. Zero data loss on serialization round-trips
5. Backward compatible with legacy value system

Examples

value_store_example.cpp.

Definition at line 128 of file value.h.

Constructor & Destructor Documentation

value() [1/6]

kcenon::container::value::value ( )

inline

Default constructor - creates null value.

Definition at line 134 of file value.h.

: name_(""), data_(std::in_place_index<0>) {}

Referenced by deserialize_data(), to_json(), and to_string().

Here is the caller graph for this function:

value() [2/6]

kcenon::container::value::value ( std::string_view name )

inlineexplicit

Construct with name (null value)

Definition at line 139 of file value.h.

            : name_(name), data_(std::in_place_index<0>) {}

value() [3/6]

template<typename T >

kcenon::container::value::value ( std::string_view name, T && value )

inline

Construct with name and typed value.

Definition at line 146 of file value.h.

            : name_(name), data_(std::forward<T>(value)) {}

value() [4/6]

kcenon::container::value::value	(	std::string_view	name,
		value_types	type,
		const std::vector< uint8_t > &	raw_data )

Construct from value_types and raw data (legacy compatibility)

Definition at line 87 of file value.cpp.

        : name_(name), data_(std::in_place_index<0>)
    {
        // Construct variant from legacy type and raw data
        size_t offset = 0;
        if (!deserialize_data(*this, type, raw_data, offset)) {
            // Failed to deserialize, reset to null
            data_.emplace<0>();
        }
    }

References data_, deserialize_data(), and type().

Here is the call graph for this function:

value() [5/6]

kcenon::container::value::value

(

const value &

other

)

Copy constructor (thread-safe)

Definition at line 100 of file value.cpp.

        : name_(other.name_)
    {
        std::shared_lock lock(other.mutex_);
        data_ = other.data_;
    }

References data_, and mutex_.

value() [6/6]

kcenon::container::value::value ( value && other )

noexcept

Move constructor.

Definition at line 107 of file value.cpp.

        : name_(other.name_)
    {
        std::unique_lock lock(other.mutex_);
        data_ = std::move(other.data_);
        read_count_ = other.read_count_.load();
        write_count_ = other.write_count_.load();
        other.read_count_ = 0;
        other.write_count_ = 0;
    }

Member Function Documentation

deserialize()

std::optional< value > kcenon::container::value::deserialize ( const std::vector< uint8_t > & data )

static

Deserialize from binary format (legacy compatible)

Supports both:

• New value serialized data
• Legacy value class serialized data

Returns

std::optional containing value if deserialization succeeds

Definition at line 555 of file value.cpp.

                                                                        {
        if (data.size() < sizeof(uint32_t) + 1) {
            return std::nullopt;  // Too small: need at least name_len + type
        }
 
        size_t offset = 0;
 
        // Read name length
        uint32_t name_len;
        std::memcpy(&name_len, data.data() + offset, sizeof(name_len));
        offset += sizeof(name_len);
 
        if (offset + name_len + 1 > data.size()) {
            return std::nullopt;  // Invalid name length
        }
 
        // Read name
        std::string name(data.begin() + offset, data.begin() + offset + name_len);
        offset += name_len;
 
        // Read type byte
        uint8_t type_byte = data[offset++];
        value_types type = static_cast<value_types>(type_byte);
 
        // Validate type range
        if (type_byte > 15) {
            return std::nullopt;  // Invalid type
        }
 
        // Create result with name
        kcenon::container::value result(name);
 
        // Deserialize data based on type
        if (!deserialize_data(result, type, data, offset)) {
            return std::nullopt;
        }
 
        return result;
    }

References deserialize_data(), name(), and type().

Referenced by kcenon::container::clone_with_name(), kcenon::container::thread_safe_container::deserialize(), and deserialize_data().

Here is the call graph for this function:

Here is the caller graph for this function:

deserialize_data()

bool kcenon::container::value::deserialize_data ( value & result, value_types type, const std::vector< uint8_t > & data, size_t & offset )

staticprivate

Deserialize data portion based on type.

Definition at line 359 of file value.cpp.

                                                            {
        switch (type) {
            case value_types::null_value:
                result.data_.emplace<0>();  // null is at index 0
                return true;
 
            case value_types::bool_value:
                if (offset >= data.size()) return false;
                result.data_ = (data[offset++] != 0);
                return true;
 
            case value_types::short_value: {
                if (offset + sizeof(int16_t) > data.size()) return false;
                int16_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::ushort_value: {
                if (offset + sizeof(uint16_t) > data.size()) return false;
                uint16_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::int_value: {
                if (offset + sizeof(int32_t) > data.size()) return false;
                int32_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::uint_value: {
                if (offset + sizeof(uint32_t) > data.size()) return false;
                uint32_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::long_value: {
                if (offset + sizeof(int64_t) > data.size()) return false;
                int64_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::llong_value: {
                if (offset + sizeof(int64_t) > data.size()) return false;
#if defined(_MSC_VER) && _MSC_VER < 1900
                // Old MSVC (2013-): int64_t is __int64, long long is separate
                long long value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;  // Stored at index 8 (llong_value slot)
#else
                // Modern platforms (macOS, Linux, MSVC 2015+): int64_t == long long
                // llong_value uses same storage as long_value (int64_t)
                int64_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;  // Stored at index 6 (long_value slot)
#endif
                return true;
            }
 
            case value_types::ulong_value: {
                if (offset + sizeof(uint64_t) > data.size()) return false;
                uint64_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::ullong_value: {
                if (offset + sizeof(uint64_t) > data.size()) return false;
#if defined(_MSC_VER) && _MSC_VER < 1900
                // Old MSVC (2013-): uint64_t is unsigned __int64, unsigned long long is separate
                unsigned long long value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;  // Stored at index 9 (ullong_value slot)
#else
                // Modern platforms (macOS, Linux, MSVC 2015+): uint64_t == unsigned long long
                // ullong_value uses same storage as ulong_value (uint64_t)
                uint64_t value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;  // Stored at index 7 (ulong_value slot)
#endif
                return true;
            }
 
            case value_types::float_value: {
                if (offset + sizeof(float) > data.size()) return false;
                float value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::double_value: {
                if (offset + sizeof(double) > data.size()) return false;
                double value;
                std::memcpy(&value, data.data() + offset, sizeof(value));
                offset += sizeof(value);
                result.data_ = value;
                return true;
            }
 
            case value_types::bytes_value: {
                if (offset + sizeof(uint32_t) > data.size()) return false;
                uint32_t size;
                std::memcpy(&size, data.data() + offset, sizeof(size));
                offset += sizeof(size);
                if (offset + size > data.size()) return false;
                std::vector<uint8_t> bytes(data.begin() + offset,
                                          data.begin() + offset + size);
                offset += size;
                result.data_ = std::move(bytes);
                return true;
            }
 
            case value_types::string_value: {
                if (offset + sizeof(uint32_t) > data.size()) return false;
                uint32_t size;
                std::memcpy(&size, data.data() + offset, sizeof(size));
                offset += sizeof(size);
                if (offset + size > data.size()) return false;
                std::string str(data.begin() + offset, data.begin() + offset + size);
                offset += size;
                result.data_ = std::move(str);
                return true;
            }
 
            case value_types::container_value: {
                if (offset + sizeof(uint32_t) > data.size()) return false;
                uint32_t size;
                std::memcpy(&size, data.data() + offset, sizeof(size));
                offset += sizeof(size);
                if (size == 0) {
                    result.data_ = std::shared_ptr<thread_safe_container>(nullptr);
                    return true;
                }
                if (offset + size > data.size()) return false;
                std::vector<uint8_t> container_data(data.begin() + offset,
                                                    data.begin() + offset + size);
                offset += size;
                auto container = thread_safe_container::deserialize(container_data);
                result.data_ = container;
                return true;
            }
 
            case value_types::array_value: {
                if (offset + sizeof(uint32_t) > data.size()) return false;
                uint32_t count;
                std::memcpy(&count, data.data() + offset, sizeof(count));
                offset += sizeof(count);
 
                array_variant arr;
                arr.values.reserve(count);
 
                for (uint32_t i = 0; i < count; ++i) {
                    auto elem = deserialize(std::vector<uint8_t>(data.begin() + offset, data.end()));
                    if (!elem) return false;
 
                    // Update offset based on elem's serialized size
                    auto elem_size = elem->serialize().size();
                    offset += elem_size;
 
                    arr.values.push_back(std::make_shared<value>(std::move(*elem)));
                }
 
                result.data_ = std::move(arr);
                return true;
            }
 
            default:
                return false;
        }
    }

References data_, kcenon::container::thread_safe_container::deserialize(), deserialize(), type(), value(), and kcenon::container::array_variant::values.

Referenced by deserialize(), and value().

Here is the call graph for this function:

Here is the caller graph for this function:

get()

template<concepts::ValueVariantType T>

std::optional< T > kcenon::container::value::get ( ) const

inline

Type-safe getter with optional return.

Template Parameters

T	The type to retrieve (must be valid variant type)

Returns

std::optional containing value if type matches

Definition at line 213 of file value.h.

                                   {
            std::shared_lock lock(mutex_);
            if (auto* ptr = std::get_if<T>(&data_)) {
                return *ptr;
            }
            return std::nullopt;
        }

References data_, and mutex_.

is_null()

bool kcenon::container::value::is_null ( ) const

inline

Check if null value.

Definition at line 202 of file value.h.

                             {
            std::shared_lock lock(mutex_);
            return data_.index() == 0;
        }

References data_, and mutex_.

name()

std::string_view kcenon::container::value::name ( ) const

inlinenoexcept

Get the name of this value (lock-free, immutable)

Definition at line 177 of file value.h.

{ return name_; }

References name_.

Referenced by deserialize(), kcenon::container::thread_safe_container::set_variant(), and to_json().

Here is the caller graph for this function:

operator!=()

bool kcenon::container::value::operator!= ( const value & other ) const

inline

Definition at line 295 of file value.h.

{ return !(*this == other); }

operator<()

bool kcenon::container::value::operator<

(

const value &

other

)

const

Definition at line 601 of file value.cpp.

                                                  {
        if (this == &other) return false;
        std::scoped_lock lock(mutex_, other.mutex_);
        if (name_ != other.name_) return name_ < other.name_;
        return data_ < other.data_;
    }

References data_, mutex_, and name_.

operator=() [1/2]

value & kcenon::container::value::operator=

(

const value &

other

)

Copy assignment (thread-safe)

Definition at line 118 of file value.cpp.

                                              {
        if (this != &other) {
            std::unique_lock lock(mutex_);
            std::shared_lock other_lock(other.mutex_);
            data_ = other.data_;
            write_count_.fetch_add(1, std::memory_order_relaxed);
        }
        return *this;
    }

References data_, mutex_, and write_count_.

operator=() [2/2]

value & kcenon::container::value::operator= ( value && other )

noexcept

Move assignment.

Definition at line 128 of file value.cpp.

                                                  {
        if (this != &other) {
            std::unique_lock lock(mutex_);
            std::unique_lock other_lock(other.mutex_);
            data_ = std::move(other.data_);
            write_count_.fetch_add(1, std::memory_order_relaxed);
        }
        return *this;
    }

operator==()

bool kcenon::container::value::operator==

(

const value &

other

)

const

Comparison operators (thread-safe)

Definition at line 595 of file value.cpp.

                                                   {
        if (this == &other) return true;
        std::scoped_lock lock(mutex_, other.mutex_);
        return name_ == other.name_ && data_ == other.data_;
    }

References data_, mutex_, and name_.

read_count()

size_t kcenon::container::value::read_count ( ) const

inline

Get read/write statistics.

Definition at line 288 of file value.h.

{ return read_count_.load(std::memory_order_relaxed); }

References read_count_.

serialize()

std::vector< uint8_t > kcenon::container::value::serialize

(

)

const

Serialize to binary format (legacy compatible)

Wire format: [name_len:4][name:UTF-8][type:1][data:variable]

Type byte matches value_types enum EXACTLY (0-15)

Definition at line 339 of file value.cpp.

                                              {
        std::vector<uint8_t> result;
 
        // Header: [name_length:4][name:UTF-8][type:1]
        uint32_t name_len = static_cast<uint32_t>(name_.size());
        result.insert(result.end(),
                     reinterpret_cast<const uint8_t*>(&name_len),
                     reinterpret_cast<const uint8_t*>(&name_len) + sizeof(name_len));
        result.insert(result.end(), name_.begin(), name_.end());
 
        // Type byte: use value_types enum value (0-15)
        uint8_t type_byte = static_cast<uint8_t>(type());
        result.push_back(type_byte);
 
        // Data: type-specific serialization
        serialize_data(result);
 
        return result;
    }

References name_, serialize_data(), and type().

Referenced by kcenon::container::clone_with_name(), kcenon::container::thread_safe_container::serialize(), and serialize_data().

Here is the call graph for this function:

Here is the caller graph for this function:

serialize_data()

void kcenon::container::value::serialize_data ( std::vector< uint8_t > & result ) const

private

Serialize data portion based on type.

Definition at line 259 of file value.cpp.

                                                               {
        visit([&result](auto&& val) {
            using T = std::decay_t<decltype(val)>;
 
            if constexpr (std::is_same_v<T, std::monostate>) {
                // Null val: no data
            }
            else if constexpr (std::is_same_v<T, bool>) {
                result.push_back(val ? 1 : 0);
            }
            else if constexpr (std::is_same_v<T, std::vector<uint8_t>>) {
                // Bytes: [length:4][data:length]
                uint32_t size = static_cast<uint32_t>(val.size());
                result.insert(result.end(),
                             reinterpret_cast<const uint8_t*>(&size),
                             reinterpret_cast<const uint8_t*>(&size) + sizeof(size));
                result.insert(result.end(), val.begin(), val.end());
            }
            else if constexpr (std::is_arithmetic_v<T> && !std::is_same_v<T, bool>) {
                // Numeric: raw bytes
                result.insert(result.end(),
                             reinterpret_cast<const uint8_t*>(&val),
                             reinterpret_cast<const uint8_t*>(&val) + sizeof(T));
            }
            else if constexpr (std::is_same_v<T, std::string>) {
                // String: [length:4][UTF-8 data:length]
                uint32_t size = static_cast<uint32_t>(val.size());
                result.insert(result.end(),
                             reinterpret_cast<const uint8_t*>(&size),
                             reinterpret_cast<const uint8_t*>(&size) + sizeof(size));
                result.insert(result.end(), val.begin(), val.end());
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<thread_safe_container>>) {
                // Container: [serialized_size:4][serialized_data:size]
                if (val) {
                    // Check for circular reference
                    detail::circular_ref_guard guard(val.get());
                    if (guard.is_circular()) {
                        // Circular reference detected - serialize as null container
                        uint32_t size = 0;
                        result.insert(result.end(),
                                     reinterpret_cast<const uint8_t*>(&size),
                                     reinterpret_cast<const uint8_t*>(&size) + sizeof(size));
                    } else {
                        auto container_data = val->serialize();
                        uint32_t size = static_cast<uint32_t>(container_data.size());
                        result.insert(result.end(),
                                     reinterpret_cast<const uint8_t*>(&size),
                                     reinterpret_cast<const uint8_t*>(&size) + sizeof(size));
                        result.insert(result.end(), container_data.begin(), container_data.end());
                    }
                } else {
                    uint32_t size = 0;
                    result.insert(result.end(),
                                 reinterpret_cast<const uint8_t*>(&size),
                                 reinterpret_cast<const uint8_t*>(&size) + sizeof(size));
                }
            }
            else if constexpr (std::is_same_v<T, array_variant>) {
                // Array: [count:4][value1_serialized][value2_serialized]...
                uint32_t count = static_cast<uint32_t>(val.values.size());
                result.insert(result.end(),
                             reinterpret_cast<const uint8_t*>(&count),
                             reinterpret_cast<const uint8_t*>(&count) + sizeof(count));
 
                for (const auto& elem : val.values) {
                    if (elem) {
                        auto elem_data = elem->serialize();
                        result.insert(result.end(), elem_data.begin(), elem_data.end());
                    } else {
                        // Null element: serialize as null_value with empty name
                        kcenon::container::value null_elem("");
                        auto null_data = null_elem.serialize();
                        result.insert(result.end(), null_data.begin(), null_data.end());
                    }
                }
            }
        });
    }

References kcenon::container::detail::circular_ref_guard::is_circular(), serialize(), and visit().

Referenced by serialize().

Here is the call graph for this function:

Here is the caller graph for this function:

set()

template<concepts::ValueVariantType T>

void kcenon::container::value::set ( T && value )

inline

Type-safe setter.

Template Parameters

T	The type to store (must be valid variant type)

Definition at line 226 of file value.h.

                            {
            std::unique_lock lock(mutex_);
            data_ = std::forward<T>(value);
            write_count_.fetch_add(1, std::memory_order_relaxed);
        }

References data_, mutex_, and write_count_.

to_json()

std::string kcenon::container::value::to_json

(

)

const

Convert to JSON representation.

Definition at line 186 of file value.cpp.

                                   {
        auto var_name = name();
        auto var_type = type();
 
        return visit([var_name, var_type](auto&& value) -> std::string {
            using T = std::decay_t<decltype(value)>;
 
            // Manual JSON header formatting (no std::format dependency)
            std::string result = "{\"name\":\"" + std::string(var_name) +
                                "\",\"type\":" + std::to_string(static_cast<int>(var_type)) +
                                ",\"value\":";
 
            if constexpr (std::is_same_v<T, std::monostate>) {
                result += "null";
            }
            else if constexpr (std::is_same_v<T, bool>) {
                result += value ? "true" : "false";
            }
            else if constexpr (std::is_same_v<T, std::vector<uint8_t>>) {
                result += "\"";
                std::ostringstream oss;
                oss << std::hex << std::setfill('0');
                for (auto byte : value) {
                    oss << std::setw(2) << static_cast<int>(byte);
                }
                result += oss.str();
                result += "\"";
            }
            else if constexpr (std::is_arithmetic_v<T>) {
                result += std::to_string(value);
            }
            else if constexpr (std::is_same_v<T, std::string>) {
                // Escape string for JSON
                result += "\"";
                for (char c : value) {
                    switch (c) {
                        case '"': result += "\\\""; break;
                        case '\\': result += "\\\\"; break;
                        case '\b': result += "\\b"; break;
                        case '\f': result += "\\f"; break;
                        case '\n': result += "\\n"; break;
                        case '\r': result += "\\r"; break;
                        case '\t': result += "\\t"; break;
                        default:
                            if (c >= 0x20 && c <= 0x7E) {
                                result += c;
                            } else {
                                // Manual Unicode escape formatting (no std::format dependency)
                                char buf[7];  // "\uXXXX" + null terminator
                                std::snprintf(buf, sizeof(buf), "\\u%04x", static_cast<unsigned char>(c));
                                result += buf;
                            }
                    }
                }
                result += "\"";
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<thread_safe_container>>) {
                result += value ? value->to_json() : "null";
            }
            else if constexpr (std::is_same_v<T, array_variant>) {
                result += "[";
                for (size_t i = 0; i < value.values.size(); ++i) {
                    if (i > 0) result += ",";
                    result += value.values[i] ? value.values[i]->to_json() : "null";
                }
                result += "]";
            }
 
            result += "}";
            return result;
        });
    }

References name(), to_json(), type(), value(), and visit().

Referenced by kcenon::container::thread_safe_container::to_json(), to_json(), and to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

to_string()

std::string kcenon::container::value::to_string

(

)

const

Convert to string representation.

Definition at line 146 of file value.cpp.

                                     {
        return visit([](auto&& value) -> std::string {
            using T = std::decay_t<decltype(value)>;
 
            if constexpr (std::is_same_v<T, std::monostate>) {
                return "null";
            }
            else if constexpr (std::is_same_v<T, bool>) {
                return value ? "true" : "false";
            }
            else if constexpr (std::is_same_v<T, std::vector<uint8_t>>) {
                std::ostringstream oss;
                oss << std::hex << std::setfill('0');
                for (auto byte : value) {
                    oss << std::setw(2) << static_cast<int>(byte);
                }
                return oss.str();
            }
            else if constexpr (std::is_arithmetic_v<T>) {
                return std::to_string(value);
            }
            else if constexpr (std::is_same_v<T, std::string>) {
                return value;
            }
            else if constexpr (std::is_same_v<T, std::shared_ptr<thread_safe_container>>) {
                return value ? value->to_json() : "null";
            }
            else if constexpr (std::is_same_v<T, array_variant>) {
                std::string result = "[";
                for (size_t i = 0; i < value.values.size(); ++i) {
                    if (i > 0) result += ",";
                    result += value.values[i] ? value.values[i]->to_string() : "null";
                }
                result += "]";
                return result;
            }
            return "";
        });
    }

References to_json(), to_string(), value(), and visit().

Referenced by to_string().

Here is the call graph for this function:

Here is the caller graph for this function:

type()

value_types kcenon::container::value::type

(

)

const

Get the value_types enum (NOT variant::index()!)

IMPORTANT: This returns the logical type, which matches:

• value_types enum (0-15)
• Wire format type byte
• Legacy system type

On platforms where llong == int64_t, llong_value returns as long_value.

Definition at line 138 of file value.cpp.

                                  {
        std::shared_lock lock(mutex_);
        // Direct mapping: variant index == value_types enum value
        // Positions 6-9 now use unaliased fundamental types (long, unsigned long,
        // long long, unsigned long long) so direct index cast is always correct.
        return static_cast<value_types>(data_.index());
    }

References data_, and mutex_.

Referenced by deserialize(), deserialize_data(), kcenon::container::same_type(), serialize(), to_json(), kcenon::container::type_name(), and value().

Here is the caller graph for this function:

variant_index()

size_t kcenon::container::value::variant_index ( ) const

inline

Get variant index (for internal use only)

Definition at line 194 of file value.h.

                                     {
            std::shared_lock lock(mutex_);
            return data_.index();
        }

References data_, and mutex_.

visit()

template<concepts::ValueVisitor Visitor>

auto kcenon::container::value::visit ( Visitor && vis ) const

inline

Apply visitor to contained value (const)

Template Parameters

Visitor

The visitor callable type

Definition at line 237 of file value.h.

                                        {
            std::shared_lock lock(mutex_);
            read_count_.fetch_add(1, std::memory_order_relaxed);
            return std::visit(std::forward<Visitor>(vis), data_);
        }

References data_, mutex_, and read_count_.

Referenced by serialize_data(), to_json(), and to_string().

Here is the caller graph for this function:

visit_mut()

template<concepts::ValueVisitor Visitor>

auto kcenon::container::value::visit_mut ( Visitor && vis )

inline

Apply visitor to contained value (mutable)

Template Parameters

Visitor

The visitor callable type

Definition at line 248 of file value.h.

                                      {
            std::unique_lock lock(mutex_);
            write_count_.fetch_add(1, std::memory_order_relaxed);
            return std::visit(std::forward<Visitor>(vis), data_);
        }

References data_, mutex_, and write_count_.

write_count()

size_t kcenon::container::value::write_count ( ) const

inline

Definition at line 289 of file value.h.

{ return write_count_.load(std::memory_order_relaxed); }

References write_count_.

Member Data Documentation

data_

ValueVariant kcenon::container::value::data_

private

Definition at line 313 of file value.h.

Referenced by deserialize_data(), get(), is_null(), operator<(), operator=(), operator==(), set(), type(), value(), value(), variant_index(), visit(), and visit_mut().

mutex_

std::shared_mutex kcenon::container::value::mutex_

mutableprivate

Definition at line 314 of file value.h.

Referenced by get(), is_null(), operator<(), operator=(), operator==(), set(), type(), value(), variant_index(), visit(), and visit_mut().

name_

const std::string kcenon::container::value::name_

private

Definition at line 312 of file value.h.

Referenced by name(), operator<(), operator==(), and serialize().

read_count_

std::atomic<size_t> kcenon::container::value::read_count_ {0}

mutableprivate

Definition at line 315 of file value.h.

{0};

Referenced by read_count(), and visit().

write_count_

std::atomic<size_t> kcenon::container::value::write_count_ {0}

mutableprivate

Definition at line 316 of file value.h.

{0};

Referenced by operator=(), set(), visit_mut(), and write_count().

---

The documentation for this class was generated from the following files:

• internal/value.h
• internal/value.cpp