musli 0.1.1

Müsli is a flexible and efficient serialization framework.
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
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155

use core::fmt;

use crate::de::SizeHint;

/// A type hint.
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub(crate) enum TypeHint {
    /// A unit type or an empty value.
    Empty,
    /// A boolean type.
    Bool,
    /// A character type.
    Char,
    /// The type as a number.
    Number(NumberHint),
    /// A byte array.
    Bytes(SizeHint),
    /// A string with the given length.
    String(SizeHint),
    /// A sequence with a length hint.
    Sequence(SizeHint),
    /// A map with a length hint.
    Map(SizeHint),
    /// A variant.
    Variant,
    /// An optional value.
    Option,
}

impl fmt::Display for TypeHint {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            TypeHint::Empty => write!(f, "empty"),
            TypeHint::Bool => write!(f, "bool"),
            TypeHint::Char => write!(f, "char"),
            TypeHint::Number(number) => number.fmt(f),
            TypeHint::Bytes(size) => write!(f, "bytes with length {size}"),
            TypeHint::String(size) => write!(f, "string with length {size}"),
            TypeHint::Sequence(size) => write!(f, "sequence with length {size}"),
            TypeHint::Map(size) => write!(f, "map with length {size}"),
            TypeHint::Variant => write!(f, "variant"),
            TypeHint::Option => write!(f, "option"),
        }
    }
}

/// A number hint.
#[derive(Debug, Clone, Copy)]
#[non_exhaustive]
pub(crate) enum NumberHint {
    /// An integer of the given kind.
    Integer(IntegerKind),
    /// A float of the given kind.
    Float(FloatKind),
}

impl fmt::Display for NumberHint {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            NumberHint::Integer(kind) => kind.fmt(f),
            NumberHint::Float(kind) => kind.fmt(f),
        }
    }
}

/// The kind of an integer, which identifies its exact representation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
#[non_exhaustive]
pub(crate) enum IntegerKind {
    /// An unsigned 8-bit integer.
    U8,
    /// An unsigned 16-bit integer.
    U16,
    /// An unsigned 32-bit integer.
    U32,
    /// An unsigned 64-bit integer.
    U64,
    /// An unsigned 128-bit integer.
    U128,
    /// A signed 8-bit integer.
    I8,
    /// A signed 16-bit integer.
    I16,
    /// A signed 32-bit integer.
    I32,
    /// A signed 64-bit integer.
    I64,
    /// A signed 128-bit integer.
    I128,
}

impl IntegerKind {
    /// The kind a [usize] is represented as.
    #[cfg(target_pointer_width = "32")]
    pub(crate) const USIZE: Self = IntegerKind::U32;
    /// The kind a [usize] is represented as.
    #[cfg(target_pointer_width = "64")]
    pub(crate) const USIZE: Self = IntegerKind::U64;
    /// The kind an [isize] is represented as.
    #[cfg(target_pointer_width = "32")]
    pub(crate) const ISIZE: Self = IntegerKind::I32;
    /// The kind an [isize] is represented as.
    #[cfg(target_pointer_width = "64")]
    pub(crate) const ISIZE: Self = IntegerKind::I64;

    /// Test if the integer kind is signed.
    #[inline]
    pub(crate) const fn is_signed(self) -> bool {
        matches!(
            self,
            IntegerKind::I8
                | IntegerKind::I16
                | IntegerKind::I32
                | IntegerKind::I64
                | IntegerKind::I128
        )
    }
}

impl fmt::Display for IntegerKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            IntegerKind::U8 => write!(f, "u8"),
            IntegerKind::U16 => write!(f, "u16"),
            IntegerKind::U32 => write!(f, "u32"),
            IntegerKind::U64 => write!(f, "u64"),
            IntegerKind::U128 => write!(f, "u128"),
            IntegerKind::I8 => write!(f, "i8"),
            IntegerKind::I16 => write!(f, "i16"),
            IntegerKind::I32 => write!(f, "i32"),
            IntegerKind::I64 => write!(f, "i64"),
            IntegerKind::I128 => write!(f, "i128"),
        }
    }
}

/// The kind of a float, which identifies its exact representation.
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
#[non_exhaustive]
pub(crate) enum FloatKind {
    /// A 32-bit float.
    F32,
    /// A 64-bit float.
    F64,
}

impl fmt::Display for FloatKind {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        match self {
            FloatKind::F32 => write!(f, "f32"),
            FloatKind::F64 => write!(f, "f64"),
        }
    }
}