Struct ProcedureStream

pub struct ProcedureStream { /* private fields */ }

TODO

Implementations

impl ProcedureStream

pub fn from_stream<T, S>(s: S) -> ProcedureStream

where S: Stream<Item = Result<T, ProcedureError>> + Send + 'static, T: Serialize + Send + Sync + 'static,

TODO

pub fn from_future<T, F>(f: F) -> ProcedureStream

where F: Future<Output = Result<T, ProcedureError>> + Send + 'static, T: Serialize + Send + Sync + 'static,

TODO

pub fn from_future_stream<T, F, S>(f: F) -> ProcedureStream

where F: Future<Output = Result<S, ProcedureError>> + Send + 'static, S: Stream<Item = Result<T, ProcedureError>> + Send + 'static, T: Serialize + Send + Sync + 'static,

TODO

pub fn from_stream_value<T, S>(s: S) -> ProcedureStream

where S: Stream<Item = Result<T, ProcedureError>> + Send + 'static, T: Send + Sync + 'static,

TODO

pub fn from_future_value<T, F>(f: F) -> ProcedureStream

where F: Future<Output = Result<T, ProcedureError>> + Send + 'static, T: Send + Sync + 'static,

TODO

pub fn from_future_stream_value<T, F, S>(f: F) -> ProcedureStream

where F: Future<Output = Result<S, ProcedureError>> + Send + 'static, S: Stream<Item = Result<T, ProcedureError>> + Send + 'static, T: Send + Sync + 'static,

TODO

pub fn require_manual_stream(self) -> ProcedureStream

By setting this the stream will delay returning any data until instructed by the caller (via Self::stream).

This allows you to progress an entire runtime of streams until all of them are in a state ready to start returning responses. This mechanism allows anything that could need to modify the HTTP response headers to do so before the body starts being streamed.

Behaviour

ProcedureStream will poll the underlying stream until the first value is ready. It will then return Poll::Pending and go inactive until Self::stream is called. When polled for the first time after Self::stream is called if a value was already ready it will be immediately returned. It is guaranteed that the stream will never yield Poll::Ready until flush is called if this is set.

Usage

It’s generally expected you will continue to poll the runtime until some criteria based on Self::resolved & Self::flushable is met on all streams. Once this is met you can call Self::stream on all of the streams at once to begin streaming data.

pub fn stream(&mut self)

Start streaming data. Refer to Self::require_manual_stream for more information.

pub fn resolved(&self) -> bool

Will return true if the future has resolved.

For a stream created via Self::from_future* this will be true once the future has resolved and for all other streams this will always be true.

pub fn flushable(&self) -> bool

Will return true if the stream is ready to start streaming data.

This is false until the flush function is called by the user.

pub fn size_hint(&self) -> (usize, Option<usize>)

TODO

pub fn poll_next( &mut self, cx: &mut Context<'_>, ) -> Poll<Option<Result<DynOutput<'_>, ProcedureError>>>

TODO

pub async fn next(&mut self) -> Option<Result<DynOutput<'_>, ProcedureError>>

TODO

pub fn map<F, T>(self, map: F) -> ProcedureStreamMap<F, T>

where F: FnMut(Result<DynOutput<'_>, ProcedureError>) -> Result<T, String>,

TODO

Trait Implementations

impl Debug for ProcedureStream

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

Formats the value using the given formatter.

impl From<ProcedureError> for ProcedureStream

fn from(err: ProcedureError) -> ProcedureStream

Converts to this type from the input type.