recode 0.4.1

Reusable encoding/decoding constructs for Rust
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

use super::Buffer;
use crate::util::EncoderExt;
use crate::{Decoder, Encoder, Error};

macro_rules! define_encoding {
    ($name:ident; doc: $d:literal; validate: |$i:ident| $v:stmt) => {
        #[derive(Debug, Clone, Default)]
        #[doc = $d]
        pub struct $name<L = crate::util::Remaining>(Buffer<L>);

        impl<B, L> Decoder<B> for $name<L>
        where
            Buffer<L>: Decoder<B>,
            Error: From<<Buffer<L> as Decoder<B>>::Error>,
        {
            type Error = Error;

            fn decode(buf: &mut B) -> Result<Self, Self::Error> {
                let $i = Buffer::<L>::decode(buf)?;

                $v

                Ok(Self($i))
            }
        }

        impl<B, L> Encoder<B> for $name<L>
        where
            Buffer<L>: Encoder<B>,
            Error: From<<Buffer<L> as Encoder<B>>::Error>,
        {
            type Error = Error;

            #[inline(always)]
            fn encode(item: &Self, buf: &mut B) -> Result<(), Self::Error> {
                Ok(item.0.encode_to(buf)?)
            }

            #[inline]
            fn size_of(item: &Self, buf: &B) -> usize {
                item.0.size(buf)
            }
        }

        impl<L> std::ops::Deref for $name<L> {
            type Target = str;

            #[inline(always)]
            fn deref(&self) -> &Self::Target {
                unsafe { std::str::from_utf8_unchecked(self.0.as_ref()) }
            }
        }

        impl<L> From<&'static str> for $name<L> {
            #[inline(always)]
            fn from(value: &'static str) -> Self {
                Self(Buffer::from_static(value.as_bytes()))
            }
        }
    };
}

define_encoding! {
    Ascii;
    doc: "A type that represents a text encoded as ASCII";
    validate: |inner| {
        if !inner.as_ref().is_ascii() {
            return Err(TextError::Ascii("invalid ascii data"))?;
        }
    }
}

define_encoding! {
    Utf8;
    doc: "A type that represents a text encoded as UTF-8";
    validate: |inner| {
        _ = std::str::from_utf8(inner.as_ref()).map_err(TextError::Utf8)?;
    }
}

#[derive(Debug, thiserror::Error)]
pub enum TextError {
    #[error("utf8 error: {0}")]
    Utf8(#[from] std::str::Utf8Error),

    #[error("ascii error: {0}")]
    Ascii(&'static str),
}