Struct Paginated 

pub struct Paginated<T> {
    pub items: Vec<T>,
    pub total: i64,
    pub limit: i64,
    pub offset: i64,
}

A page of rows plus the total, for pagination links and JSON envelopes.

Query::paginate builds one with two queries (the rows and COUNT(*)). Serializes as {"items": [...], "total": 42, "limit": 20, "offset": 0}.

Free plan

The count reads every matching row once more: on large tables, prefer plain “next page” links without a total (Page::next after Query::all) or cache the total.

Examples

use ocre::{Page, Paginated};

let page = Paginated { items: vec!["a", "b"], total: 5, limit: 2, offset: 2 };
assert_eq!(page.current_page(), 2);
assert_eq!(page.total_pages(), 3);
assert!(page.has_next() && page.has_previous());
assert_eq!(page.next_page(), Some(Page { limit: 2, offset: 4 }));
assert_eq!(page.previous_page(), Some(Page { limit: 2, offset: 0 }));
assert_eq!(serde_json::to_string(&page).unwrap(), r#"{"items":["a","b"],"total":5,"limit":2,"offset":2}"#);

Fields

items: Vec<T>

The rows of this page.

total: i64

Rows matching the query, all pages together.

limit: i64

Rows per page.

offset: i64

Rows skipped before this page.

Implementations

impl<T> Paginated<T>

pub fn current_page(&self) -> i64

1-based number of this page.

Examples

let page = ocre::Paginated::<()> { items: vec![], total: 0, limit: 10, offset: 0 };
assert_eq!(page.current_page(), 1);

pub fn total_pages(&self) -> i64

Number of pages (at least 1, even with no row).

Examples

let page = ocre::Paginated::<()> { items: vec![], total: 21, limit: 10, offset: 0 };
assert_eq!(page.total_pages(), 3);

pub fn has_next(&self) -> bool

Whether rows follow this page.

Examples

let page = ocre::Paginated::<()> { items: vec![], total: 10, limit: 10, offset: 0 };
assert!(!page.has_next());

pub fn has_previous(&self) -> bool

Whether rows come before this page.

Examples

let page = ocre::Paginated::<()> { items: vec![], total: 10, limit: 10, offset: 0 };
assert!(!page.has_previous());

pub fn next_page(&self) -> Option<Page>

The next page, if any.

Examples

let page = ocre::Paginated::<()> { items: vec![], total: 3, limit: 2, offset: 2 };
assert_eq!(page.next_page(), None);

pub fn previous_page(&self) -> Option<Page>

The previous page, if any (never a negative offset).

Examples

let page = ocre::Paginated::<()> { items: vec![], total: 30, limit: 10, offset: 5 };
assert_eq!(page.previous_page(), Some(ocre::Page { limit: 10, offset: 0 }));

pub fn map<U>(self, f: impl FnMut(T) -> U) -> Paginated<U>

Converts the items, keeping the counts (e.g. rows into view structs).

Examples

let page = ocre::Paginated { items: vec![1, 2], total: 2, limit: 10, offset: 0 };
assert_eq!(page.map(|n| n * 10).items, [10, 20]);

Trait Implementations

impl<T: Clone> Clone for Paginated<T>

fn clone(&self) -> Paginated<T>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug> Debug for Paginated<T>

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

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Paginated<T>

fn eq(&self, other: &Paginated<T>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<T> Serialize for Paginated<T>

where T: Serialize,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: PartialEq> StructuralPartialEq for Paginated<T>