Struct egg_mode::cursor::CursorIter
[−]
[src]
#[must_use = "cursor iterators are lazy and do nothing unless consumed"]pub struct CursorIter<'a, T> where
T: Cursor + FromJson + 'a, { pub page_size: Option<i32>, pub previous_cursor: i64, pub next_cursor: i64, // some fields omitted }
Represents a paginated list of results, such as the users who follow a specific user or the lists owned by that user.
This struct is given by several methods in this library, whenever Twitter would return a
cursored list of items. It implements the Stream
trait, loading items in batches so that
several can be immedately returned whenever a single network call completes.
use futures::Stream; core.run(egg_mode::user::followers_of("rustlang", &token, &handle).take(10).for_each(|resp| { println!("{}", resp.screen_name); Ok(()) })).unwrap();
You can even collect the results, letting you get one set of rate-limit information for the entire search setup:
use futures::Stream; use egg_mode::Response; use egg_mode::user::TwitterUser; use egg_mode::error::Error; // Because Streams don't have a FromIterator adaptor, we load all the responses first, then // collect them into the final Vec let names: Result<Response<Vec<TwitterUser>>, Error> = core.run(egg_mode::user::followers_of("rustlang", &token, &handle).take(10).collect()) .map(|resp| resp.into_iter().collect());
CursorIter
has an adaptor of its own, with_page_size
, that you can use before consuming it.
with_page_size
will let you set how many users are pulled in with a single network call.
Calling it after starting iteration will clear any current results.
(A note about with_page_size
/page_size
: While the CursorIter
struct always has this method
and field available, not every cursored call supports changing page size. Check the individual
method documentation for notes on what page sizes are allowed.)
The Stream
implementation yields Response<T::Item>
on a successful iteration, and Error
for errors, so network errors, rate-limit errors and other issues are passed directly through
in poll()
. The Stream
implementation will allow you to poll again after an error to
re-initiate the late network call; this way, you can wait for your network connection to return
or for your rate limit to refresh and try again with the same state.
Manual paging
The Stream
implementation works by loading in a page of results (with size set by the
method's default or by with_page_size
/the page_size
field) when it's polled, and serving
the individual elements from that locally-cached page until it runs out. This can be nice, but
it also means that your only warning that something involves a network call is that the stream
returns Ok(Async::NotReady)
, by which time the network call has already started. If you want
to know that ahead of time, that's where the call()
method comes in. By using call()
, you
can get the cursor struct directly from Twitter. With that you can iterate over the results and
page forward and backward as needed:
let mut list = egg_mode::user::followers_of("rustlang", &token, &handle).with_page_size(20); let resp = core.run(list.call()).unwrap(); for user in resp.response.users { println!("{} (@{})", user.name, user.screen_name); } list.next_cursor = resp.response.next_cursor; let resp = core.run(list.call()).unwrap(); for user in resp.response.users { println!("{} (@{})", user.name, user.screen_name); }
Fields
page_size: Option<i32>
The number of results returned in one network call.
Certain calls set their own minimums and maximums for what this value can be. Furthermore, some calls don't allow you to set the size of the pages at all. Refer to the individual methods' documentation for specifics.
previous_cursor: i64
Numeric reference to the previous page of results. A value of zero indicates that the current page of results is the first page of the cursor.
This value is intended to be automatically set and used as part of this struct's Iterator implementation. It is made available for those who wish to manually manage network calls and pagination.
next_cursor: i64
Numeric reference to the next page of results. A value of zero indicates that the current page of results is the last page of the cursor.
This value is intended to be automatically set and used as part of this struct's Iterator implementation. It is made available for those who wish to manually manage network calls and pagination.
Methods
impl<'a, T> CursorIter<'a, T> where
T: Cursor + FromJson + 'a,
[src]
T: Cursor + FromJson + 'a,
fn with_page_size(self, page_size: i32) -> CursorIter<'a, T>
[src]
Sets the number of results returned in a single network call.
Certain calls set their own minimums and maximums for what this value can be. Furthermore, some calls don't allow you to set the size of the pages at all. Refer to the individual methods' documentation for specifics. If this method is called for a response that does not accept changing the page size, no change to the underlying struct will occur.
Calling this function will invalidate any current results, if any were previously loaded.
fn call(&self) -> FutureResponse<'a, T>
[src]
Loads the next page of results.
This is intended to be used as part of this struct's Iterator implementation. It is provided as a convenience for those who wish to manage network calls and pagination manually.
Trait Implementations
impl<'a, T> Stream for CursorIter<'a, T> where
T: Cursor + FromJson + 'a,
[src]
T: Cursor + FromJson + 'a,
type Item = Response<T::Item>
The type of item this stream will yield on success.
type Error = Error
The type of error this stream may generate.
fn poll(&mut self) -> Poll<Option<Self::Item>, Self::Error>
[src]
Attempt to pull out the next value of this stream, returning None
if the stream is finished. Read more
fn wait(self) -> Wait<Self>
[src]
Creates an iterator which blocks the current thread until each item of this stream is resolved. Read more
fn into_future(self) -> StreamFuture<Self>
[src]
Converts this stream into a Future
. Read more
fn map<U, F>(self, f: F) -> Map<Self, F> where
F: FnMut(Self::Item) -> U,
[src]
F: FnMut(Self::Item) -> U,
Converts a stream of type T
to a stream of type U
. Read more
fn map_err<U, F>(self, f: F) -> MapErr<Self, F> where
F: FnMut(Self::Error) -> U,
[src]
F: FnMut(Self::Error) -> U,
Converts a stream of error type T
to a stream of error type U
. Read more
fn filter<F>(self, f: F) -> Filter<Self, F> where
F: FnMut(&Self::Item) -> bool,
[src]
F: FnMut(&Self::Item) -> bool,
Filters the values produced by this stream according to the provided predicate. Read more
fn filter_map<F, B>(self, f: F) -> FilterMap<Self, F> where
F: FnMut(Self::Item) -> Option<B>,
[src]
F: FnMut(Self::Item) -> Option<B>,
Filters the values produced by this stream while simultaneously mapping them to a different type. Read more
fn then<F, U>(self, f: F) -> Then<Self, F, U> where
F: FnMut(Result<Self::Item, Self::Error>) -> U,
U: IntoFuture,
[src]
F: FnMut(Result<Self::Item, Self::Error>) -> U,
U: IntoFuture,
Chain on a computation for when a value is ready, passing the resulting item to the provided closure f
. Read more
fn and_then<F, U>(self, f: F) -> AndThen<Self, F, U> where
F: FnMut(Self::Item) -> U,
U: IntoFuture<Error = Self::Error>,
[src]
F: FnMut(Self::Item) -> U,
U: IntoFuture<Error = Self::Error>,
Chain on a computation for when a value is ready, passing the successful results to the provided closure f
. Read more
fn or_else<F, U>(self, f: F) -> OrElse<Self, F, U> where
F: FnMut(Self::Error) -> U,
U: IntoFuture<Item = Self::Item>,
[src]
F: FnMut(Self::Error) -> U,
U: IntoFuture<Item = Self::Item>,
Chain on a computation for when an error happens, passing the erroneous result to the provided closure f
. Read more
fn collect(self) -> Collect<Self>
[src]
Collect all of the values of this stream into a vector, returning a future representing the result of that computation. Read more
fn concat2(self) -> Concat2<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
Self::Item: Default,
Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. Read more
fn concat(self) -> Concat<Self> where
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
[src]
Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
Self::Item: IntoIterator,
: please use Stream::concat2
instead
Concatenate all results of a stream into a single extendable destination, returning a future representing the end result. Read more
fn fold<F, T, Fut>(self, init: T, f: F) -> Fold<Self, F, Fut, T> where
F: FnMut(T, Self::Item) -> Fut,
Fut: IntoFuture<Item = T>,
Self::Error: From<<Fut as IntoFuture>::Error>,
[src]
F: FnMut(T, Self::Item) -> Fut,
Fut: IntoFuture<Item = T>,
Self::Error: From<<Fut as IntoFuture>::Error>,
Execute an accumulating computation over a stream, collecting all the values into one final result. Read more
fn flatten(self) -> Flatten<Self> where
Self::Item: Stream,
<Self::Item as Stream>::Error: From<Self::Error>,
[src]
Self::Item: Stream,
<Self::Item as Stream>::Error: From<Self::Error>,
Flattens a stream of streams into just one continuous stream. Read more
fn skip_while<P, R>(self, pred: P) -> SkipWhile<Self, P, R> where
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
[src]
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
Skip elements on this stream while the predicate provided resolves to true
. Read more
fn take_while<P, R>(self, pred: P) -> TakeWhile<Self, P, R> where
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
[src]
P: FnMut(&Self::Item) -> R,
R: IntoFuture<Item = bool, Error = Self::Error>,
Take elements from this stream while the predicate provided resolves to true
. Read more
fn for_each<F, U>(self, f: F) -> ForEach<Self, F, U> where
F: FnMut(Self::Item) -> U,
U: IntoFuture<Item = (), Error = Self::Error>,
[src]
F: FnMut(Self::Item) -> U,
U: IntoFuture<Item = (), Error = Self::Error>,
Runs this stream to completion, executing the provided closure for each element on the stream. Read more
fn from_err<E>(self) -> FromErr<Self, E> where
E: From<Self::Error>,
[src]
E: From<Self::Error>,
Map this stream's error to any error implementing From
for this stream's Error
, returning a new stream. Read more
fn take(self, amt: u64) -> Take<Self>
[src]
Creates a new stream of at most amt
items of the underlying stream. Read more
fn skip(self, amt: u64) -> Skip<Self>
[src]
Creates a new stream which skips amt
items of the underlying stream. Read more
fn fuse(self) -> Fuse<Self>
[src]
Fuse a stream such that poll
will never again be called once it has finished. Read more
fn by_ref(&mut self) -> &mut Self
[src]
Borrows a stream, rather than consuming it. Read more
fn catch_unwind(self) -> CatchUnwind<Self> where
Self: UnwindSafe,
[src]
Self: UnwindSafe,
Catches unwinding panics while polling the stream. Read more
fn buffered(self, amt: usize) -> Buffered<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
An adaptor for creating a buffered list of pending futures. Read more
fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
[src]
Self::Item: IntoFuture,
<Self::Item as IntoFuture>::Error == Self::Error,
An adaptor for creating a buffered list of pending futures (unordered). Read more
fn merge<S>(self, other: S) -> Merge<Self, S> where
S: Stream<Error = Self::Error>,
[src]
S: Stream<Error = Self::Error>,
: functionality provided by select
now
An adapter for merging the output of two streams. Read more
fn zip<S>(self, other: S) -> Zip<Self, S> where
S: Stream<Error = Self::Error>,
[src]
S: Stream<Error = Self::Error>,
An adapter for zipping two streams together. Read more
fn chain<S>(self, other: S) -> Chain<Self, S> where
S: Stream<Item = Self::Item, Error = Self::Error>,
[src]
S: Stream<Item = Self::Item, Error = Self::Error>,
Adapter for chaining two stream. Read more
fn peekable(self) -> Peekable<Self>
[src]
Creates a new stream which exposes a peek
method. Read more
fn chunks(self, capacity: usize) -> Chunks<Self>
[src]
An adaptor for chunking up items of the stream inside a vector. Read more
fn select<S>(self, other: S) -> Select<Self, S> where
S: Stream<Item = Self::Item, Error = Self::Error>,
[src]
S: Stream<Item = Self::Item, Error = Self::Error>,
Creates a stream that selects the next element from either this stream or the provided one, whichever is ready first. Read more
fn forward<S>(self, sink: S) -> Forward<Self, S> where
S: Sink<SinkItem = Self::Item>,
Self::Error: From<<S as Sink>::SinkError>,
[src]
S: Sink<SinkItem = Self::Item>,
Self::Error: From<<S as Sink>::SinkError>,
A future that completes after the given stream has been fully processed into the sink, including flushing. Read more
fn split(self) -> (SplitSink<Self>, SplitStream<Self>) where
Self: Sink,
[src]
Self: Sink,
Splits this Stream + Sink
object into separate Stream
and Sink
objects. Read more
fn inspect<F>(self, f: F) -> Inspect<Self, F> where
F: FnMut(&Self::Item) -> (),
[src]
F: FnMut(&Self::Item) -> (),
Do something with each item of this stream, afterwards passing it on. Read more