Enum 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.

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

A serialized unit struct of the given name.

#[derive(Serialize, Deserialize, PartialEq, Debug)]
struct X;

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

Fields

name: &'static str

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",
    }],
);

Fields

name: &'static str

variant: &'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.

#[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

name: &'static str

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),
    ],
);

Fields

name: &'static str

variant: &'static str

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,
    ],
);

Fields

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.

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

Fields

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.

#[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

name: &'static str

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

#[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

name: &'static str

variant: &'static str

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

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

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.

#[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

name: &'static str

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

#[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

name: &'static str

variant: &'static str

len: usize

StructVariantEnd

An indicator of the end of a struct variant.

Enum

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

name: &'static str

Trait Implementations

impl Clone for Token

fn clone(&self) -> Token

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Token

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Display for Token

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for Token

fn eq(&self, other: &Token) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Token

impl StructuralPartialEq for Token