frame.hpp

// SPDX-License-Identifier: BSL-1.0
#ifndef CEL_RUNTIME_DETAIL_FRAME_HPP
#define CEL_RUNTIME_DETAIL_FRAME_HPP
#include <cel/runtime/raw_stack.hpp>
 
namespace cel::detail {
struct borrowed_value {
    const value_type& type; 
    const std::byte* data;  
private:
    void require_type(const value_type& expected) const;
 
public:
    template <class T>
    T as() const {
        const auto expected = detail::concrete_adapter<T>::type();
        require_type(expected);
        return detail::concrete_adapter<T>::read(type, data);
    }
};

class frame {
    raw_stack* _stack;
    frame* _parent;
    std::size_t _checkpoint;
    std::span<const value> _arguments;
    std::span<const borrowed_value> _canonical_arguments;
    const void* _context;
    friend class raw_segment;
    friend class raw_stack;
    friend struct detail::frame_access;

    void require_active() const;
    void reset() noexcept;
    template <class T>
    T read_operand(std::size_t from_top, const value_type& expected) const {
        return detail::concrete_adapter<T>::read(
            expected, _stack->borrow_trusted(_checkpoint, from_top, expected));
    }
    template <class... T, std::size_t... I>
    std::tuple<T...> acquire_operands(const std::array<value_type, sizeof...(T)>& types,
                                      std::index_sequence<I...>) const {
        require_active();
        raw_stack::phase_guard phase(*_stack);
        return {read_operand<T>(sizeof...(T) - 1 - I, types[I])...};
    }
    void discard(std::size_t count);
    template <class T>
    void push_result(const value_type& type, const T& source) {
        require_active();
        _stack->push_written(
            type, &source, [](const void* input, const value_type& shape, std::byte* destination) {
                detail::concrete_adapter<T>::write(*static_cast<const T*>(input), shape,
                                                   destination);
            });
    }
 
public:
    explicit frame(raw_stack& stack,
                   std::span<const value> arguments = {},
                   const void* context = nullptr);
    frame(raw_stack& stack,
          std::span<const borrowed_value> arguments,
          const void* context = nullptr);
    ~frame();
    frame(const frame&) = delete;
    frame& operator=(const frame&) = delete;
    frame(frame&&) = delete;
    frame& operator=(frame&&) = delete;
    std::size_t depth() const noexcept;
    raw_stack& stack() const noexcept { return *_stack; }
    std::span<const value> arguments() const noexcept { return _arguments; }
    std::span<const borrowed_value> canonical_arguments() const noexcept {
        return _canonical_arguments;
    }
    borrowed_value argument(std::size_t index) const;
    const void* context() const noexcept { return _context; }
    void push_argument(std::size_t index);
    template <class T>
    void push(const T& source) {
        push_result(detail::concrete_adapter<T>::type(), source);
    }
    template <class T>
    T pop() {
        require_active();
        auto result = _stack->read_value<T>(_checkpoint);
        discard(1);
        return result;
    }
    void push_clone(const value& source);
    void push_take(value& source);
    value pop_value();
};
} // namespace cel::detail
#endif