variant_value_factory.h

Go to the documentation of this file.

/*****************************************************************************
BSD 3-Clause License
 
Copyright (c) 2024, 🍀☀🌕🌥 🌊
All rights reserved.
*****************************************************************************/
 
#pragma once
 
#include "value.h"
#include "core/value_types.h"
#include "core/concepts.h"
#include <string>
#include <string_view>
#include <vector>
#include <memory>
#include <type_traits>
#include <concepts>
 
namespace kcenon::container
{
    // ============================================================================
    // Modern Factory API (Recommended)
    // ============================================================================
 
    namespace factory
    {
        template<typename T>
        inline value make(std::string_view name, T&& val) {
            return value(name, std::forward<T>(val));
        }
 
        inline value make_null(std::string_view name = "") {
            return value(name);
        }
 
        inline value make_array(std::string_view name,
                               std::vector<std::shared_ptr<value>> values) {
            array_variant arr;
            arr.values = std::move(values);
            return value(name, std::move(arr));
        }
 
        inline value make_array(
            std::string_view name,
            std::initializer_list<value> values)
        {
            array_variant arr;
            arr.values.reserve(values.size());
            for (const auto& v : values) {
                arr.values.push_back(std::make_shared<value>(v));
            }
            return value(name, std::move(arr));
        }
 
        inline value make_empty_array(std::string_view name) {
            return value(name, array_variant{});
        }
 
        inline value make_container(std::string_view name,
                                   std::shared_ptr<thread_safe_container> container) {
            return value(name, std::move(container));
        }
 
        inline value make_bytes(std::string_view name,
                               const uint8_t* data,
                               size_t size) {
            return value(name, std::vector<uint8_t>(data, data + size));
        }
 
        inline value make_bytes_from_string(std::string_view name, std::string_view data) {
            return value(name, std::vector<uint8_t>(
                reinterpret_cast<const uint8_t*>(data.data()),
                reinterpret_cast<const uint8_t*>(data.data() + data.size())
            ));
        }
 
    } // namespace factory
 
    // ============================================================================
    // Type-based factory (runtime type selection)
    // ============================================================================
 
    inline value make_value_from_raw(std::string_view name,
                                                value_types type,
                                                const std::vector<uint8_t>& raw_data) {
        return value(name, type, raw_data);
    }
 
    // ============================================================================
    // Utility functions
    // ============================================================================
 
    inline value clone_with_name(const value& original,
                                           std::string_view new_name) {
        // Serialize and deserialize to create a deep copy, then change name
        auto serialized = original.serialize();
        auto cloned = value::deserialize(serialized);
        if (!cloned) {
            throw std::runtime_error("Failed to clone value");
        }
 
        // Create new value with same data but different name
        return value(new_name, cloned->type(), serialized);
    }
 
    inline bool same_type(const value& a, const value& b) {
        return a.type() == b.type();
    }
 
    inline std::string_view type_name(const value& value) {
        switch (value.type()) {
            case value_types::null_value: return "null";
            case value_types::bool_value: return "bool";
            case value_types::short_value: return "short";
            case value_types::ushort_value: return "ushort";
            case value_types::int_value: return "int";
            case value_types::uint_value: return "uint";
            case value_types::long_value: return "long";
            case value_types::ulong_value: return "ulong";
            case value_types::llong_value: return "llong";
            case value_types::ullong_value: return "ullong";
            case value_types::float_value: return "float";
            case value_types::double_value: return "double";
            case value_types::bytes_value: return "bytes";
            case value_types::string_value: return "string";
            case value_types::container_value: return "container";
            case value_types::array_value: return "array";
            default: return "unknown";
        }
    }
 
} // namespace kcenon::container