Struct rbatis::plugin::page::Page

pub struct Page<T: Send + Sync> {
    pub records: Vec<T>,
    pub total: u64,
    pub page_no: u64,
    pub page_size: u64,
    pub do_count: bool,
}

Fields

records: Vec<T>

data

total: u64

total num

page_no: u64

current page index

page_size: u64

default 10

do_count: bool

Control whether to execute count statements to count the total number

Implementations

impl<T: Send + Sync> Page<T>

pub fn new(current: u64, page_size: u64) -> Self

pub fn new_option(current: &Option<u64>, page_size: &Option<u64>) -> Self

pub fn new_total(page_no: u64, page_size: u64, total: u64) -> Self

pub fn make_pages(data: Vec<T>, page_size: u64) -> Vec<Page<T>>

create Vec from data

pub fn make_ranges(total: u64, page_size: u64) -> Vec<(u64, u64)>

create (Vec<offset,limit>) from total,page_size

pub fn set_total(self, total: u64) -> Self

pub fn set_page_size(self, arg: u64) -> Self

pub fn set_page_no(self, arg: u64) -> Self

pub fn set_do_count(self, arg: bool) -> Self

Control whether to execute count statements to count the total number

impl<V: Send + Sync> Page<V>

pub fn from<T: Send + Sync>(arg: Page<T>) -> Self

where V: From<T>,

Trait Implementations

impl<T: Clone + Send + Sync> Clone for Page<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug + Send + Sync> Debug for Page<T>

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

Formats the value using the given formatter.

impl<T: Send + Sync> Default for Page<T>

fn default() -> Self

Returns the “default value” for a type.

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

where T: Deserialize<'de> + Send + Sync,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T: Display + Debug + Send + Sync> Display for Page<T>

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

Formats the value using the given formatter.

impl<T: Send + Sync> IPage<T> for Page<T>

fn get_records(&self) -> &Vec<T>

fn get_records_mut(&mut self) -> &mut Vec<T>

fn set_records(self, arg: Vec<T>) -> Self

impl<T: Send + Sync> IPageRequest for Page<T>

fn page_size(&self) -> u64

fn page_no(&self) -> u64

fn total(&self) -> u64

fn do_count(&self) -> bool

Control whether to execute count statements to count the total number

fn set_total(&mut self, arg: u64)

fn set_page_size(&mut self, arg: u64)

fn set_page_no(&mut self, arg: u64)

fn set_do_count(&mut self, arg: bool)

Control execute select count(1) from table

fn pages(&self) -> u64

sum pages

fn offset(&self) -> u64

sum offset

fn offset_limit(&self) -> u64

sum offset_limit

fn search_count(&self) -> bool

👎Deprecated: please use do_count()

fn set_search_count(&mut self, arg: bool)

👎Deprecated: please use set_do_count()

impl<T: PartialEq + Send + Sync> PartialEq for Page<T>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<T> Serialize for Page<T>

where T: Serialize + Send + Sync,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T: Eq + Send + Sync> Eq for Page<T>

impl<T: Send + Sync> StructuralPartialEq for Page<T>