heapless 0.9.2

`static` friendly data structures that don't require dynamic memory allocation
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
133
134
135
136
137
138

use core::{fmt, iter::FusedIterator, str::Chars};

use crate::LenType;

use super::StringView;

/// A draining iterator for `String`.
///
/// This struct is created by the [`drain`] method on [`crate::String`]. See its
/// documentation for more.
///
/// [`drain`]: crate::String::drain
pub struct Drain<'a, LenT: LenType> {
    /// Will be used as &'a mut String in the destructor
    pub(super) string: *mut StringView<LenT>,
    /// Stast of part to remove
    pub(super) start: LenT,
    /// End of part to remove
    pub(super) end: LenT,
    /// Current remaining range to remove
    pub(super) iter: Chars<'a>,
}

impl<LenT: LenType> fmt::Debug for Drain<'_, LenT> {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        f.debug_tuple("Drain").field(&self.as_str()).finish()
    }
}

unsafe impl<LenT: LenType> Sync for Drain<'_, LenT> {}
unsafe impl<LenT: LenType> Send for Drain<'_, LenT> {}

impl<LenT: LenType> Drop for Drain<'_, LenT> {
    fn drop(&mut self) {
        unsafe {
            // Use `Vec::drain`. “Reaffirm” the bounds checks to avoid
            // panic code being inserted again.
            let self_vec = (*self.string).as_mut_vec();
            let start = self.start.into_usize();
            let end = self.end.into_usize();
            if start <= end && end <= self_vec.len() {
                self_vec.drain(start..end);
            }
        }
    }
}

impl<LenT: LenType> Drain<'_, LenT> {
    /// Returns the remaining (sub)string of this iterator as a slice.
    ///
    /// # Examples
    ///
    /// ```
    /// use heapless::String;
    ///
    /// let mut s = String::<8>::try_from("abc").unwrap();
    /// let mut drain = s.drain(..);
    /// assert_eq!(drain.as_str(), "abc");
    /// let _ = drain.next().unwrap();
    /// assert_eq!(drain.as_str(), "bc");
    /// ```
    #[must_use]
    pub fn as_str(&self) -> &str {
        self.iter.as_str()
    }
}

impl<LenT: LenType> AsRef<str> for Drain<'_, LenT> {
    fn as_ref(&self) -> &str {
        self.as_str()
    }
}

impl<LenT: LenType> AsRef<[u8]> for Drain<'_, LenT> {
    fn as_ref(&self) -> &[u8] {
        self.as_str().as_bytes()
    }
}

impl<LenT: LenType> Iterator for Drain<'_, LenT> {
    type Item = char;

    #[inline]
    fn next(&mut self) -> Option<char> {
        self.iter.next()
    }

    fn size_hint(&self) -> (usize, Option<usize>) {
        self.iter.size_hint()
    }

    #[inline]
    fn last(mut self) -> Option<char> {
        self.next_back()
    }
}

impl<LenT: LenType> DoubleEndedIterator for Drain<'_, LenT> {
    #[inline]
    fn next_back(&mut self) -> Option<char> {
        self.iter.next_back()
    }
}

impl<LenT: LenType> FusedIterator for Drain<'_, LenT> {}

#[cfg(test)]
mod tests {
    use crate::String;

    #[test]
    fn drain_front() {
        let mut s = String::<8>::try_from("abcd").unwrap();
        let mut it = s.drain(..1);
        assert_eq!(it.next(), Some('a'));
        drop(it);
        assert_eq!(s, "bcd");
    }

    #[test]
    fn drain_middle() {
        let mut s = String::<8>::try_from("abcd").unwrap();
        let mut it = s.drain(1..3);
        assert_eq!(it.next(), Some('b'));
        assert_eq!(it.next(), Some('c'));
        drop(it);
        assert_eq!(s, "ad");
    }

    #[test]
    fn drain_end() {
        let mut s = String::<8>::try_from("abcd").unwrap();
        let mut it = s.drain(3..);
        assert_eq!(it.next(), Some('d'));
        drop(it);
        assert_eq!(s, "abc");
    }
}