Struct StreamMap 

pub(crate) struct StreamMap {
    open_streams: StreamPollSet<StreamId, Priority, OpenStreamEntStream>,
    closed_streams: HashMap<StreamId, ClosedStreamEnt>,
    next_stream_id: StreamId,
    next_priority: Priority,
}

A map from stream IDs to stream entries. Each circuit has one for each hop.

Fields

open_streams: StreamPollSet<StreamId, Priority, OpenStreamEntStream>

Open streams.

closed_streams: HashMap<StreamId, ClosedStreamEnt>

Closed streams.

next_stream_id: StreamId

The next StreamId that we should use for a newly allocated circuit.

next_priority: Priority

Next priority to use in open_streams. We implement round-robin scheduling of handling outgoing messages from streams by assigning a stream the next priority whenever an outgoing message is processed from that stream, putting it last in line.

Implementations

impl StreamMap

pub(crate) fn new() -> Self

Make a new empty StreamMap.

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

Return the number of open streams in this map.

pub(crate) fn tunnel_activity(&self) -> TunnelActivity

Return a TunnelActivity for this hop.

fn take_next_priority(&mut self) -> Priority

Return the next available priority.

pub(crate) fn add_ent( &mut self, sink: StreamQueueSender, rx: Receiver<AnyRelayMsg, MpscSpec>, flow_ctrl: StreamFlowCtrl, cmd_checker: Box<dyn CmdChecker + Send + 'static>, ) -> Result<StreamId>

Add an entry to this map; return the newly allocated StreamId.

pub(crate) fn add_ent_with_id( &mut self, sink: StreamQueueSender, rx: Receiver<AnyRelayMsg, MpscSpec>, flow_ctrl: StreamFlowCtrl, id: StreamId, cmd_checker: Box<dyn CmdChecker + Send + 'static>, ) -> Result<()>

Add an entry to this map using the specified StreamId.

pub(crate) fn get_mut(&mut self, id: StreamId) -> Option<StreamEntMut<'_>>

Return the entry for id in this map, if any.

pub(crate) fn ending_msg_received(&mut self, id: StreamId) -> Result<()>

Note that we received an END message (or other message indicating the end of the stream) on the stream with id.

Returns true if there was really a stream there.

pub(crate) fn terminate( &mut self, id: StreamId, why: TerminateReason, expiry: Instant, ) -> Result<ShouldSendEnd>

Handle a termination of the stream with id from this side of the circuit. Return true if the stream was open and an END ought to be sent.

pub(crate) fn poll_ready_streams_iter<'a>( &'a mut self, cx: &mut Context<'_>, ) -> impl Iterator<Item = (StreamId, Option<&'a AnyRelayMsg>)> + 'a + use<'a>

Get an up-to-date iterator of streams with ready items. Option<AnyRelayMsg>::None indicates that the local sender has been dropped.

Conceptually all streams are in a queue; new streams are added to the back of the queue, and a stream is sent to the back of the queue whenever a ready message is taken from it (via Self::take_ready_msg). The returned iterator is an ordered view of this queue, showing the subset of streams that have a message ready to send, or whose sender has been dropped.

pub(crate) fn take_ready_msg(&mut self, sid: StreamId) -> Option<AnyRelayMsg>

If the stream sid has a message ready, take it, and reprioritize sid to the “back of the line” with respect to Self::poll_ready_streams_iter.

pub(crate) fn remove_expired_halfstreams(&mut self, now: Instant)

Remove all halfstreams that are expired at now.