Struct egg_mode::cursor::CursorIter

#[must_use = "cursor iterators are lazy and do nothing unless consumed"]
pub struct CursorIter<'a, T> where
    T: Cursor + for<'de> Deserialize<'de> + '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 tokio::runtime::current_thread::block_on_all;
use futures::Stream;

block_on_all(egg_mode::user::followers_of("rustlang", &token).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 tokio::runtime::current_thread::block_on_all;
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> =
    block_on_all(egg_mode::user::followers_of("rustlang", &token).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:

use tokio::runtime::current_thread::block_on_all;
let mut list = egg_mode::user::followers_of("rustlang", &token).with_page_size(20);
let resp = block_on_all(list.call()).unwrap();

for user in resp.response.users {
    println!("{} (@{})", user.name, user.screen_name);
}

list.next_cursor = resp.response.next_cursor;
let resp = block_on_all(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 + for<'de> Deserialize<'de> + 'a, 

pub fn with_page_size(self, page_size: i32) -> CursorIter<'a, T>

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.

pub fn call(&self) -> FutureResponse<T>

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 + for<'de> Deserialize<'de> + '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>

Attempt to pull out the next value of this stream, returning None if the stream is finished.

fn wait(self) -> Wait<Self>

Creates an iterator which blocks the current thread until each item of this stream is resolved.

fn into_future(self) -> StreamFuture<Self>

Converts this stream into a Future.

fn map<U, F>(self, f: F) -> Map<Self, F> where
    F: FnMut(Self::Item) -> U, 

Converts a stream of type T to a stream of type U.

fn map_err<U, F>(self, f: F) -> MapErr<Self, F> where
    F: FnMut(Self::Error) -> U, 

Converts a stream of error type T to a stream of error type U.

fn filter<F>(self, f: F) -> Filter<Self, F> where
    F: FnMut(&Self::Item) -> bool, 

Filters the values produced by this stream according to the provided predicate.

fn filter_map<F, B>(self, f: F) -> FilterMap<Self, F> where
    F: FnMut(Self::Item) -> Option<B>, 

Filters the values produced by this stream while simultaneously mapping them to a different type.

fn then<F, U>(self, f: F) -> Then<Self, F, U> where
    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.

fn and_then<F, U>(self, f: F) -> AndThen<Self, F, U> where
    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.

fn or_else<F, U>(self, f: F) -> OrElse<Self, F, U> where
    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.

fn collect(self) -> Collect<Self>

Collect all of the values of this stream into a vector, returning a future representing the result of that computation.

fn concat2(self) -> Concat2<Self> where
    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.

fn concat(self) -> Concat<Self> where
    Self::Item: Extend<<Self::Item as IntoIterator>::Item>,
    Self::Item: IntoIterator, 

Deprecated since 0.1.14:

please use Stream::concat2 instead

Concatenate all results of a stream into a single extendable destination, returning a future representing the end result.

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>, 

Execute an accumulating computation over a stream, collecting all the values into one final result.

fn flatten(self) -> Flatten<Self> where
    Self::Item: Stream,
    <Self::Item as Stream>::Error: From<Self::Error>, 

Flattens a stream of streams into just one continuous stream.

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>, 

Skip elements on this stream while the predicate provided resolves to true.

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>, 

Take elements from this stream while the predicate provided resolves to true.

fn for_each<F, U>(self, f: F) -> ForEach<Self, F, U> where
    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.

fn from_err<E>(self) -> FromErr<Self, E> where
    E: From<Self::Error>, 

Map this stream's error to any error implementing From for this stream's Error, returning a new stream.

fn take(self, amt: u64) -> Take<Self>

Creates a new stream of at most amt items of the underlying stream.

fn skip(self, amt: u64) -> Skip<Self>

Creates a new stream which skips amt items of the underlying stream.

fn fuse(self) -> Fuse<Self>

Fuse a stream such that poll will never again be called once it has finished.

fn by_ref(&mut self) -> &mut Self

Borrows a stream, rather than consuming it.

fn catch_unwind(self) -> CatchUnwind<Self> where
    Self: UnwindSafe, 

Catches unwinding panics while polling the stream.

fn buffered(self, amt: usize) -> Buffered<Self> where
    Self::Item: IntoFuture,
    <Self::Item as IntoFuture>::Error == Self::Error, 

An adaptor for creating a buffered list of pending futures.

fn buffer_unordered(self, amt: usize) -> BufferUnordered<Self> where
    Self::Item: IntoFuture,
    <Self::Item as IntoFuture>::Error == Self::Error, 

An adaptor for creating a buffered list of pending futures (unordered).

fn merge<S>(self, other: S) -> Merge<Self, S> where
    S: Stream<Error = Self::Error>, 

Deprecated:

functionality provided by select now

An adapter for merging the output of two streams.

fn zip<S>(self, other: S) -> Zip<Self, S> where
    S: Stream<Error = Self::Error>, 

An adapter for zipping two streams together.

fn chain<S>(self, other: S) -> Chain<Self, S> where
    S: Stream<Item = Self::Item, Error = Self::Error>, 

Adapter for chaining two stream.

fn peekable(self) -> Peekable<Self>

Creates a new stream which exposes a peek method.

fn chunks(self, capacity: usize) -> Chunks<Self>

An adaptor for chunking up items of the stream inside a vector.

fn select<S>(self, other: S) -> Select<Self, S> where
    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.

fn forward<S>(self, sink: S) -> Forward<Self, S> where
    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.

fn split(self) -> (SplitSink<Self>, SplitStream<Self>) where
    Self: Sink, 

Splits this Stream + Sink object into separate Stream and Sink objects.

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.

fn inspect_err<F>(self, f: F) -> InspectErr<Self, F> where
    F: FnMut(&Self::Error), 

Do something with the error of this stream, afterwards passing it on.