seabored 0.0.3

Implementation of the CBOR data format. Implements RFC8949 with the preferred-plus recommendations
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

mod float;
mod integer;
mod seq;

use std::borrow::Cow;

pub use float::CborFloat;
pub use integer::CborInteger;
pub(crate) use integer::{CborIntegerValue, IB_LIMIT};
pub use seq::CborSequence;

use crate::{de::CborDeserialize, ib::InitialByte, ser::CborSerialize};

impl CborSerialize for bool {
    #[inline(always)]
    fn cbor_serialize_to<W: crate::io::Write>(
        &self,
        buf: &mut W,
    ) -> Result<usize, crate::error::SeaboredSerError> {
        buf.write(&[crate::ib::consts::IB_FALSE | *self as u8])
    }
}

impl<'de> CborDeserialize<'de> for bool {
    #[cfg_attr(feature = "inline-nontrivial", inline)]
    fn cbor_deserialize_from<R: crate::io::Read<'de>>(
        reader: &mut R,
    ) -> Result<Self, crate::error::SeaboredDeError<'de>>
    where
        Self: Sized + 'de,
    {
        let ib = InitialByte::cbor_deserialize_from(reader)?;
        Ok(match ib.0 {
            crate::ib::consts::IB_TRUE => true,
            crate::ib::consts::IB_FALSE => false,
            _ => {
                return Err(crate::error::SeaboredDeError::IncorrectMajorType {
                    actual: ib.mt(),
                    expected: &[crate::mt::MajorType::SimpleValueOrFloat],
                });
            }
        })
    }
}

impl CborSerialize for &str {
    #[inline(always)]
    fn cbor_serialize_to<W: crate::io::Write>(
        &self,
        writer: &mut W,
    ) -> Result<usize, crate::error::SeaboredSerError> {
        CborIntegerValue::serialize_inline_bytes(
            self.as_bytes(),
            crate::mt::MajorType::String,
            writer,
        )
    }
}

impl<'de> CborDeserialize<'de> for Cow<'de, str> {
    #[cfg_attr(feature = "inline-nontrivial", inline)]
    fn cbor_deserialize_from<R: crate::io::Read<'de>>(
        reader: &mut R,
    ) -> Result<Self, crate::error::SeaboredDeError<'de>> {
        let ib = InitialByte::cbor_deserialize_from(reader)?;
        let (mt, ai) = ib.mt_ai();
        if mt != crate::mt::MajorType::String {
            return Err(crate::error::SeaboredDeError::IncorrectMajorType {
                actual: mt,
                expected: &[crate::mt::MajorType::String],
            });
        }

        let len = ai.find_subsequent_len(reader)?;
        Ok(match reader.read_slice(len.try_into()?)? {
            Cow::Borrowed(s) => Cow::Borrowed(simdutf8::basic::from_utf8(s)?),
            Cow::Owned(s) => Cow::Owned({
                let _ = simdutf8::basic::from_utf8(&s)?;
                // SAFETY: Checked right above
                unsafe { String::from_utf8_unchecked(s) }
            }),
        })
    }
}

impl CborSerialize for &[u8] {
    #[inline(always)]
    fn cbor_serialize_to<W: crate::io::Write>(
        &self,
        writer: &mut W,
    ) -> Result<usize, crate::error::SeaboredSerError> {
        CborIntegerValue::serialize_inline_bytes(self, crate::mt::MajorType::Bytes, writer)
    }
}

impl<'de> CborDeserialize<'de> for Cow<'de, [u8]> {
    #[cfg_attr(feature = "inline-nontrivial", inline)]
    fn cbor_deserialize_from<R: crate::io::Read<'de>>(
        reader: &mut R,
    ) -> Result<Self, crate::error::SeaboredDeError<'de>> {
        let ib = InitialByte::cbor_deserialize_from(reader)?;
        let (mt, ai) = ib.mt_ai();
        if mt != crate::mt::MajorType::Bytes {
            return Err(crate::error::SeaboredDeError::IncorrectMajorType {
                actual: mt,
                expected: &[crate::mt::MajorType::Bytes],
            });
        }

        let len = ai.find_subsequent_len(reader)?;
        reader.read_slice(len.try_into()?)
    }
}