Struct h2::proto::streams::store::Ptr

pub(super) struct Ptr<'a> {
    key: Key,
    store: &'a mut Store,
}

“Pointer” to an entry in the store

Fields

key: Key

store: &'a mut Store

Implementations

impl<'a> Ptr<'a>

pub fn key(&self) -> Key

Returns the Key associated with the stream

pub fn store_mut(&mut self) -> &mut Store

pub fn remove(self) -> StreamId

Remove the stream from the store

pub fn unlink(&mut self)

Remove the StreamId -> stream state association.

This will effectively remove the stream as far as the H2 protocol is concerned.

Methods from Deref<Target = Stream>

pub fn ref_inc(&mut self)

Increment the stream’s ref count

pub fn ref_dec(&mut self)

Decrements the stream’s ref count

pub fn is_pending_reset_expiration(&self) -> bool

Returns true if stream is currently being held for some time because of a local reset.

pub fn is_send_ready(&self) -> bool

Returns true if frames for this stream are ready to be sent over the wire

pub fn is_closed(&self) -> bool

Returns true if the stream is closed

pub fn is_released(&self) -> bool

Returns true if the stream is no longer in use

pub fn is_canceled_interest(&self) -> bool

Returns true when the consumer of the stream has dropped all handles (indicating no further interest in the stream) and the stream state is not actually closed.

In this case, a reset should be sent.

pub fn capacity(&self, max_buffer_size: usize) -> u32

Current available stream send capacity

pub fn assign_capacity(&mut self, capacity: u32, max_buffer_size: usize)

pub fn send_data(&mut self, len: u32, max_buffer_size: usize)

pub fn notify_capacity(&mut self)

If the capacity was limited because of the max_send_buffer_size, then consider waking the send task again…

pub fn dec_content_length(&mut self, len: usize) -> Result<(), ()>

Returns Err when the decrement cannot be completed due to overflow.

pub fn ensure_content_length_zero(&self) -> Result<(), ()>

pub fn notify_send(&mut self)

pub fn wait_send(&mut self, cx: &Context<'_>)

pub fn notify_recv(&mut self)

Trait Implementations

impl<'a> Debug for Ptr<'a>

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

Formats the value using the given formatter.

impl<'a> Deref for Ptr<'a>

type Target = Stream

The resulting type after dereferencing.

fn deref(&self) -> &Stream

Dereferences the value.

impl<'a> DerefMut for Ptr<'a>

fn deref_mut(&mut self) -> &mut Stream

Mutably dereferences the value.

impl<'a> Resolve for Ptr<'a>

fn resolve(&mut self, key: Key) -> Ptr<'_>