Enum serde_test::Token
source · [−]pub enum Token {
Show 40 variants
Bool(bool),
I8(i8),
I16(i16),
I32(i32),
I64(i64),
U8(u8),
U16(u16),
U32(u32),
U64(u64),
F32(f32),
F64(f64),
Char(char),
Str(&'static str),
BorrowedStr(&'static str),
String(&'static str),
Bytes(&'static [u8]),
BorrowedBytes(&'static [u8]),
ByteBuf(&'static [u8]),
None,
Some,
Unit,
UnitStruct {
name: &'static str,
},
UnitVariant {
name: &'static str,
variant: &'static str,
},
NewtypeStruct {
name: &'static str,
},
NewtypeVariant {
name: &'static str,
variant: &'static str,
},
Seq {
len: Option<usize>,
},
SeqEnd,
Tuple {
len: usize,
},
TupleEnd,
TupleStruct {
name: &'static str,
len: usize,
},
TupleStructEnd,
TupleVariant {
name: &'static str,
variant: &'static str,
len: usize,
},
TupleVariantEnd,
Map {
len: Option<usize>,
},
MapEnd,
Struct {
name: &'static str,
len: usize,
},
StructEnd,
StructVariant {
name: &'static str,
variant: &'static str,
len: usize,
},
StructVariantEnd,
Enum {
name: &'static str,
},
}
Variants
Bool(bool)
A serialized bool
.
assert_tokens(&true, &[Token::Bool(true)]);
I8(i8)
A serialized i8
.
assert_tokens(&0i8, &[Token::I8(0)]);
I16(i16)
A serialized i16
.
assert_tokens(&0i16, &[Token::I16(0)]);
I32(i32)
A serialized i32
.
assert_tokens(&0i32, &[Token::I32(0)]);
I64(i64)
A serialized i64
.
assert_tokens(&0i64, &[Token::I64(0)]);
U8(u8)
A serialized u8
.
assert_tokens(&0u8, &[Token::U8(0)]);
U16(u16)
A serialized u16
.
assert_tokens(&0u16, &[Token::U16(0)]);
U32(u32)
A serialized u32
.
assert_tokens(&0u32, &[Token::U32(0)]);
U64(u64)
A serialized u64
.
assert_tokens(&0u64, &[Token::U64(0)]);
F32(f32)
A serialized f32
.
assert_tokens(&0f32, &[Token::F32(0.0)]);
F64(f64)
A serialized f64
.
assert_tokens(&0f64, &[Token::F64(0.0)]);
Char(char)
A serialized char
.
assert_tokens(&'\n', &[Token::Char('\n')]);
Str(&'static str)
A serialized str
.
let s = String::from("transient");
assert_tokens(&s, &[Token::Str("transient")]);
BorrowedStr(&'static str)
A borrowed str
.
let s: &str = "borrowed";
assert_tokens(&s, &[Token::BorrowedStr("borrowed")]);
String(&'static str)
A serialized String
.
let s = String::from("owned");
assert_tokens(&s, &[Token::String("owned")]);
Bytes(&'static [u8])
A serialized [u8]
BorrowedBytes(&'static [u8])
A borrowed [u8]
.
ByteBuf(&'static [u8])
A serialized ByteBuf
None
A serialized Option<T>
containing none.
let opt = None::<char>;
assert_tokens(&opt, &[Token::None]);
Some
The header to a serialized Option<T>
containing some value.
The tokens of the value follow after this header.
let opt = Some('c');
assert_tokens(&opt, &[
Token::Some,
Token::Char('c'),
]);
Unit
A serialized ()
.
assert_tokens(&(), &[Token::Unit]);
UnitStruct
Fields
name: &'static str
A serialized unit struct of the given name.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct X;
assert_tokens(&X, &[Token::UnitStruct { name: "X" }]);
UnitVariant
A unit variant of an enum.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
A,
}
let a = E::A;
assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]);
NewtypeStruct
Fields
name: &'static str
The header to a serialized newtype struct of the given name.
After this header is the value contained in the newtype struct.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct N(String);
let n = N("newtype".to_owned());
assert_tokens(&n, &[
Token::NewtypeStruct { name: "N" },
Token::String("newtype"),
]);
NewtypeVariant
The header to a newtype variant of an enum.
After this header is the value contained in the newtype variant.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
B(u8),
}
let b = E::B(0);
assert_tokens(&b, &[
Token::NewtypeVariant { name: "E", variant: "B" },
Token::U8(0),
]);
Seq
The header to a sequence.
After this header are the elements of the sequence, followed by
SeqEnd
.
let vec = vec!['a', 'b', 'c'];
assert_tokens(&vec, &[
Token::Seq { len: Some(3) },
Token::Char('a'),
Token::Char('b'),
Token::Char('c'),
Token::SeqEnd,
]);
SeqEnd
An indicator of the end of a sequence.
Tuple
Fields
len: usize
The header to a tuple.
After this header are the elements of the tuple, followed by TupleEnd
.
let tuple = ('a', 100);
assert_tokens(&tuple, &[
Token::Tuple { len: 2 },
Token::Char('a'),
Token::I32(100),
Token::TupleEnd,
]);
TupleEnd
An indicator of the end of a tuple.
TupleStruct
The header to a tuple struct.
After this header are the fields of the tuple struct, followed by
TupleStructEnd
.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct T(u8, u8);
let t = T(0, 0);
assert_tokens(&t, &[
Token::TupleStruct { name: "T", len: 2 },
Token::U8(0),
Token::U8(0),
Token::TupleStructEnd,
]);
TupleStructEnd
An indicator of the end of a tuple struct.
TupleVariant
The header to a tuple variant of an enum.
After this header are the fields of the tuple variant, followed by
TupleVariantEnd
.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
C(u8, u8),
}
let c = E::C(0, 0);
assert_tokens(&c, &[
Token::TupleVariant { name: "E", variant: "C", len: 2 },
Token::U8(0),
Token::U8(0),
Token::TupleVariantEnd,
]);
TupleVariantEnd
An indicator of the end of a tuple variant.
Map
The header to a map.
After this header are the entries of the map, followed by MapEnd
.
use std::collections::BTreeMap;
let mut map = BTreeMap::new();
map.insert('A', 65);
map.insert('Z', 90);
assert_tokens(&map, &[
Token::Map { len: Some(2) },
Token::Char('A'),
Token::I32(65),
Token::Char('Z'),
Token::I32(90),
Token::MapEnd,
]);
MapEnd
An indicator of the end of a map.
Struct
The header of a struct.
After this header are the fields of the struct, followed by StructEnd
.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct S {
a: u8,
b: u8,
}
let s = S { a: 0, b: 0 };
assert_tokens(&s, &[
Token::Struct { name: "S", len: 2 },
Token::Str("a"),
Token::U8(0),
Token::Str("b"),
Token::U8(0),
Token::StructEnd,
]);
StructEnd
An indicator of the end of a struct.
StructVariant
The header of a struct variant of an enum.
After this header are the fields of the struct variant, followed by
StructVariantEnd
.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
D { d: u8 },
}
let d = E::D { d: 0 };
assert_tokens(&d, &[
Token::StructVariant { name: "E", variant: "D", len: 1 },
Token::Str("d"),
Token::U8(0),
Token::StructVariantEnd,
]);
StructVariantEnd
An indicator of the end of a struct variant.
Enum
Fields
name: &'static str
The header to an enum of the given name.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
A,
B(u8),
C(u8, u8),
D { d: u8 },
}
let a = E::A;
assert_tokens(&a, &[
Token::Enum { name: "E" },
Token::Str("A"),
Token::Unit,
]);
let b = E::B(0);
assert_tokens(&b, &[
Token::Enum { name: "E" },
Token::Str("B"),
Token::U8(0),
]);
let c = E::C(0, 0);
assert_tokens(&c, &[
Token::Enum { name: "E" },
Token::Str("C"),
Token::Seq { len: Some(2) },
Token::U8(0),
Token::U8(0),
Token::SeqEnd,
]);
let d = E::D { d: 0 };
assert_tokens(&d, &[
Token::Enum { name: "E" },
Token::Str("D"),
Token::Map { len: Some(1) },
Token::Str("d"),
Token::U8(0),
Token::MapEnd,
]);
Trait Implementations
impl Copy for Token
impl StructuralPartialEq for Token
Auto Trait Implementations
impl RefUnwindSafe for Token
impl Send for Token
impl Sync for Token
impl Unpin for Token
impl UnwindSafe for Token
Blanket Implementations
sourceimpl<T> BorrowMut<T> for T where
T: ?Sized,
impl<T> BorrowMut<T> for T where
T: ?Sized,
const: unstable · sourcefn borrow_mut(&mut self) -> &mut T
fn borrow_mut(&mut self) -> &mut T
Mutably borrows from an owned value. Read more