Enum ScratchBuf 

pub enum ScratchBuf {
    F32(Vec<f32>),
    F64(Vec<f64>),
    F16(Vec<f16>),
    I8(Vec<i8>),
    I16(Vec<i16>),
    I32(Vec<i32>),
    I64(Vec<i64>),
    Str(Vec<u8>),
    Bytes(Vec<u8>),
    Value(Vec<Value>),
    Slots(Vec<u64>),
    Kernels(BodyKernels),
    State(NodeState),
}

One kernel-owned scratch buffer. A Ref2 output port’s (ptr, len) buffer slots view its scratch — the kernel owns the allocation, so the pointer is valid exactly as long as the producing step doesn’t rerun (and a rerun rewrites the slots before any consumer reads them). No Arc traffic, no allocation after warmup: a string or byte string is rewritten in place, a value is replaced.

Variants

F32(Vec<f32>)

An f32 buffer.

F64(Vec<f64>)

An f64 buffer.

F16(Vec<f16>)

An f16 buffer.

I8(Vec<i8>)

An i8 buffer.

I16(Vec<i16>)

An i16 buffer.

I32(Vec<i32>)

An i32 buffer.

I64(Vec<i64>)

An i64 buffer.

Str(Vec<u8>)

The UTF-8 bytes of a string.

Bytes(Vec<u8>)

The bytes of a byte string.

Value(Vec<Value>)

One value held by reference; empty until the step first runs.

Slots(Vec<u64>)

A buffer of 64-bit slots (a native cone’s own).

Kernels(BodyKernels)

The kernels a tile render keeps over its projection bodies. A clone is empty: a new state builds its own.

State(NodeState)

State a node defines for itself, per kernel state. A clone is empty: a new state derives its own.

Implementations

impl ScratchBuf

pub fn ptr_len(&self) -> (u64, u64)

The (ptr, len) pair this entry currently publishes — the ground truth axiom S9(a)’s validator compares buffer slots against.

pub fn to_value(&self) -> Value

What this entry holds as an owned Value, copied out: the typed read of a Ref2 output on a compiled kernel, which is what the interpreter’s pull returns for the same port. A value entry that has not been written reads as None.

pub fn node_state(&mut self) -> &mut NodeState

The node-defined state this entry holds. The entry must be a State entry.

pub fn set_str(&mut self, s: &str)

Replace the string this entry holds, reusing its allocation. The entry must be a Str entry.

pub fn set_bytes(&mut self, b: &[u8])

Replace the byte string this entry holds, reusing its allocation. The entry must be a Bytes entry.

pub fn set_from_value(&mut self, v: &Value)

Fill this entry from v, whatever kind of entry it is.

The entry’s own variant decides, and it was allocated from the step’s declared ScratchElem — so the type the graph resolved picks the write, rather than a match over Value that has to be extended every time the language grows a carrier. A value that does not fit the entry is a graph that mis-typed the slot, and the inner setters say so.

pub fn set_vector(&mut self, value: &Value)

Replace the numeric vector this entry holds, reusing its allocation. The entry must be the matching element type.

The typed write path reaches a vector entry through the node’s declared element type; this is the same write for the path that only has a Value in hand (crate::derive_support::write_poly), which is how a vector reaches a polymorphic node’s output.

pub fn set_value(&mut self, value: Value)

Replace the value this entry holds. The entry must be a Value entry.

pub fn set_ref_value(&mut self, value: Value)

Replace the value this entry holds with a by-reference value that may be None. A None leaves the entry empty, so its pair has length zero, which is how a Ref2 slot reads None. The entry must be a Value entry.

pub fn new(elem: ScratchElem) -> Self

An empty buffer of the element type.

Trait Implementations

impl Clone for ScratchBuf

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ScratchBuf

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.