Enum serde_test::Token [−][src]
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
A serialized bool
.
assert_tokens(&true, &[Token::Bool(true)]);
Tuple Fields of Bool
0: bool
A serialized i8
.
assert_tokens(&0i8, &[Token::I8(0)]);
Tuple Fields of I8
0: i8
A serialized i16
.
assert_tokens(&0i16, &[Token::I16(0)]);
Tuple Fields of I16
0: i16
A serialized i32
.
assert_tokens(&0i32, &[Token::I32(0)]);
Tuple Fields of I32
0: i32
A serialized i64
.
assert_tokens(&0i64, &[Token::I64(0)]);
Tuple Fields of I64
0: i64
A serialized u8
.
assert_tokens(&0u8, &[Token::U8(0)]);
Tuple Fields of U8
0: u8
A serialized u16
.
assert_tokens(&0u16, &[Token::U16(0)]);
Tuple Fields of U16
0: u16
A serialized u32
.
assert_tokens(&0u32, &[Token::U32(0)]);
Tuple Fields of U32
0: u32
A serialized u64
.
assert_tokens(&0u64, &[Token::U64(0)]);
Tuple Fields of U64
0: u64
A serialized f32
.
assert_tokens(&0f32, &[Token::F32(0.0)]);
Tuple Fields of F32
0: f32
A serialized f64
.
assert_tokens(&0f64, &[Token::F64(0.0)]);
Tuple Fields of F64
0: f64
A serialized char
.
assert_tokens(&'\n', &[Token::Char('\n')]);
Tuple Fields of Char
0: char
A serialized str
.
let s = String::from("transient");
assert_tokens(&s, &[Token::Str("transient")]);
Tuple Fields of Str
0: &'static str
A borrowed str
.
let s: &str = "borrowed";
assert_tokens(&s, &[Token::BorrowedStr("borrowed")]);
Tuple Fields of BorrowedStr
0: &'static str
A serialized String
.
let s = String::from("owned");
assert_tokens(&s, &[Token::String("owned")]);
Tuple Fields of String
0: &'static str
A serialized [u8]
Tuple Fields of Bytes
A borrowed [u8]
.
Tuple Fields of BorrowedBytes
A serialized ByteBuf
Tuple Fields of ByteBuf
A serialized Option<T>
containing none.
let opt = None::<char>;
assert_tokens(&opt, &[Token::None]);
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'),
]);
A serialized ()
.
assert_tokens(&(), &[Token::Unit]);
A serialized unit struct of the given name.
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct X;
assert_tokens(&X, &[Token::UnitStruct { name: "X" }]);
Fields of UnitStruct
name: &'static str
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" }]);
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"),
]);
Fields of NewtypeStruct
name: &'static str
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),
]);
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,
]);
An indicator of the end of a sequence.
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,
]);
Fields of Tuple
len: usize
An indicator of the end of a tuple.
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,
]);
An indicator of the end of a tuple struct.
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,
]);
An indicator of the end of a tuple variant.
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,
]);
An indicator of the end of a map.
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,
]);
An indicator of the end of a struct.
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,
]);
An indicator of the end of a struct variant.
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,
]);
Fields of Enum
name: &'static str
Trait Implementations
Auto Trait Implementations
impl RefUnwindSafe for Token
impl UnwindSafe for Token
Blanket Implementations
Mutably borrows from an owned value. Read more