value.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_VALUE_HPP
#define CEL_RUNTIME_VALUE_HPP
 
#include <cel/runtime/value_type.hpp>
 
#include <array>
#include <bit>
#include <cassert>
#include <cstring>
#include <memory>
#include <span>
#include <stdexcept>
#include <tuple>
#include <utility>
#include <vector>
 
namespace cel {

namespace detail {
struct owned_payload;
struct value_access;
struct array_view {
    const value_type& element; 
    const std::byte* data;     
    std::size_t size;          
    std::size_t stride;        
};
template <class T>
struct concrete_adapter;
} // namespace detail

// [knowledge] Never byte-relocate public wrappers; only private canonical carriers transfer owners.
class value {
    std::unique_ptr<detail::owned_payload> _payload;
    friend struct detail::value_access;
    template <class T>
    friend struct detail::concrete_adapter;

    explicit value(std::unique_ptr<detail::owned_payload> payload);
    static value from_leaf(value_type type, const void* source);
    void copy_leaf(const value_type& expected, void* destination) const;
    static value aggregate(value_type type, std::span<const value> fields);
    static value array_owned(value_type element, std::span<value> children);
    static const std::byte* raw_data(const value& owner) noexcept;
    static detail::array_view array_data(const std::byte* data) noexcept;
    static value from_concrete(value_type type,
                               const void* source,
                               void (*write)(const void*, const value_type&, std::byte*));
    static void write_array(const value_type& element,
                            std::byte* destination,
                            std::size_t count,
                            const void* source,
                            void (*write)(const void*, std::size_t, const value_type&, std::byte*));
    static void destroy_fields(const value_type& type, std::byte* data, std::size_t count) noexcept;
 
public:
    value() noexcept;
    ~value();
    value(const value& other);
    value(value&& other) noexcept;
    value& operator=(const value& other);
    value& operator=(value&& other) noexcept;
    const value_type& type() const;
    template <class T>
    static value from(const T& source) {
        return detail::concrete_adapter<std::remove_cv_t<T>>::from(source);
    }

    template <class T>
    T as() const {
        return detail::concrete_adapter<std::remove_cv_t<T>>::as(*this);
    }

    static value array(value_type element, std::span<const value> elements);
    static value tuple(std::span<const value> fields);
    static value record(value_type type, std::span<const value> fields);
    static value range(value_type type, std::span<const value> endpoints);
    std::size_t size() const;
    value at(std::size_t index) const;
    void set(std::size_t index, const value& replacement);
    value field(std::string_view name) const;
    void set_field(std::string_view name, const value& replacement);
};
 
namespace detail {

template <class T>
struct concrete_adapter {
    static value_type type() { return value_type::leaf<T>(); }
    static value from(const T& source) { return value::from_leaf(type(), &source); }
    static T as(const value& source) {
        std::array<std::byte, sizeof(T)> bytes{};
        source.copy_leaf(type(), bytes.data());
        return std::bit_cast<T>(bytes);
    }
    static T read(const value_type&, const std::byte* data) {
        assert(data != nullptr);
        std::array<std::byte, sizeof(T)> bytes{};
        std::memcpy(bytes.data(), data, bytes.size());
        return std::bit_cast<T>(bytes);
    }
    static void write(const T& source, const value_type&, std::byte* data) {
        static_assert(std::is_trivially_copyable_v<T>);
        std::memcpy(data, &source, sizeof(T));
    }
};

template <class T, class Allocator>
struct concrete_adapter<std::vector<T, Allocator>> {
    static value_type type() {
        static const auto descriptor = value_type::array(concrete_adapter<T>::type());
        return descriptor;
    }
    static value from(const std::vector<T, Allocator>& source) {
        return value::from_concrete(
            type(), &source, [](const void* object, const value_type& shape, std::byte* data) {
                write(*static_cast<const std::vector<T, Allocator>*>(object), shape, data);
            });
    }
    static void write(const std::vector<T, Allocator>& source,
                      const value_type& shape,
                      std::byte* data) {
        value::write_array(shape.element(), data, source.size(), &source,
                           [](const void* object, std::size_t index, const value_type& element,
                              std::byte* target) {
                               const auto& input =
                                   *static_cast<const std::vector<T, Allocator>*>(object);
                               concrete_adapter<T>::write(input[index], element, target);
                           });
    }
    static std::vector<T, Allocator> as(const value& source) {
        if (!source.type().same_shape(type())) throw std::invalid_argument("wrong vector type");
        return read(source.type(), value::raw_data(source));
    }
    static std::vector<T, Allocator> read(const value_type&, const std::byte* data) {
        std::vector<T, Allocator> result;
        const auto children = value::array_data(data);
        result.reserve(children.size);
        // Extract each element through its trusted concrete adapter.
        for (std::size_t i = 0; i != children.size; ++i)
            result.push_back(concrete_adapter<T>::read(
                children.element, children.data ? children.data + i * children.stride : nullptr));
        return result;
    }
};

template <class... T>
struct concrete_adapter<std::tuple<T...>> {
    static value_type type() {
        static const auto descriptor = [] {
            const std::array<value_type, sizeof...(T)> fields{concrete_adapter<T>::type()...};
            return value_type::tuple(fields);
        }();
        return descriptor;
    }
    static value from(const std::tuple<T...>& source) {
        return value::from_concrete(
            type(), &source, [](const void* object, const value_type& shape, std::byte* data) {
                write(*static_cast<const std::tuple<T...>*>(object), shape, data);
            });
    }
    template <std::size_t... I>
    static void write_fields(const std::tuple<T...>& source,
                             const value_type& shape,
                             std::byte* data,
                             std::index_sequence<I...>) {
        std::size_t completed = 0;
        try {
            ((concrete_adapter<T>::write(std::get<I>(source), shape.fields()[I],
                                         data ? data + shape.offsets()[I] : nullptr),
              ++completed),
             ...);
        } catch (...) {
            value::destroy_fields(shape, data, completed);
            throw;
        }
    }
    static void write(const std::tuple<T...>& source, const value_type& shape, std::byte* data) {
        write_fields(source, shape, data, std::index_sequence_for<T...>{});
    }
    template <std::size_t... I>
    static std::tuple<T...> extract(const value_type& shape,
                                    const std::byte* data,
                                    std::index_sequence<I...>) {
        return {concrete_adapter<T>::read(shape.fields()[I],
                                          data ? data + shape.offsets()[I] : nullptr)...};
    }
    static std::tuple<T...> as(const value& source) {
        if (!source.type().same_shape(type())) throw std::invalid_argument("wrong tuple type");
        return read(source.type(), value::raw_data(source));
    }
    static std::tuple<T...> read(const value_type& shape, const std::byte* data) {
        return extract(shape, data, std::index_sequence_for<T...>{});
    }
};
 
} // namespace detail
template <class T>
value_type native_type() {
    return detail::concrete_adapter<std::remove_cvref_t<T>>::type();
}

} // namespace cel
#endif