Struct SinkBlocker 

pub(crate) struct SinkBlocker<S, P = BooleanPolicy> {
    inner: S,
    policy: P,
    waker: Option<Waker>,
}

A wrapper for a [futures::Sink] that allows its blocking status to be turned on and off according to a policy.

While the policy is blocking, attempts to enqueue data on the sink via this Sink trait will return Poll::Pending. Later, when the policy is replaced with a nonblocking one via Self::update_policy() this sink can be written to again.

Fields

inner: S

The inner sink.

policy: P

A policy state object, deciding whether we are blocking or not.

Invariant: Whenever we try to send with a blocking Policy, we store the context’s waker in self.waker. If later the policy becomes non-blocking, we we alert the Waker.

waker: Option<Waker>

A waker that we should alert when policy transitions from a blocking to a non-blocking state.

Implementations

impl<S> SinkBlocker<S, BooleanPolicy>

pub(crate) fn set_blocked(&mut self)

Put this SinkBlocker into a blocked state.

pub(crate) fn set_unblocked(&mut self)

Put this SinkBlocker into an unblocked state.

impl<S> SinkBlocker<S, CountingPolicy>

pub(crate) fn set_blocked(&mut self)

Put this SinkBlocker into a blocked state.

pub(crate) fn set_unlimited(&mut self)

Put this SinkBlocker into an unlimited state.

pub(crate) fn allow_n_additional_items(&mut self, n: u32)

Allow n additional items to bypass the current blocking of this SinkBlocker.

(This function has no effect if the SinkBlocker is currently unlimited.)

pub(crate) fn is_unlimited(&self) -> bool

Return true if there is no limit on this policy.

impl<S, P> SinkBlocker<S, P>

pub(crate) fn project<'pin>( self: Pin<&'pin mut Self>, ) -> __SinkBlockerProjection<'pin, S, P>

pub(crate) fn project_ref<'pin>( self: Pin<&'pin Self>, ) -> __SinkBlockerProjectionRef<'pin, S, P>

impl<S, P> SinkBlocker<S, P>

pub(crate) fn new(inner: S, policy: P) -> Self

Construct a new SinkBlocker wrapping a given sink, with a given initial blocking policy.

pub(crate) fn as_inner(&self) -> &S

Return a reference to the inner Sink of this object.

See warnings on as_inner_mut.

pub(crate) fn as_inner_mut(&mut self) -> &mut S

Return a mutable reference to the inner Sink of this object.

Note that with this method, it is possible to bypass the blocking features of SinkBlocker. This is an intentional escape hatch.

impl<S, P: Policy> SinkBlocker<S, P>

pub(crate) fn update_policy(&mut self, new_policy: P)

Replace the current Policy state object with new_policy.

This method is used to make a blocked SinkBlocker unblocked, or vice versa.

Trait Implementations

impl<T, S: Sink<T>, P: Policy> Sink<T> for SinkBlocker<S, P>

type Error = <S as Sink<T>>::Error

The type of value produced by the sink when an error occurs.

fn poll_ready( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Attempts to prepare the Sink to receive a value.

fn start_send(self: Pin<&mut Self>, item: T) -> Result<(), Self::Error>

Begin the process of sending a value to the sink. Each call to this function must be preceded by a successful call to poll_ready which returned Poll::Ready(Ok(())).

fn poll_flush( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output from this sink.

fn poll_close( self: Pin<&mut Self>, cx: &mut Context<'_>, ) -> Poll<Result<(), Self::Error>>

Flush any remaining output and close this sink, if necessary.

impl<'pin, S, P> Unpin for SinkBlocker<S, P>

where PinnedFieldsOf<__SinkBlocker<'pin, S, P>>: Unpin,