pub struct Cursor<T> { /* private fields */ }
Expand description
A Cursor
streams the result of a query. When a query is made, the returned Cursor
will
contain the first batch of results from the server; the individual results will then be returned
as the Cursor
is iterated. When the batch is exhausted and if there are more results, the
Cursor
will fetch the next batch of documents, and so forth until the results are exhausted.
Note that because of this batching, additional network I/O may occur on any given call to
next
. Because of this, a Cursor
iterates over Result<T>
items rather than
simply T
items.
The batch size of the Cursor
can be configured using the options to the method that returns
it. For example, setting the batch_size
field of
FindOptions
will set the batch size of the
Cursor
returned by Collection::find
.
Note that the batch size determines both the number of documents stored in memory by the
Cursor
at a given time as well as the total number of network round-trips needed to fetch all
results from the server; both of these factors should be taken into account when choosing the
optimal batch size.
Cursor
implements Stream
, which means
it can be iterated over much in the same way that an Iterator
can be in synchronous Rust. In
order to do so, the StreamExt
trait must
be imported. Because a Cursor
iterates over a Result<T>
, it also has access to the
potentially more ergonomic functionality provided by
TryStreamExt
, which can be
imported instead of or in addition to
StreamExt
. The methods from
TryStreamExt
are especially useful when
used in conjunction with the ?
operator.
use futures::stream::{StreamExt, TryStreamExt};
let mut cursor = coll.find(None, None).await?;
// regular Stream uses next() and iterates over Option<Result<T>>
while let Some(doc) = cursor.next().await {
println!("{}", doc?)
}
// regular Stream uses collect() and collects into a Vec<Result<T>>
let v: Vec<Result<_>> = cursor.collect().await;
let mut cursor = coll.find(None, None).await?;
// TryStream uses try_next() and iterates over Result<Option<T>>
while let Some(doc) = cursor.try_next().await? {
println!("{}", doc)
}
// TryStream uses try_collect() and collects into a Result<Vec<T>>
let v: Vec<_> = cursor.try_collect().await?;
Implementations
sourceimpl<T> Cursor<T>
impl<T> Cursor<T>
sourcepub async fn advance(&mut self) -> Result<bool>
pub async fn advance(&mut self) -> Result<bool>
Move the cursor forward, potentially triggering requests to the database for more results if the local buffer has been exhausted.
This will keep requesting data from the server until either the cursor is exhausted or batch with results in it has been received.
The return value indicates whether new results were successfully returned (true) or if the cursor has been closed (false).
Note: Cursor::current
and Cursor::deserialize_current
must only be called after
Cursor::advance
returned Ok(true)
. It is an error to call either of them without
calling Cursor::advance
first or after Cursor::advance
returns an error / false.
let mut cursor = coll.find(None, None).await?;
while cursor.advance().await? {
println!("{:?}", cursor.current());
}
sourcepub fn current(&self) -> &RawDocument
pub fn current(&self) -> &RawDocument
Returns a reference to the current result in the cursor.
Panics
Cursor::advance
must return Ok(true)
before Cursor::current
can be
invoked. Calling Cursor::current
after Cursor::advance
does not return true
or without calling Cursor::advance
at all may result in a panic.
let mut cursor = coll.find(None, None).await?;
while cursor.advance().await? {
println!("{:?}", cursor.current());
}
sourcepub fn deserialize_current<'a>(&'a self) -> Result<T> where
T: Deserialize<'a>,
pub fn deserialize_current<'a>(&'a self) -> Result<T> where
T: Deserialize<'a>,
Deserialize the current result to the generic type associated with this cursor.
Panics
Cursor::advance
must return Ok(true)
before Cursor::deserialize_current
can be
invoked. Calling Cursor::deserialize_current
after Cursor::advance
does not return
true or without calling Cursor::advance
at all may result in a panic.
use serde::Deserialize;
#[derive(Debug, Deserialize)]
struct Cat<'a> {
#[serde(borrow)]
name: &'a str
}
let coll = db.collection::<Cat>("cat");
let mut cursor = coll.find(None, None).await?;
while cursor.advance().await? {
println!("{:?}", cursor.deserialize_current()?);
}
sourcepub fn with_type<'a, D>(self) -> Cursor<D> where
D: Deserialize<'a>,
pub fn with_type<'a, D>(self) -> Cursor<D> where
D: Deserialize<'a>,
Update the type streamed values will be parsed as.
Trait Implementations
sourceimpl<T> Stream for Cursor<T> where
T: DeserializeOwned + Unpin + Send + Sync,
impl<T> Stream for Cursor<T> where
T: DeserializeOwned + Unpin + Send + Sync,
Auto Trait Implementations
impl<T> !RefUnwindSafe for Cursor<T>
impl<T> Send for Cursor<T> where
T: Send,
impl<T> !Sync for Cursor<T>
impl<T> Unpin for Cursor<T> where
T: Unpin,
impl<T> !UnwindSafe for Cursor<T>
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more
sourceimpl<T> StreamExt for T where
T: Stream + ?Sized,
impl<T> StreamExt for T where
T: Stream + ?Sized,
sourcefn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
fn next(&mut self) -> Next<'_, Self> where
Self: Unpin,
Creates a future that resolves to the next item in the stream. Read more
sourcefn into_future(self) -> StreamFuture<Self> where
Self: Unpin,
fn into_future(self) -> StreamFuture<Self> where
Self: Unpin,
sourcefn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
fn map<T, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> T,
Maps this stream’s items to a different type, returning a new stream of the resulting type. Read more
sourcefn enumerate(self) -> Enumerate<Self>
fn enumerate(self) -> Enumerate<Self>
Creates a stream which gives the current iteration count as well as the next value. Read more
sourcefn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn filter<Fut, F>(self, f: F) -> Filter<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Filters the values produced by this stream according to the provided asynchronous predicate. Read more
sourcefn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
fn filter_map<Fut, T, F>(self, f: F) -> FilterMap<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = Option<T>>,
Filters the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
sourcefn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future,
Computes from this stream’s items new items of a different type using an asynchronous closure. Read more
sourcefn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>,
fn collect<C>(self) -> Collect<Self, C> where
C: Default + Extend<Self::Item>,
Transforms a stream into a collection, returning a future representing the result of that computation. Read more
sourcefn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
fn unzip<A, B, FromA, FromB>(self) -> Unzip<Self, FromA, FromB> where
FromA: Default + Extend<A>,
FromB: Default + Extend<B>,
Self: Stream<Item = (A, B)>,
Converts a stream of pairs into a future, which resolves to pair of containers. Read more
sourcefn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
Concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
sourcefn count(self) -> Count<Self>
fn count(self) -> Count<Self>
Drives the stream to completion, counting the number of items. Read more
sourcefn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
fn fold<T, Fut, F>(self, init: T, f: F) -> Fold<Self, Fut, T, F> where
F: FnMut(T, Self::Item) -> Fut,
Fut: Future<Output = T>,
Execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
sourcefn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn any<Fut, F>(self, f: F) -> Any<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Execute predicate over asynchronous stream, and return true
if any element in stream satisfied a predicate. Read more
sourcefn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn all<Fut, F>(self, f: F) -> All<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = bool>,
Execute predicate over asynchronous stream, and return true
if all element in stream satisfied a predicate. Read more
sourcefn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
Flattens a stream of streams into just one continuous stream. Read more
sourcefn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self> where
Self::Item: Stream,
Self::Item: Unpin,
fn flatten_unordered(
self,
limit: impl Into<Option<usize>>
) -> FlattenUnordered<Self> where
Self::Item: Stream,
Self::Item: Unpin,
Flattens a stream of streams into just one continuous stream. Polls inner streams concurrently. Read more
sourcefn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
fn flat_map<U, F>(self, f: F) -> FlatMap<Self, U, F> where
F: FnMut(Self::Item) -> U,
U: Stream,
Maps a stream like StreamExt::map
but flattens nested Stream
s. Read more
sourcefn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F> where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
fn flat_map_unordered<U, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> FlatMapUnordered<Self, U, F> where
U: Stream + Unpin,
F: FnMut(Self::Item) -> U,
Maps a stream like StreamExt::map
but flattens nested Stream
s
and polls them concurrently, yielding items in any order, as they made
available. Read more
sourcefn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
fn scan<S, B, Fut, F>(self, initial_state: S, f: F) -> Scan<Self, S, Fut, F> where
F: FnMut(&mut S, Self::Item) -> Fut,
Fut: Future<Output = Option<B>>,
Combinator similar to StreamExt::fold
that holds internal state
and produces a new stream. Read more
sourcefn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn skip_while<Fut, F>(self, f: F) -> SkipWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Skip elements on this stream while the provided asynchronous predicate
resolves to true
. Read more
sourcefn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
fn take_while<Fut, F>(self, f: F) -> TakeWhile<Self, Fut, F> where
F: FnMut(&Self::Item) -> Fut,
Fut: Future<Output = bool>,
Take elements from this stream while the provided asynchronous predicate
resolves to true
. Read more
sourcefn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
fn take_until<Fut>(self, fut: Fut) -> TakeUntil<Self, Fut> where
Fut: Future,
Take elements from this stream until the provided future resolves. Read more
sourcefn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each<Fut, F>(self, f: F) -> ForEach<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
Runs this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
sourcefn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
fn for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> ForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Item) -> Fut,
Fut: Future<Output = ()>,
Runs this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available. Read more
sourcefn take(self, n: usize) -> Take<Self>
fn take(self, n: usize) -> Take<Self>
Creates a new stream of at most n
items of the underlying stream. Read more
sourcefn skip(self, n: usize) -> Skip<Self>
fn skip(self, n: usize) -> Skip<Self>
Creates a new stream which skips n
items of the underlying stream. Read more
sourcefn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
Catches unwinding panics while polling the stream. Read more
sourcefn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>> where
Self: 'a + Send,
fn boxed<'a>(
self
) -> Pin<Box<dyn Stream<Item = Self::Item> + Send + 'a, Global>> where
Self: 'a + Send,
Wrap the stream in a Box, pinning it. Read more
sourcefn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
fn boxed_local<'a>(self) -> Pin<Box<dyn Stream<Item = Self::Item> + 'a, Global>> where
Self: 'a,
Wrap the stream in a Box, pinning it. Read more
sourcefn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
fn buffered(self, n: usize) -> Buffered<Self> where
Self::Item: Future,
An adaptor for creating a buffered list of pending futures. Read more
sourcefn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
fn buffer_unordered(self, n: usize) -> BufferUnordered<Self> where
Self::Item: Future,
An adaptor for creating a buffered list of pending futures (unordered). Read more
sourcefn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
fn zip<St>(self, other: St) -> Zip<Self, St> where
St: Stream,
An adapter for zipping two streams together. Read more
sourcefn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
fn chain<St>(self, other: St) -> Chain<Self, St> where
St: Stream<Item = Self::Item>,
Adapter for chaining two streams. Read more
sourcefn peekable(self) -> Peekable<Self>
fn peekable(self) -> Peekable<Self>
Creates a new stream which exposes a peek
method. Read more
sourcefn chunks(self, capacity: usize) -> Chunks<Self>
fn chunks(self, capacity: usize) -> Chunks<Self>
An adaptor for chunking up items of the stream inside a vector. Read more
sourcefn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
fn ready_chunks(self, capacity: usize) -> ReadyChunks<Self>
An adaptor for chunking up ready items of the stream inside a vector. Read more
sourcefn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
fn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<Self::Ok, Error = Self::Error>,
Self: TryStream,
A future that completes after the given stream has been fully processed into the sink and the sink has been flushed and closed. Read more
sourcefn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
fn split<Item>(self) -> (SplitSink<Self, Item>, SplitStream<Self>) where
Self: Sink<Item>,
Splits this Stream + Sink
object into separate Sink
and Stream
objects. Read more
sourcefn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item),
Do something with each item of this stream, afterwards passing it on. Read more
sourcefn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>,
fn left_stream<B>(self) -> Either<Self, B> where
B: Stream<Item = Self::Item>,
Wrap this stream in an Either
stream, making it the left-hand variant
of that Either
. Read more
sourcefn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>,
fn right_stream<B>(self) -> Either<B, Self> where
B: Stream<Item = Self::Item>,
Wrap this stream in an Either
stream, making it the right-hand variant
of that Either
. Read more
sourcefn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
fn poll_next_unpin(&mut self, cx: &mut Context<'_>) -> Poll<Option<Self::Item>> where
Self: Unpin,
A convenience method for calling Stream::poll_next
on Unpin
stream types. Read more
sourcefn select_next_some(&mut self) -> SelectNextSome<'_, Self> where
Self: Unpin + FusedStream,
fn select_next_some(&mut self) -> SelectNextSome<'_, Self> where
Self: Unpin + FusedStream,
sourceimpl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
impl<S, T, E> TryStream for S where
S: Stream<Item = Result<T, E>> + ?Sized,
sourceimpl<S> TryStreamExt for S where
S: TryStream + ?Sized,
impl<S> TryStreamExt for S where
S: TryStream + ?Sized,
sourcefn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
fn err_into<E>(self) -> ErrInto<Self, E> where
Self::Error: Into<E>,
Wraps the current stream in a new stream which converts the error type into the one provided. Read more
sourcefn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
fn map_ok<T, F>(self, f: F) -> MapOk<Self, F> where
F: FnMut(Self::Ok) -> T,
Wraps the current stream in a new stream which maps the success value using the provided closure. Read more
sourcefn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
fn map_err<E, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> E,
Wraps the current stream in a new stream which maps the error value using the provided closure. Read more
sourcefn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
fn and_then<Fut, F>(self, f: F) -> AndThen<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Error = Self::Error>,
Chain on a computation for when a value is ready, passing the successful
results to the provided closure f
. Read more
sourcefn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
fn or_else<Fut, F>(self, f: F) -> OrElse<Self, Fut, F> where
F: FnMut(Self::Error) -> Fut,
Fut: TryFuture<Ok = Self::Ok>,
Chain on a computation for when an error happens, passing the
erroneous result to the provided closure f
. Read more
sourcefn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F> where
F: FnMut(&Self::Ok),
Do something with the success value of this stream, afterwards passing it on. Read more
sourcefn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
F: FnMut(&Self::Error),
Do something with the error value of this stream, afterwards passing it on. Read more
sourcefn into_stream(self) -> IntoStream<Self>
fn into_stream(self) -> IntoStream<Self>
sourcefn try_next(&mut self) -> TryNext<'_, Self> where
Self: Unpin,
fn try_next(&mut self) -> TryNext<'_, Self> where
Self: Unpin,
Creates a future that attempts to resolve the next item in the stream. If an error is encountered before the next item, the error is returned instead. Read more
sourcefn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
fn try_for_each<Fut, F>(self, f: F) -> TryForEach<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: TryFuture<Ok = (), Error = Self::Error>,
Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream. Read more
sourcefn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_skip_while<Fut, F>(self, f: F) -> TrySkipWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Skip elements on this stream while the provided asynchronous predicate
resolves to true
. Read more
sourcefn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
fn try_take_while<Fut, F>(self, f: F) -> TryTakeWhile<Self, Fut, F> where
F: FnMut(&Self::Ok) -> Fut,
Fut: TryFuture<Ok = bool, Error = Self::Error>,
Take elements on this stream while the provided asynchronous predicate
resolves to true
. Read more
sourcefn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
fn try_for_each_concurrent<Fut, F>(
self,
limit: impl Into<Option<usize>>,
f: F
) -> TryForEachConcurrent<Self, Fut, F> where
F: FnMut(Self::Ok) -> Fut,
Fut: Future<Output = Result<(), Self::Error>>,
Attempts to run this stream to completion, executing the provided asynchronous closure for each element on the stream concurrently as elements become available, exiting as soon as an error occurs. Read more
sourcefn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>,
fn try_collect<C>(self) -> TryCollect<Self, C> where
C: Default + Extend<Self::Ok>,
Attempt to transform a stream into a collection, returning a future representing the result of that computation. Read more
sourcefn try_chunks(self, capacity: usize) -> TryChunks<Self>
fn try_chunks(self, capacity: usize) -> TryChunks<Self>
An adaptor for chunking up successful items of the stream inside a vector. Read more
sourcefn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
fn try_filter<Fut, F>(self, f: F) -> TryFilter<Self, Fut, F> where
Fut: Future<Output = bool>,
F: FnMut(&Self::Ok) -> Fut,
Attempt to filter the values produced by this stream according to the provided asynchronous closure. Read more
sourcefn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
fn try_filter_map<Fut, F, T>(self, f: F) -> TryFilterMap<Self, Fut, F> where
Fut: TryFuture<Ok = Option<T>, Error = Self::Error>,
F: FnMut(Self::Ok) -> Fut,
Attempt to filter the values produced by this stream while simultaneously mapping them to a different type according to the provided asynchronous closure. Read more
sourcefn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
fn try_flatten(self) -> TryFlatten<Self> where
Self::Ok: TryStream,
<Self::Ok as TryStream>::Error: From<Self::Error>,
Flattens a stream of streams into just one continuous stream. Read more
sourcefn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
fn try_fold<T, Fut, F>(self, init: T, f: F) -> TryFold<Self, Fut, T, F> where
F: FnMut(T, Self::Ok) -> Fut,
Fut: TryFuture<Ok = T, Error = Self::Error>,
Attempt to execute an accumulating asynchronous computation over a stream, collecting all the values into one final result. Read more
sourcefn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
fn try_concat(self) -> TryConcat<Self> where
Self::Ok: Extend<<Self::Ok as IntoIterator>::Item>,
Self::Ok: IntoIterator,
Self::Ok: Default,
Attempt to concatenate all items of a stream into a single extendable destination, returning a future representing the end result. Read more
sourcefn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_buffer_unordered(self, n: usize) -> TryBufferUnordered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Attempt to execute several futures from a stream concurrently (unordered). Read more
sourcefn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
fn try_buffered(self, n: usize) -> TryBuffered<Self> where
Self::Ok: TryFuture,
<Self::Ok as TryFuture>::Error == Self::Error,
Attempt to execute several futures from a stream concurrently. Read more