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

use crate::{
    decoder::{DecodeStatus, Decoder},
    encoder::Encoder,
    DecodeError,
};

/// The iterator returned by [`crate::encode_iter`].
#[derive(Debug, Clone, Copy)]
pub struct EncodeIter<I> {
    iter: I,
    encoder: Encoder,
}

impl<I> EncodeIter<I> {
    pub(crate) fn new(iter: I) -> Self {
        Self {
            iter,
            encoder: Encoder::default(),
        }
    }

    /// Get a reference to the inner iterator.
    pub fn inner(&self) -> &I {
        &self.iter
    }

    /// Get a mutable reference to the inner iterator.
    pub fn inner_mut(&mut self) -> &mut I {
        &mut self.iter
    }

    /// Take the inner iterator.
    pub fn into_inner(self) -> I {
        self.iter
    }
}

impl<I> Iterator for EncodeIter<I>
where
    I: Iterator<Item = u8>,
{
    type Item = char;

    fn next(&mut self) -> Option<Self::Item> {
        if let Some(encoded) = self.encoder.next() {
            return Some(encoded);
        }

        let byte = self.iter.next()?;
        let encoded = self.encoder.push(byte);
        Some(encoded)
    }
}

/// The iterator returned by [`crate::decode_iter`].
#[derive(Debug, Clone, Copy)]
pub struct DecodeIter<I> {
    iter: I,
    decoder: Decoder,
}

impl<I> DecodeIter<I> {
    pub(crate) fn new(iter: I) -> Self {
        Self {
            iter,
            decoder: Decoder::default(),
        }
    }

    /// Get a reference to the inner iterator.
    pub fn inner(&self) -> &I {
        &self.iter
    }

    /// Get a mutable reference to the inner iterator.
    pub fn inner_mut(&mut self) -> &mut I {
        &mut self.iter
    }

    /// Take the inner iterator.
    pub fn into_inner(self) -> I {
        self.iter
    }
}

impl<I> Iterator for DecodeIter<I>
where
    I: Iterator<Item = u8>,
{
    type Item = Result<u8, DecodeError>;

    fn next(&mut self) -> Option<Self::Item> {
        loop {
            let next_byte = self.iter.next();
            match self.decoder.push(next_byte) {
                DecodeStatus::NeedMore => {}
                DecodeStatus::Emit(result) => {
                    return result;
                }
            }
        }
    }
}