Trait solicit::http::session::Stream

pub trait Stream {
    fn new(stream_id: StreamId) -> Self;
    fn new_data_chunk(&mut self, data: &[u8]);
    fn set_headers(&mut self, headers: Vec<Header>);
    fn set_state(&mut self, state: StreamState);
    fn get_data_chunk(
        &mut self, 
        buf: &mut [u8]
    ) -> Result<StreamDataChunk, StreamDataError>;
    fn id(&self) -> StreamId;
    fn state(&self) -> StreamState;

    fn close(&mut self) { ... }
    fn close_local(&mut self) { ... }
    fn close_remote(&mut self) { ... }
    fn is_closed(&self) -> bool { ... }
    fn is_closed_local(&self) -> bool { ... }
    fn is_closed_remote(&self) -> bool { ... }
}

A trait representing a single HTTP/2 stream. An HTTP/2 connection multiplexes a number of streams.

The trait defines which operations need to be implemented by a type that should be usable as an HTTP/2 stream. By implementing this trait, clients can implement only stream-level logic, such as how the received data should be handled, or which data should be sent to the peer, without having to worry about the lower-level details of session and connection management (e.g. handling raw frames or tracking stream status).

Required Methods

fn new(stream_id: StreamId) -> Self

Create a new stream with the given ID

fn new_data_chunk(&mut self, data: &[u8])

Handle a new data chunk that has arrived for the stream.

fn set_headers(&mut self, headers: Vec<Header>)

Set headers for a stream. A stream is only allowed to have one set of headers.

fn set_state(&mut self, state: StreamState)

Sets the stream state to the newly provided state.

fn get_data_chunk(
    &mut self,
    buf: &mut [u8]
) -> Result<StreamDataChunk, StreamDataError>

Places the next data chunk that should be written onto the stream into the given buffer.

Returns

The returned variant of the StreamDataChunk enum can indicate that the returned chunk is the last one that the stream can write (the StreamDataChunk::Last variant).

It can also indicate that the stream currently does not have any data that could be written, but it isn't closed yet, implying that at a later time some data might become available for writing (the StreamDataChunk::Unavailable variant).

The StreamDataChunk::Chunk indicates that the chunk of the given length has been placed into the buffer and that more data might follow on the stream.

fn id(&self) -> StreamId

Returns the ID of the stream.

fn state(&self) -> StreamState

Returns the current state of the stream.

Provided Methods

fn close(&mut self)

Transitions the stream state to closed. After this, the stream is considered to be closed for any further reads or writes.

fn close_local(&mut self)

Updates the Stream status to indicate that it is closed locally.

If the stream is closed on the remote end, then it is fully closed after this call.

fn close_remote(&mut self)

Updates the Stream status to indicate that it is closed on the remote peer's side.

If the stream is also locally closed, then it is fully closed after this call.

fn is_closed(&self) -> bool

Returns whether the stream is closed.

A stream is considered to be closed iff its state is set to Closed.

fn is_closed_local(&self) -> bool

Returns whether the stream is closed locally.

fn is_closed_remote(&self) -> bool

Returns whether the remote peer has closed the stream. This includes a fully closed stream.

Implementors

• impl Stream for DefaultStream