memory_addr 0.4.1

Wrappers and helper functions for physical and virtual addresses
Documentation 
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
123
124
125
126
127
128
129
130
131
132

use crate::MemoryAddr;

/// A page-by-page iterator.
///
/// The page size is specified by the generic parameter `PAGE_SIZE`, which must
/// be a power of 2.
///
/// The address type is specified by the type parameter `A`.
///
/// # Examples
///
/// ```
/// use memory_addr::PageIter;
///
/// let mut iter = PageIter::<0x1000, usize>::new(0x1000, 0x3000).unwrap();
/// assert_eq!(iter.next(), Some(0x1000));
/// assert_eq!(iter.next(), Some(0x2000));
/// assert_eq!(iter.next(), None);
///
/// assert!(PageIter::<0x1000, usize>::new(0x1000, 0x3001).is_none());
/// ```
pub struct PageIter<const PAGE_SIZE: usize, A>
where
    A: MemoryAddr,
{
    start: A,
    end: A,
}

impl<A, const PAGE_SIZE: usize> PageIter<PAGE_SIZE, A>
where
    A: MemoryAddr,
{
    /// Creates a new [`PageIter`].
    ///
    /// Returns `None` if `PAGE_SIZE` is not a power of 2, or `start` or `end`
    /// is not page-aligned.
    pub fn new(start: A, end: A) -> Option<Self> {
        if !PAGE_SIZE.is_power_of_two()
            || !start.is_aligned(PAGE_SIZE)
            || !end.is_aligned(PAGE_SIZE)
        {
            None
        } else {
            Some(Self { start, end })
        }
    }
}

impl<A, const PAGE_SIZE: usize> Iterator for PageIter<PAGE_SIZE, A>
where
    A: MemoryAddr,
{
    type Item = A;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start < self.end {
            let ret = self.start;
            self.start = self.start.add(PAGE_SIZE);
            Some(ret)
        } else {
            None
        }
    }
}

/// A page-by-page iterator with dynamic page size.
///
/// The address type is specified by the type parameter `A`.
///
/// # Examples
///
/// ```
/// use memory_addr::DynPageIter;
///
/// let mut iter = DynPageIter::<usize>::new(0x1000, 0x3000, 0x1000).unwrap();
/// assert_eq!(iter.next(), Some(0x1000));
/// assert_eq!(iter.next(), Some(0x2000));
/// assert_eq!(iter.next(), None);
///
/// assert!(DynPageIter::<usize>::new(0x1000, 0x3001, 0x1000).is_none());
/// assert!(DynPageIter::<usize>::new(0x1000, 0x3000, 0x1001).is_none());
/// ```
pub struct DynPageIter<A>
where
    A: MemoryAddr,
{
    start: A,
    end: A,
    page_size: usize,
}

impl<A> DynPageIter<A>
where
    A: MemoryAddr,
{
    /// Creates a new [`DynPageIter`].
    ///
    /// Returns `None` if `page_size` is not a power of 2, or `start` or `end`
    /// is not page-aligned.
    pub fn new(start: A, end: A, page_size: usize) -> Option<Self> {
        if !page_size.is_power_of_two()
            || !start.is_aligned(page_size)
            || !end.is_aligned(page_size)
        {
            None
        } else {
            Some(Self {
                start,
                end,
                page_size,
            })
        }
    }
}

impl<A> Iterator for DynPageIter<A>
where
    A: MemoryAddr,
{
    type Item = A;

    fn next(&mut self) -> Option<Self::Item> {
        if self.start < self.end {
            let ret = self.start;
            self.start = self.start.add(self.page_size);
            Some(ret)
        } else {
            None
        }
    }
}