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
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170

#[derive(Clone, PartialEq, Debug)]
pub enum Token<'a> {
    /// A serialized `bool`.
    Bool(bool),

    /// A serialized `i8`.
    I8(i8),

    /// A serialized `i16`.
    I16(i16),

    /// A serialized `i32`.
    I32(i32),

    /// A serialized `i64`.
    I64(i64),

    /// A serialized `u8`.
    U8(u8),

    /// A serialized `u16`.
    U16(u16),

    /// A serialized `u32`.
    U32(u32),

    /// A serialized `u64`.
    U64(u64),

    /// A serialized `f32`.
    F32(f32),

    /// A serialized `f64`.
    F64(f64),

    /// A serialized `char`.
    Char(char),

    /// A serialized `str`.
    Str(&'a str),

    /// A serialized `String`.
    String(String),

    /// A serialized `[u8]`
    Bytes(&'a [u8]),

    /// A serialized `ByteBuf`
    ByteBuf(Vec<u8>),

    /// The header to a serialized `Option<T>`.
    ///
    /// `None` is serialized as `Option(false)`, while `Some` is serialized as `Option(true)`, then
    /// the value contained in the option.
    Option(bool),

    /// A serialized `()`.
    Unit,

    /// A serialized unit struct of the given name.
    UnitStruct(&'a str),

    /// The header to a serialized newtype struct of the given name.
    ///
    /// Newtype structs are serialized with this header, followed by the value contained in the
    /// newtype struct.
    StructNewType(&'a str),

    /// The header to an enum of the given name.
    ///
    /// This token is only used for deserializers, and ensures that the following tokens are read as
    /// an enum. Because this is never emitted by serializers, calling `assert_ser_tokens` or
    /// `assert_tokens` will fail if this token is used.
    ///
    /// TODO: Trash this.
    EnumStart(&'a str),

    /// A unit variant of an enum of the given name, of the given name.
    ///
    /// The first string represents the name of the enum, and the second represents the name of the
    /// variant.
    EnumUnit(&'a str, &'a str),

    /// The header to a newtype variant of an enum of the given name, of the given name.
    ///
    /// The first string represents the name of the enum, and the second represents the name of the
    /// variant. The value contained within this enum works the same as `StructNewType`.
    EnumNewType(&'a str, &'a str),

    /// The header to a sequence of the given length.
    ///
    /// These are serialized via `serialize_seq`, which takes an optional length. After this
    /// header is a list of elements, followed by `SeqEnd`.
    SeqStart(Option<usize>),

    /// The header to an array of the given length.
    ///
    /// These are serialized via `serialize_seq_fized_size`, which requires a length. After this
    /// header is a list of elements, followed by `SeqEnd`.
    SeqArrayStart(usize),

    /// A separator, which occurs *before* every element in a sequence.
    ///
    /// Elements in sequences are represented by a `SeqSep`, followed by the value of the element.
    SeqSep,

    /// An indicator of the end of a sequence.
    SeqEnd,

    /// The header to a tuple of the given length, similar to `SeqArrayStart`.
    TupleStart(usize),

    /// A separator, similar to `SeqSep`.
    TupleSep,

    /// An indicator of the end of a tuple, similar to `SeqEnd`.
    TupleEnd,

    /// The header to a tuple struct of the given name and length.
    TupleStructStart(&'a str, usize),

    /// A separator, similar to `TupleSep`.
    TupleStructSep,

    /// An indicator of the end of a tuple struct, similar to `TupleEnd`.
    TupleStructEnd,

    /// The header to a map of the given length.
    ///
    /// These are serialized via `serialize_map`, which takes an optional length. After this header
    /// is a list of key-value pairs, followed by `MapEnd`.
    MapStart(Option<usize>),

    /// A separator, which occurs *before* every key-value pair in a map.
    ///
    /// Elements in maps are represented by a `MapSep`, followed by a serialized key, followed
    /// by a serialized value.
    MapSep,

    /// An indicator of the end of a map.
    MapEnd,

    /// The header of a struct of the given name and length, similar to `MapStart`.
    StructStart(&'a str, usize),

    /// A separator, similar to `MapSep`.
    StructSep,

    /// An indicator of the end of a struct, similar to `MapEnd`.
    StructEnd,

    /// The header to a tuple variant of an enum of the given name, of the given name and length.
    EnumSeqStart(&'a str, &'a str, usize),

    /// A separator, similar to `TupleSep`.
    EnumSeqSep,

    /// An indicator of the end of a tuple variant, similar to `TupleEnd`.
    EnumSeqEnd,

    /// The header of a struct variant of an enum of the given name, of the given name and length,
    /// similar to `StructStart`.
    EnumMapStart(&'a str, &'a str, usize),

    /// A separator, similar to `StructSep`.
    EnumMapSep,

    /// An indicator of the end of a struct, similar to `StructEnd`.
    EnumMapEnd,
}