enrede 0.2.0

An easy-to-use string encoding library, providing an interface similar to str/String.
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

use crate::encoding::Encoding;
use crate::str::Str;
use core::marker::PhantomData;

pub(super) struct EncodedChunks<'a, E> {
    src: &'a [u8],
    _phantom: PhantomData<E>,
}

impl<'a, E: Encoding> EncodedChunks<'a, E> {
    pub(super) fn new(src: &'a [u8]) -> Self {
        EncodedChunks {
            src,
            _phantom: PhantomData,
        }
    }
}

pub(crate) struct EncodedChunk<'a, E> {
    valid: &'a Str<E>,
    invalid: &'a [u8],
    _phantom: PhantomData<E>,
}

impl<'a, E: Encoding> EncodedChunk<'a, E> {
    pub(super) fn valid(&self) -> &'a Str<E> {
        self.valid
    }

    pub(super) fn invalid(&self) -> &'a [u8] {
        self.invalid
    }
}

impl<'a, E: Encoding + 'a> Iterator for EncodedChunks<'a, E> {
    type Item = EncodedChunk<'a, E>;

    fn next(&mut self) -> Option<Self::Item> {
        if self.src.is_empty() {
            return None;
        }

        Some(match Str::<E>::from_bytes(self.src) {
            Ok(valid) => {
                let out = EncodedChunk {
                    valid,
                    invalid: &[],
                    _phantom: PhantomData,
                };
                self.src = &[];
                out
            }
            Err(err) => {
                let valid_to = err.valid_up_to();
                // SAFETY: Data up to `valid_to` is guaranteed valid for the provided encoding
                let valid = unsafe { Str::from_bytes_unchecked(&self.src[..valid_to]) };
                let invalid = match err.error_len() {
                    Some(len) => {
                        let i = &self.src[valid_to..valid_to + len];
                        self.src = &self.src[valid_to + len..];
                        i
                    }
                    None => {
                        let i = &self.src[valid_to..];
                        self.src = &[];
                        i
                    }
                };

                EncodedChunk {
                    valid,
                    invalid,
                    _phantom: PhantomData,
                }
            }
        })
    }
}