Struct ValueStream 

pub struct ValueStream { /* private fields */ }

An async stream of Values with optional type checking.

ValueStream combines a buffered front-end with an optional async [Stream] back-end. Values can be pushed into the buffer or pulled from the underlying stream. When a Type is attached via typed, every yielded value is checked at runtime.

Implements [Stream] from tokio_stream, yielding Result<Value> items.

Examples

use toasty_core::stmt::{Value, ValueStream};

let mut stream = ValueStream::from_value(Value::from(42_i64));
let val = stream.next().await.unwrap().unwrap();
assert_eq!(val, Value::from(42_i64));

Implementations

impl ValueStream

pub fn from_value(value: impl Into<Value>) -> ValueStream

Creates a stream containing a single value.

pub fn from_stream<T>(stream: T) -> ValueStream

where T: Stream<Item = Result<Value, Error>> + Send + 'static,

Creates a stream backed by an async [Stream] of Result<Value>.

pub fn from_vec(records: Vec<Value>) -> ValueStream

Creates a fully-buffered stream from a vector of values.

pub fn from_iter<T, I>(iter: I) -> ValueStream

where T: Into<Value>, I: Iterator<Item = Result<T, Error>> + Send + 'static,

Creates a stream from a fallible iterator.

pub async fn next(&mut self) -> Option<Result<Value, Error>>

Returns the next record in the stream

pub async fn peek(&mut self) -> Option<Result<&Value, Error>>

Peek at the next record in the stream

pub async fn tap(&mut self) -> Result<(), Error>

Force the stream to preload at least one record, if there are more records to stream.

pub fn min_len(&self) -> usize

Returns the minimum number of elements this stream will yield.

This is derived from the stream’s size_hint lower bound plus the number of buffered elements.

pub async fn collect(self) -> Result<Vec<Value>, Error>

Consumes the stream and collects all values into a Vec.

pub async fn dup(&mut self) -> Result<ValueStream, Error>

Fully buffers the stream and returns a clone of it.

After this call, both the original and the returned stream are fully buffered and contain the same values.

pub fn try_clone(&self) -> Option<ValueStream>

Returns a clone if the stream is fully buffered, or None if there is an unconsumed async stream that cannot be cloned.

pub async fn buffer(&mut self) -> Result<(), Error>

Drains the underlying async stream into the buffer.

After this call, all remaining values are buffered locally and is_buffered returns true.

pub fn is_buffered(&self) -> bool

Returns true if the ValueStream is fully buffered (no remaining stream)

pub fn buffered_to_vec(&self) -> Vec<Value>

Returns a clone of only the currently buffered values Does not consume any stream data or wait for additional values

pub fn iter_mut(&mut self) -> impl Iterator<Item = &mut Value>

Returns a mutable iterator over the buffered values.

Panics

Panics if the stream has an unconsumed async back-end. Call buffer first to ensure all values are buffered.

pub fn typed(self, ty: Type) -> ValueStream

Attaches a Type constraint to this stream.

Every value yielded from the stream (both already-buffered and future) will be checked against ty at runtime. If a value does not match, the check panics with a diagnostic message.

Panics

Panics if an already-buffered value is not compatible with ty, or if a previously set type differs from ty.

Trait Implementations

impl Debug for ValueStream

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

Formats the value using the given formatter.

impl Default for ValueStream

fn default() -> ValueStream

Returns the “default value” for a type.

impl From<Value> for ValueStream

fn from(src: Value) -> ValueStream

Converts to this type from the input type.

impl From<Vec<Value>> for ValueStream

fn from(value: Vec<Value>) -> ValueStream

Converts to this type from the input type.

impl Stream for ValueStream

type Item = Result<Value, Error>

Values yielded by the stream.

fn poll_next( self: Pin<&mut ValueStream>, cx: &mut Context<'_>, ) -> Poll<Option<<ValueStream as Stream>::Item>>

Attempt to pull out the next value of this stream, registering the current task for wakeup if the value is not yet available, and returning None if the stream is exhausted.

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

Returns the bounds on the remaining length of the stream.