Struct vector_buffers::topology::channel::BufferSender

pub struct BufferSender<T: Bufferable> { /* private fields */ }

A buffer sender.

The sender handles sending events into the buffer, as well as the behavior around handling events when the internal channel is full.

When creating a buffer sender/receiver pair, callers can specify the “when full” behavior of the sender. This controls how events are handled when the internal channel is full. Three modes are possible:

• block
• drop newest
• overflow

In “block” mode, callers are simply forced to wait until the channel has enough capacity to accept the event. In “drop newest” mode, any event being sent when the channel is full will be dropped and proceed no further. In “overflow” mode, events will be sent to another buffer sender. Callers can specify the overflow sender to use when constructing their buffers initially.

TODO: We should eventually rework BufferSender/BufferReceiver so that they contain a vector of the fields we already have here, but instead of cascading via calling into overflow, we’d linearize the nesting instead, so that BufferSender would only ever be calling the underlying SenderAdapter instances instead… which would let us get rid of the boxing and #[async_recursion] stuff.

Implementations

impl<T: Bufferable> BufferSender<T>

pub fn new(base: SenderAdapter<T>, when_full: WhenFull) -> Self

Creates a new BufferSender wrapping the given channel sender.

pub fn with_overflow(base: SenderAdapter<T>, overflow: BufferSender<T>) -> Self

Creates a new BufferSender wrapping the given channel sender and overflow sender.

pub fn with_usage_instrumentation(&mut self, handle: BufferUsageHandle)

Configures this sender to instrument the items passing through it.

pub fn with_send_duration_instrumentation(&mut self, stage: usize, span: &Span)

Configures this sender to instrument the send duration.

impl<T: Bufferable> BufferSender<T>

pub fn send<'life_self, 'async_recursion>( &'life_self mut self, item: T, send_reference: Option<Instant>, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_recursion>>

where 'life_self: 'async_recursion,

pub fn flush<'life_self, 'async_recursion>( &'life_self mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_recursion>>

where 'life_self: 'async_recursion,

Trait Implementations

impl<T: Clone + Bufferable> Clone for BufferSender<T>

fn clone(&self) -> BufferSender<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for BufferSender<T>

where T: Debug + Bufferable,

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

Formats the value using the given formatter.