conversion 0.1.0

An abstraction crate to convert iterators on the fly.
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

//! 7-bit ASCII Decoder/Encoder.

use crate::Converter;
use core::fmt;

/// An error while encoding/decoding ASCII characters.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub struct ASCIIEncodingError;

impl fmt::Display for ASCIIEncodingError {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "A character out of bound.")
    }
}

#[cfg(feature = "std")]
impl std::error::Error for ASCIIEncodingError {}

/// A decoder for 7-bit ASCII.
///
/// # Examples
/// ```
/// use conversion::converter::encoding::ascii::{ASCIIDecoder, ASCIIEncodingError};
/// use conversion::iter::ConvertedIterator;
///
/// let iter = b"stra\xc3\x9fe".into_iter().cloned();
/// let mut decoded = ConvertedIterator::new(iter, ASCIIDecoder::new());
///
/// assert_eq!(Some(Ok('s')), decoded.next());
/// assert_eq!(Some(Ok('t')), decoded.next());
/// assert_eq!(Some(Ok('r')), decoded.next());
/// assert_eq!(Some(Ok('a')), decoded.next());
/// assert_eq!(Some(Err(ASCIIEncodingError)), decoded.next());
/// assert_eq!(Some(Err(ASCIIEncodingError)), decoded.next());
/// assert_eq!(Some(Ok('e')), decoded.next());
/// assert_eq!(None, decoded.next());
/// ```
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ASCIIDecoder;

impl ASCIIDecoder {
    /// Create a new instance.
    #[inline]
    pub fn new() -> Self {
        Self::default()
    }
}

impl Converter for ASCIIDecoder {
    type Item = u8;
    type Output = char;
    type Error = ASCIIEncodingError;

    fn convert<E>(&mut self, item: Self::Item, buf: &mut E) -> Result<usize, Self::Error>
    where
        E: Extend<Self::Output>,
    {
        if item <= 0x7f {
            buf.extend([item as char]);
            Ok(1)
        } else {
            Err(ASCIIEncodingError)
        }
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        (1, Some(1))
    }
}

/// An encoder for 7-bit ASCII.
///
/// # Examples
/// ```
/// use conversion::converter::encoding::ascii::{ASCIIEncoder, ASCIIEncodingError};
/// use conversion::iter::ConvertedIterator;
///
/// let iter = "straße".chars();
/// let mut encoded = ConvertedIterator::new(iter, ASCIIEncoder::new());
///
/// assert_eq!(Some(Ok(b's')), encoded.next());
/// assert_eq!(Some(Ok(b't')), encoded.next());
/// assert_eq!(Some(Ok(b'r')), encoded.next());
/// assert_eq!(Some(Ok(b'a')), encoded.next());
/// assert_eq!(Some(Err(ASCIIEncodingError)), encoded.next());
/// assert_eq!(Some(Ok(b'e')), encoded.next());
/// assert_eq!(None, encoded.next());
/// ```
#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
pub struct ASCIIEncoder;

impl ASCIIEncoder {
    /// Create a new instance.
    #[inline]
    pub fn new() -> Self {
        Self::default()
    }
}

impl Converter for ASCIIEncoder {
    type Item = char;
    type Output = u8;
    type Error = ASCIIEncodingError;

    fn convert<E>(&mut self, item: Self::Item, buf: &mut E) -> Result<usize, Self::Error>
    where
        E: Extend<Self::Output>,
    {
        if (item as u32) <= 0x7f {
            buf.extend([item as u8]);
            Ok(1)
        } else {
            Err(ASCIIEncodingError)
        }
    }

    #[inline]
    fn size_hint(&self) -> (usize, Option<usize>) {
        (1, Some(1))
    }
}