Struct ProcessorContext 

pub struct ProcessorContext<'ctx, 'd, KOut, VOut> { /* private fields */ }

The context handed to Processor::process. forward boxes the record and queues it for each child node, and the driver drains the queue.

There are two lifetimes. 'ctx is the borrow of the Dispatch reference itself. 'd is the lifetime of the data inside Dispatch, such as the buffers and the slices. Separate lifetimes avoid lifetime-invariance problems when the code builds a ProcessorContext from a &mut Dispatch<'d> with an independently-scoped outer borrow 'ctx.

Implementations

impl<'ctx, 'd, KOut, VOut> ProcessorContext<'ctx, 'd, KOut, VOut>

where KOut: Any + Send + Clone, VOut: Any + Send + Clone,

pub fn forward(&mut self, record: Record<KOut, VOut>)

Forward a record to all child nodes.

The fan-out clones the record once per child. The last child receives the original by move, so the common single-child case makes no clone. This mirrors the JVM ProcessorContext.forward(Record), which takes the record by value.

pub fn get_state_store<K2: Send + Sync + 'static, V2: Send + 'static>( &mut self, name: &str, ) -> Option<&mut dyn KeyValueStore<K2, V2>>

Access a connected state store, typed. It returns None when the store is absent or the K and V types do not match. Fetch it once per record and do not hold it across process calls.

pub async fn global_get<GK: Send + Sync + 'static, VG: Send + 'static>( &mut self, store: &str, key: &GK, ) -> Option<VG>

Look up a value in a connected GLOBAL store, which is fully replicated and shared across tasks.

The method returns an owned value. No borrow escapes the shared manager’s lock, so the caller need not hold the lookup future across forward. It returns None on a miss or a type mismatch. Fetch it once per record and do not hold it across process calls.

pub fn get_window_store<K2: Send + Sync + 'static, V2: Send + 'static>( &mut self, name: &str, ) -> Option<&mut dyn WindowStore<K2, V2>>

Access a connected window store, typed. It returns None when the store is absent or the K and V types do not match. Fetch it once per record and do not hold it across process calls.

pub fn get_join_window_store<K2: Send + Sync + 'static, V2: Send + 'static>( &mut self, name: &str, ) -> Option<&mut dyn JoinWindowStore<K2, V2>>

Access a connected join-window store (retainDuplicates), typed. It returns None when the store is absent or the K and V types do not match. Fetch it once per record and do not hold it across process calls.

pub fn get_session_store<K2: Send + Sync + 'static, V2: Send + 'static>( &mut self, name: &str, ) -> Option<&mut dyn SessionStore<K2, V2>>

Access a connected session store, typed. It returns None when the store is absent or the K and V types do not match. Fetch it once per record and do not hold it across process calls.

pub fn get_versioned_store<K2: Send + Sync + 'static, V2: Send + 'static>( &mut self, name: &str, ) -> Option<&mut dyn VersionedKeyValueStore<K2, V2>>

Access a connected versioned store (KIP-889), typed. It returns None when the store is absent or the K and V types do not match. Fetch it once per record and do not hold it across process calls.

pub fn record_context(&self) -> &RecordContext

The metadata of the source record that this context processes now.

pub fn store_is_cached(&self, name: &str) -> bool

Whether the named KV state store is record-cached. When it is, this processor should suppress its immediate forward and let the cache flush forward the deduped change. The method returns false for an absent store, a non-KV store, and an uncached store.

pub fn schedule<P>( &mut self, interval: Duration, ty: PunctuationType, punctuator: P, ) -> Cancellable

where P: Punctuator<KOut, VOut>,

Schedule a periodic Punctuator. You can call this from init or from process. interval must be positive. The method returns a Cancellable that stops the punctuator.

Panics

Panics if synchronized client state is poisoned or a response violates an invariant established by protocol validation.