Struct HttpPaginator 

pub struct HttpPaginator<T, F, Fut> { /* private fields */ }

Call a function with an update HttpPaginationOptions for each batch request, simplifying lazy access to large response sets such as messages etc.

Implementations

impl<T, F, Fut> HttpPaginator<T, F, Fut>

where F: Fn(Option<HttpPaginationOptions>) -> Fut, Fut: Future<Output = HttpResult<Vec<T>>>,

pub fn new(http_fn: F, pagination: HttpPaginationOptions) -> Self

Create the paginator with the http batch generator.

Example

use sms_client::Client;
use sms_client::config::ClientConfig;
use sms_client::http::paginator::HttpPaginator;
use sms_client::types::http::HttpPaginationOptions;

let http = Client::new(ClientConfig::http_only("http://localhost:3000").with_auth("token!"))?.http_arc();
let mut paginator = HttpPaginator::new(
    move |pagination| {
        let http = http.expect("Missing HTTP client configuration!").clone();
        async move {
            http.get_latest_numbers(pagination).await
        }
    },
    HttpPaginationOptions::default()
        .with_limit(10) // Do it in batches of 10.
        .with_offset(10) // Skip the first 10 results.
        .with_reverse(true) // Reverse the results set.
);

pub fn with_defaults(http_fn: F) -> Self

Create a paginator with default pagination settings. This starts at offset 0 with a limit of 50 per page.

Example

use sms_client::Client;
use sms_client::config::ClientConfig;
use sms_client::http::HttpClient;
use sms_client::http::paginator::HttpPaginator;

/// View all latest numbers, in a default paginator with a limit of 50 per chunk.
async fn view_all_latest_numbers(http: HttpClient) {
    let mut paginator = HttpPaginator::with_defaults(|pagination| {
        http.get_latest_numbers(pagination)
    });
    while let Some(message) = paginator.next().await {
        log::info!("{:?}", message);
    }
}

pub async fn next(&mut self) -> Option<T>

Get the next item, automatically fetching next pages as needed.

Example

use sms_client::http::HttpClient;
use sms_client::http::paginator::HttpPaginator;

async fn get_delivery_reports(message_id: i64, http: HttpClient) {
    let mut paginator = HttpPaginator::with_defaults(|pagination| {
        http.get_delivery_reports(message_id, pagination)
    }).await;

    /// Iterate through ALL messages, with a page size of 50 (default).
    while let Some(message) = paginator.next().await {
        log::info!("{:?}", message);
    }
}

pub async fn collect_all(self) -> HttpResult<Vec<T>>

Collect all remaining items into a Vec. This continues to request batches until empty.

pub async fn take(self, n: usize) -> HttpResult<Vec<T>>

Process items in chunks, calling the provided closure for each chunk.

pub async fn for_each_chuck<C>( self, chunk_size: usize, chunk_fn: C, ) -> HttpResult<()>

where C: FnMut(&[T]) -> HttpResult<()>,

Process items in chunks, calling the provided closure for each chunk.

Example

use std::sync::Arc;
use sms_client::http::HttpClient;
use sms_client::http::paginator::HttpPaginator;
use sms_client::types::http::HttpPaginationOptions;

/// Read all messages from a phone number, in chunks of 10.
async fn read_all_messages(phone_number: &str, http: Arc<HttpClient>) {
    let paginator = HttpPaginator::with_defaults(|pagination| {
        http.get_messages(phone_number, pagination)
    }).await;

    paginator.for_each_chuck(10, |batch| {
        for message in batch {
            log::info!("{:?}", message);
        }
    }).await?;
}

pub async fn skip(self, n: usize) -> Self

Skip n items and return the paginator.

pub fn current_pagination(&self) -> &HttpPaginationOptions

Get the current pagination options state.

pub fn has_more(&self) -> bool

Check if there are potentially more items to fetch.