Struct CircuitCellSender 

pub(crate) struct CircuitCellSender {
    sink: SinkBlocker<SometimesUnboundedSink<(AnyChanCell, Option<QueuedCellPaddingInfo>), ChannelSender>, BooleanPolicy>,
}

A sink that a circuit uses to send cells onto a Channel.

(This is a separate type so we can more easily control access to its internals.)

You must poll this type

This type is based on SometimesUnboundedSink. For queued items to be delivered, SometimesUnboundedSink must be polled, even if you don’t have an item to send. The same rule applies here.

Currently Sink::poll_flush, Sink::poll_close, and Sink::poll_ready will all work for this purpose.

Fields

sink: SinkBlocker<SometimesUnboundedSink<(AnyChanCell, Option<QueuedCellPaddingInfo>), ChannelSender>, BooleanPolicy>

The actual inner sink on which we’ll be sending cells.

See type alias documentation for full details.

Implementations

impl CircuitCellSender

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

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

impl CircuitCellSender

pub(crate) fn from_channel_sender(inner: ChannelSender) -> Self

Construct a new CircuitCellSender to deliver cells onto inner.

pub(crate) fn n_queued(&self) -> usize

Return the number of cells queued in this Sender that have not yet been flushed onto the channel.

pub(crate) fn have_queued_cell_for_hop_or_later(&self, hop: HopNum) -> bool

Return true if we have a queued cell for the specified hop or later.

pub(crate) async fn send_unbounded( &mut self, entry: (AnyChanCell, Option<QueuedCellPaddingInfo>), ) -> Result<()>

Send a cell on this sender, even if the underlying channel queues are all full.

You must .await this, but it will never block. (Its future is always Ready.)

See note on CircuitCellSender type about polling: If you don’t poll this sink, then queued items might never flush.

pub(crate) fn time_provider(&self) -> &DynTimeProvider

Return the time provider used by the underlying channel sender for memory quota purposes.

pub(crate) fn start_blocking(&mut self)

Circpadding only: Put this sink into a blocked state.

When we are blocked, attempts to send() to this sink will fail. You can still queue items with send_unbounded(), and they will be sent immediately.

pub(crate) fn stop_blocking(&mut self)

Circpadding only: Put this sink into an unblocked state.

pub(crate) async fn congestion_signals(&mut self) -> CongestionSignals

Note: This is only async because we need a Context to check the underlying sink for readiness. This will register a new waker (or overwrite any existing waker).

fn sometimes_unbounded( &self, ) -> &SometimesUnboundedSink<(AnyChanCell, Option<QueuedCellPaddingInfo>), ChannelSender>

Helper: return a reference to the internal SometimesUnboundedSink that this CircuitCellSender is based on.

fn sometimes_unbounded_mut( &mut self, ) -> &mut SometimesUnboundedSink<(AnyChanCell, Option<QueuedCellPaddingInfo>), ChannelSender>

Helper: return a mutable reference to the internal SometimesUnboundedSink that this CircuitCellSender is based on.

fn chan_sender(&self) -> &ChannelSender

Helper: Return a reference to the internal ChannelSender that this CircuitCellSender is based on.

fn chan_sender_mut(&mut self) -> &mut ChannelSender

Helper: Return a mutable reference to the internal ChannelSender that this CircuitCellSender is based on.

fn pre_queue_blocker_mut( &mut self, ) -> &mut SinkBlocker<SometimesUnboundedSink<(AnyChanCell, Option<QueuedCellPaddingInfo>), ChannelSender>, BooleanPolicy>

Helper: Return a mutable reference to our outer SinkBlocker

Trait Implementations

impl Sink<(ChanCell<AnyChanMsg>, Option<QueuedCellPaddingInfo>)> for CircuitCellSender

type Error = <ChannelSender as Sink<(ChanCell<AnyChanMsg>, Option<QueuedCellPaddingInfo>)>>::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: (AnyChanCell, Option<QueuedCellPaddingInfo>), ) -> 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> Unpin for CircuitCellSender

where PinnedFieldsOf<__CircuitCellSender<'pin>>: Unpin,