Struct SinkNode 

pub struct SinkNode<S, InP, const IN: usize>
where
    S: Sink<InP, IN>,
    InP: Payload,
{ /* private fields */ }

A thin adapter that exposes a Sink as a Node<IN, 0, InP, ()>.

Owns the sink and forwards lifecycle calls. Users do not construct this directly — graphs can accept impl Into<SinkNode<...>> and rely on From<S>.

Implementations

impl<S, InP, const IN: usize> SinkNode<S, InP, IN>

where S: Sink<InP, IN>, InP: Payload,

pub const fn new(sink: S, policy: NodePolicy) -> Self

Construct a SinkNode from a sink and a static policy bundle.

pub fn sink_ref(&self) -> &S

Borrow the underlying sink.

pub fn sink_mut(&mut self) -> &mut S

Mutably borrow the underlying sink.

Trait Implementations

impl<S, InP, const IN: usize> From<S> for SinkNode<S, InP, IN>

where S: Sink<InP, IN>, InP: Payload,

Allow graphs to accept any Sink and convert implicitly.

fn from(sink: S) -> Self

Converts to this type from the input type.

impl<S, InP, const IN: usize> Node<IN, 0, InP, ()> for SinkNode<S, InP, IN>

where S: Sink<InP, IN>, InP: Payload + Copy,

fn set_policy(&mut self, policy: NodePolicy)

TEST ONLY method used to override batching policies for node contract tests.

fn describe_capabilities(&self) -> NodeCapabilities

Return the node’s capability descriptor.

fn input_acceptance(&self) -> [PlacementAcceptance; IN]

Return the node’s port placement acceptances (zero-copy compatibility).

fn output_acceptance(&self) -> [PlacementAcceptance; 0]

Return the node’s output placement preferences (zero-copy compatibility).

fn policy(&self) -> NodePolicy

Return the node’s policy bundle.

fn node_kind(&self) -> NodeKind

Return the type of node (Model, processing, source, sink).

fn initialize<C, T>(&mut self, _c: &C, _t: &mut T) -> Result<(), NodeError>

where T: Telemetry,

Prepare internal state, acquire buffers, and register telemetry series.

fn start<C, T>(&mut self, _c: &C, _t: &mut T) -> Result<(), NodeError>

where T: Telemetry,

Optional warm-up (e.g., compile kernels, prime pools). Default: no-op.

fn process_message<C>( &mut self, msg: &Message<InP>, _sys_clock: &C, ) -> Result<ProcessResult<()>, NodeError>

where C: PlatformClock + Sized,

Per-message processing hook.

fn step<'g, 't, 'ck, InQ, OutQ, InM, OutM, C, Tel>( &mut self, cx: &mut StepContext<'g, 't, 'ck, IN, 0, InP, (), InQ, OutQ, InM, OutM, C, Tel>, ) -> Result<StepResult, NodeError>

where InQ: Edge, OutQ: Edge, InM: MemoryManager<InP>, OutM: MemoryManager<()>, C: PlatformClock + Sized, Tel: Telemetry + Sized,

Execute one cooperative step using the provided context.

fn step_batch<'graph, 'telemetry, 'clock, InQ, OutQ, InM, OutM, C, Tel>( &mut self, ctx: &mut StepContext<'graph, 'telemetry, 'clock, IN, 0, InP, (), InQ, OutQ, InM, OutM, C, Tel>, ) -> Result<StepResult, NodeError>

where InQ: Edge, OutQ: Edge, InM: MemoryManager<InP>, OutM: MemoryManager<()>, C: PlatformClock + Sized, Tel: Telemetry + Sized,

Default batched-step implementation that honors all NodePolicy batching variants while delegating actual consumption to the implementor’s single-message process_message() method.

fn on_watchdog_timeout<C, Tel>( &mut self, clock: &C, _t: &mut Tel, ) -> Result<StepResult, NodeError>

where C: PlatformClock + Sized, Tel: Telemetry,

Handle watchdog timeouts by applying over-budget policy (degrade/default/skip).

fn stop<C, Tel>(&mut self, _c: &C, _t: &mut Tel) -> Result<(), NodeError>

where Tel: Telemetry,

Flush and release resources, if any. Default: no-op.