[][src]Enum serde_test::Token

pub enum Token {
    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.

This code runs with edition 2018
assert_tokens(&true, &[Token::Bool(true)]);
I8(i8)

A serialized i8.

This code runs with edition 2018
assert_tokens(&0i8, &[Token::I8(0)]);
I16(i16)

A serialized i16.

This code runs with edition 2018
assert_tokens(&0i16, &[Token::I16(0)]);
I32(i32)

A serialized i32.

This code runs with edition 2018
assert_tokens(&0i32, &[Token::I32(0)]);
I64(i64)

A serialized i64.

This code runs with edition 2018
assert_tokens(&0i64, &[Token::I64(0)]);
U8(u8)

A serialized u8.

This code runs with edition 2018
assert_tokens(&0u8, &[Token::U8(0)]);
U16(u16)

A serialized u16.

This code runs with edition 2018
assert_tokens(&0u16, &[Token::U16(0)]);
U32(u32)

A serialized u32.

This code runs with edition 2018
assert_tokens(&0u32, &[Token::U32(0)]);
U64(u64)

A serialized u64.

This code runs with edition 2018
assert_tokens(&0u64, &[Token::U64(0)]);
F32(f32)

A serialized f32.

This code runs with edition 2018
assert_tokens(&0f32, &[Token::F32(0.0)]);
F64(f64)

A serialized f64.

This code runs with edition 2018
assert_tokens(&0f64, &[Token::F64(0.0)]);
Char(char)

A serialized char.

This code runs with edition 2018
assert_tokens(&'\n', &[Token::Char('\n')]);
Str(&'static str)

A serialized str.

This code runs with edition 2018
let s = String::from("transient");
assert_tokens(&s, &[Token::Str("transient")]);
BorrowedStr(&'static str)

A borrowed str.

This code runs with edition 2018
let s: &str = "borrowed";
assert_tokens(&s, &[Token::BorrowedStr("borrowed")]);
String(&'static str)

A serialized String.

This code runs with edition 2018
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.

This code runs with edition 2018
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.

This code runs with edition 2018
let opt = Some('c');
assert_tokens(&opt, &[
    Token::Some,
    Token::Char('c'),
]);
Unit

A serialized ().

This code runs with edition 2018
assert_tokens(&(), &[Token::Unit]);
UnitStruct

A serialized unit struct of the given name.

This code runs with edition 2018
#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct X;

assert_tokens(&X, &[Token::UnitStruct { name: "X" }]);

Fields of UnitStruct

name: &'static str
UnitVariant

A unit variant of an enum.

This code runs with edition 2018
#[derive(Serialize, Deserialize, PartialEq, Debug)]
enum E {
    A,
}

let a = E::A;
assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]);

Fields of UnitVariant

name: &'static strvariant: &'static str
NewtypeStruct

The header to a serialized newtype struct of the given name.

After this header is the value contained in the newtype struct.

This code runs with edition 2018
#[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
NewtypeVariant

The header to a newtype variant of an enum.

After this header is the value contained in the newtype variant.

This code runs with edition 2018
#[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),
]);

Fields of NewtypeVariant

name: &'static strvariant: &'static str
Seq

The header to a sequence.

After this header are the elements of the sequence, followed by SeqEnd.

This code runs with edition 2018
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,
]);

Fields of Seq

len: Option<usize>
SeqEnd

An indicator of the end of a sequence.

Tuple

The header to a tuple.

After this header are the elements of the tuple, followed by TupleEnd.

This code runs with edition 2018
let tuple = ('a', 100);
assert_tokens(&tuple, &[
    Token::Tuple { len: 2 },
    Token::Char('a'),
    Token::I32(100),
    Token::TupleEnd,
]);

Fields of Tuple

len: usize
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.

This code runs with edition 2018
#[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,
]);

Fields of TupleStruct

name: &'static strlen: usize
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.

This code runs with edition 2018
#[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,
]);

Fields of TupleVariant

name: &'static strvariant: &'static strlen: usize
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.

This code runs with edition 2018
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,
]);

Fields of Map

len: Option<usize>
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.

This code runs with edition 2018
#[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,
]);

Fields of Struct

name: &'static strlen: usize
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.

This code runs with edition 2018
#[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,
]);

Fields of StructVariant

name: &'static strvariant: &'static strlen: usize
StructVariantEnd

An indicator of the end of a struct variant.

Enum

The header to an enum of the given name.

This code runs with edition 2018
#[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

impl Clone for Token[src]

impl Copy for Token[src]

impl PartialEq<Token> for Token[src]

impl Display for Token[src]

impl Debug for Token[src]

impl StructuralPartialEq for Token[src]

Auto Trait Implementations

impl Send for Token

impl Sync for Token

impl Unpin for Token

impl UnwindSafe for Token

impl RefUnwindSafe for Token

Blanket Implementations

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T> From<T> for T[src]

impl<T> ToOwned for T where
    T: Clone
[src]

type Owned = T

The resulting type after obtaining ownership.

impl<T> ToString for T where
    T: Display + ?Sized
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> Any for T where
    T: 'static + ?Sized
[src]