Struct Segmenter 

pub struct Segmenter<const C: usize, S> {
    inner: S,
    state: State,
    frame: Vec<u8>,
    ready_segments: VecDeque<Segment>,
    frame_size: usize,
    frame_id: FrameId,
    is_closed: bool,
    send_terminating_segment: bool,
}

Segmenter is an adaptor to [futures::Sink] of Segment items that turns it into [futures::io::AsyncWrite].

Bytes written to the Segmenter are buffered up and/or chopped into Segment of at most C in payload size (the data member).

The bytes are written to the underlying Sink once more than frame_size is written (or unless flushed), so the Segmenter naturally acts as a buffered writer. Any unflushed bytes written to the Segmenter will be lost when it is closed.

The data are grouped into Frames of the size given by the frame_size parameter, segments in each such group share the same FrameId. This acts as a natural buffering feature of a Segmenter.

Segmenter can optionally send a terminating when poll_close is called.

Segmenter is essentially inverse of Reassembler.

Use SegmenterExt to turn a Segment sink into an AsyncWrite object using the Segmenter.

Fields

inner: S

state: State

frame: Vec<u8>

ready_segments: VecDeque<Segment>

frame_size: usize

frame_id: FrameId

is_closed: bool

send_terminating_segment: bool

Implementations

impl<const C: usize, S> Segmenter<C, S>

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

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

impl<const C: usize, S> Segmenter<C, S>

where S: Sink<Segment>, S::Error: Error + Send + Sync + 'static,

fn new(inner: S, frame_size: usize, send_terminating_segment: bool) -> Self

Trait Implementations

impl<const C: usize, S> AsyncWrite for Segmenter<C, S>

where S: Sink<Segment>, S::Error: Error + Send + Sync + 'static,

fn poll_write( self: Pin<&mut Self>, cx: &mut Context<'_>, buf: &[u8], ) -> Poll<Result<usize>>

Attempt to write bytes from buf into the object.

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

Attempt to flush the object, ensuring that any buffered data reach their destination.

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

Attempt to close the object.

fn poll_write_vectored( self: Pin<&mut Self>, cx: &mut Context<'_>, bufs: &[IoSlice<'_>], ) -> Poll<Result<usize, Error>>

Attempt to write bytes from bufs into the object using vectored IO operations.

impl<'pin, const C: usize, S> Unpin for Segmenter<C, S>

where PinnedFieldsOf<__Segmenter<'pin, C, S>>: Unpin,