Struct Page 

pub struct Page<E> { /* private fields */ }

Model to represent paginated items.

Fields:

• items: Represents the items in a Page as a Vec of E.
• page: Represents the page index in a Page. It starts from 0 to pages - 1.
• size: Represents the maximum number of elements per Page. items length must be equal to size for all pages except the last page, when items length could be less than or equal to size.
• total: Represents the total number of records used for pagination.
• pages: Represents the total number of pages required for paginate the items.
• previous_page: Represents the previous page index in a Page. If there is no previous page, it will be None.
• next_page: Represents the next page index in a Page. If there is no next page, it will be None.

Implementations

impl<E> Page<E>

pub fn get_items(&self) -> &Vec<E>

Get items

pub fn get_page(&self) -> usize

Get page

pub fn get_size(&self) -> usize

Get size

pub fn get_total(&self) -> usize

Get total

pub fn get_pages(&self) -> usize

Get pages

pub fn get_previous_page(&self) -> Option<usize>

Get previous_page

pub fn get_next_page(&self) -> Option<usize>

Get next_page

pub fn new( items: &Vec<E>, page: usize, size: usize, total: usize, ) -> PaginationResult<Page<E>>

where E: Clone,

Create a new Page instance.

Arguments:

• items: A reference to a collection of items E, where E must implement Clone.
• page: The page index.
• size: The maximum number of elements per page.
• total: The total number of records used for pagination.

Returns:

A PaginationResult with a Page if successful, otherwise a PaginationError is returned.

Example:

   use page_hunter::*;

   let items: Vec<u32> = vec![1, 2];
   let page: usize = 0;
   let size: usize = 2;
   let total_elements: usize = 5;

   let pagination_result: PaginationResult<Page<u32>> = Page::new(
     &items,
     page,
     size,
     total_elements,
   );

   let page: Page<u32> = match pagination_result {
     Ok(page) => page,
     Err(error) => panic!("Error: {}", error),
   };

Trait Implementations

impl<E: Clone> Clone for Page<E>

fn clone(&self) -> Page<E>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<E> ComposeSchema for Page<E>

where E: ToSchema,

fn compose(generics: Vec<RefOr<Schema>>) -> RefOr<Schema>

impl<E: Debug> Debug for Page<E>

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

Formats the value using the given formatter.

impl<E> Default for Page<E>

Implementation of Default for Page.

fn default() -> Self

Returns the “default value” for a type.

impl<'de, E> Deserialize<'de> for Page<E>

where E: Deserialize<'de>,

Available on crate feature serde only.

Implementation of Deserialize for Page if the feature serde is enabled.

fn deserialize<D>(deserializer: D) -> Result<Page<E>, D::Error>

where D: DeDeserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<E> Display for Page<E>

where E: Debug,

Implementation of Display for Page.

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

Formats the value using the given formatter.

impl<E> IntoIterator for Page<E>

Implementation of IntoIterator for Page.

type Item = E

The type of the elements being iterated over.

type IntoIter = IntoIter<<Page<E> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.

impl<E> Serialize for Page<E>

where E: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<E> ToSchema for Page<E>

where E: ToSchema,

fn name() -> Cow<'static, str>

Return name of the schema.

fn schemas(schemas: &mut Vec<(String, RefOr<Schema>)>)

Implement reference utoipa::openapi::schema::Schemas for this type.