Struct SinkStack 

pub struct SinkStack<L = ()> { /* private fields */ }

Builds a sink stack in record-entry order.

The first tier call becomes the outermost tier and receives records first. Each later tier receives records only when the tier before it forwards them; terminal finishes the stack with its final sink.

The builder introduces no boxing, dynamic dispatch, runtime collection, or store calls. Finishing it produces the existing nested Tier types.

use std::convert::Infallible;
use std::time::Duration;

use meathook::{
    FlushPolicy, JsonlStore, MemStore, Sink, SinkStack, WindowMeta,
};

struct Terminal;

impl Sink<i32> for Terminal {
    type Error = Infallible;

    async fn ingest(
        &mut self,
        _: &WindowMeta,
        _: Vec<i32>,
    ) -> Result<(), Self::Error> {
        Ok(())
    }

    async fn flush(&mut self) -> Result<(), Self::Error> {
        Ok(())
    }
}

let sink = SinkStack::new()
    .tier(
        MemStore::new(),
        FlushPolicy::new(Duration::from_secs(300), 10_000),
    )
    .tier(JsonlStore::new("spool"), FlushPolicy::hourly())
    .terminal(Terminal);

// Concrete type, inferred without boxing or `dyn Sink`.
let _: meathook::Tier<
    i32,
    MemStore<i32>,
    meathook::Tier<i32, JsonlStore<i32>, Terminal>,
> = sink;

Implementations

impl SinkStack<()>

pub const fn new() -> Self

Start an empty sink stack.

impl<L> SinkStack<L>

pub fn tier<St>( self, store: St, policy: FlushPolicy, ) -> SinkStack<(St, FlushPolicy, L)>

Add the next tier in record-entry order.

pub fn terminal<R, S>(self, sink: S) -> <L as BuildSinkStack<R, S>>::Output

where S: Sink<R>, L: BuildSinkStack<R, S>,

Finish the stack with its terminal sink.

The record type is normally inferred from the stores, terminal, or surrounding pipeline. For a terminal that implements Sink for multiple record types, specify it explicitly with terminal::<MyRecord, _>(sink).

Trait Implementations

impl Default for SinkStack<()>

fn default() -> Self

Returns the “default value” for a type.