digits_iterator 0.1.0

Iterate over the digits of numbers in an arbitrary radix
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

#[cfg(test)]
mod tests;

use int::Int;

pub struct Digits<T>
where
    T: Int,
{
    n: T::Unsigned,
    div: T::Unsigned,
    base: T::Unsigned,
}

impl<T> Digits<T>
where
    T: Int,
{
    pub fn new(n: T) -> Digits<T> {
        Self::with_base(n, 10)
    }

    pub fn with_base(n: T, base: u32) -> Digits<T> {
        fn is_ok_as_base(base: u32) -> bool {
            base >= 2 && base <= 36
        }
        assert!(is_ok_as_base(base));

        let base = T::from_base(base);

        let mut div = T::one();
        loop {
            div = match div.checked_mul(base) {
                None => break,
                Some(i) if n < i => break,
                Some(i) => i,
            };
        }

        Digits {
            n: n.as_unsigned(),
            div: div.as_unsigned(),
            base: base.as_unsigned(),
        }
    }
}

macro_rules! impl_iterators {
    { $from: ty, $u: ty } => {
        impl Iterator for Digits<$from> {
            type Item = u8;

            fn next(&mut self) -> Option<Self::Item> {
                if self.div == 0 {
                    None
                } else {
                    let result = self.n / self.div;
                    self.n %= self.div;
                    self.div /= self.base;

                    Some(result as u8)
                }
            }
        }

        impl DoubleEndedIterator for Digits<$from> {
            fn next_back(&mut self) -> Option<Self::Item> {
                if self.div == 0 {
                    None
                } else {
                    let result = self.n % self.base;
                    self.n /= self.base;
                    self.div /= self.base;

                    Some(result as u8)
                }
            }
        }
    }
}

impl_iterators!(isize, usize);
impl_iterators!(usize, usize);

impl_iterators!(i128, u128);
impl_iterators!(u128, u128);

impl_iterators!(i64, u64);
impl_iterators!(u64, u64);

impl_iterators!(i32, u32);
impl_iterators!(u32, u32);

impl_iterators!(i16, u16);
impl_iterators!(u16, u16);

impl_iterators!(i8, u8);
impl_iterators!(u8, u8);