value_type.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_VALUE_TYPE_HPP
#define CEL_RUNTIME_VALUE_TYPE_HPP
 
#include <cel/runtime/layout.hpp>
 
#include <memory>
#include <span>
#include <string>
#include <string_view>
#include <type_traits>
#include <typeindex>
 
namespace cel {

enum class range_kind {
    range,              
    range_from,         
    range_to,           
    range_to_inclusive, 
    range_inclusive,    
    range_full          
};

enum class type_kind {
    leaf,    
    array,   
    tuple,   
    record,  
    range,   
    callable 
};
 
struct record_field;
namespace detail {
struct type_plan;
struct type_access;
} // namespace detail

class value_type {
    friend struct detail::type_access;
    std::shared_ptr<const detail::type_plan> _plan;

    explicit value_type(std::shared_ptr<const detail::type_plan> plan);
    static value_type make_leaf(std::type_index identity, layout bytes);
    static void release_plan(std::shared_ptr<const detail::type_plan>& plan) noexcept;
 
public:
    value_type();
    value_type(const value_type&) noexcept = default;
    value_type(value_type&& other) noexcept : _plan(other._plan) {}
    value_type& operator=(const value_type& other) noexcept;
    value_type& operator=(value_type&& other) noexcept {
        return *this = static_cast<const value_type&>(other);
    }

    ~value_type();

    template <class T>
    static value_type leaf() {
        static_assert(std::is_trivially_copyable_v<T>,
                      "opaque CEL leaves must be trivially copyable");
        static const value_type descriptor = make_leaf(typeid(T), {sizeof(T), alignof(T)});
        return descriptor;
    }

    static value_type array(value_type element);
    static value_type tuple(std::span<const value_type> fields);
    static value_type record(std::string_view identity, std::span<const record_field> fields);
    static value_type range(range_kind form, value_type endpoint);
    static value_type callable(std::span<const value_type> parameters, value_type result);
    bool same_shape(const value_type& other) const;
    bool compatible_with(const value_type& other) const;
    type_kind kind() const noexcept;
    layout byte_layout() const noexcept;
    bool owns_values() const noexcept;
    std::type_index leaf_identity() const;
    const value_type& element() const;
    std::span<const value_type> fields() const;
    std::span<const std::size_t> offsets() const;
    std::string_view record_identity() const;
    std::span<const std::string> field_names() const;
    range_kind form() const;
    std::span<const value_type> parameters() const;
    const value_type& result() const;
};

struct record_field {
    std::string name; 
    value_type type;  
};

value_type bind_runtime_ownership(const value_type& type);

} // namespace cel
#endif