1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122

/**
 * This `struct` is created by the [`Connection::paginate_find_where`] method.
 *
 * [`Connection::paginate_find_where`]: struct.Connection.html#method.paginate_find_where
 */
#[derive(Debug)]
pub struct Pager<E: crate::Entity> {
    rows: crate::Rows<E>,
    count: usize,
    page: usize,
    max_per_page: usize,
}

impl<E: crate::Entity> Pager<E> {
    pub(crate) fn new(
        rows: crate::Rows<E>,
        count: usize,
        page: usize,
        max_per_page: usize,
    ) -> Self {
        Self {
            rows,
            count,
            page,
            max_per_page,
        }
    }

    /**
     * Get the number of results in this page.
     */
    pub fn result_count(&self) -> usize {
        self.rows.len()
    }

    /**
     * Get the index of the first element of this page.
     */
    pub fn result_min(&self) -> usize {
        usize::min(1 + self.max_per_page * (self.page - 1), self.count)
    }

    /**
     * Get the index of the last element of this page.
     */
    pub fn result_max(&self) -> usize {
        (self.page - 1) * self.max_per_page + self.result_count()
    }

    /**
     * Get the last page index.
     */
    pub fn last_page(&self) -> usize {
        if self.count == 0 {
            1
        }
        else {
            (self.count as f32 / self.max_per_page as f32).ceil() as usize
        }
    }

    /**
     * Get the current page index.
     */
    pub fn page(&self) -> usize {
        self.page
    }

    /**
     * True if a next page exists.
     */
    pub fn has_next_page(&self) -> bool {
        self.page < self.last_page()
    }

    /**
     * True if a previous page exists.
     */
    pub fn has_previous_page(&self) -> bool {
        self.page > 1
    }

    /**
     * Get the total number of results in all pages.
     */
    pub fn count(&self) -> usize {
        self.count
    }

    /**
     * Get maximum result per page.
     */
    pub fn max_per_page(&self) -> usize {
        self.max_per_page
    }
}

#[cfg(feature = "serde-support")]
impl<E: crate::Entity + serde::Serialize> serde::Serialize for Pager<E> {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        use serde::ser::SerializeStruct;

        let mut state = serializer.serialize_struct("Pager", 3)?;

        state.serialize_field("result_count", &self.result_count())?;
        state.serialize_field("result_min", &self.result_min())?;
        state.serialize_field("result_max", &self.result_max())?;
        state.serialize_field("last_page", &self.last_page())?;
        state.serialize_field("page", &self.page())?;
        state.serialize_field("has_next_page", &self.has_next_page())?;
        state
            .serialize_field("has_previous_page", &self.has_previous_page())?;
        state.serialize_field("count", &self.count())?;
        state.serialize_field("max_per_page", &self.max_per_page())?;
        state.serialize_field("iterator", &self.rows)?;

        state.end()
    }
}