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

Fields

§name: &'static str
§variant: &'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",
    }],
);
§

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

Fields

§name: &'static str
§variant: &'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),
    ],
);
§

Seq

Fields

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

Fields

§name: &'static str
§len: usize

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

Fields

§name: &'static str
§variant: &'static str
§len: usize

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

Fields

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

Fields

§name: &'static str
§len: usize

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

Fields

§name: &'static str
§variant: &'static str
§len: usize

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§

source§

impl Clone for Token

source§

fn clone(&self) -> Token

Returns a copy of the value. Read more
1.0.0 · source§

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

Performs copy-assignment from source. Read more
source§

impl Debug for Token

source§

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

Formats the value using the given formatter. Read more
source§

impl Display for Token

source§

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

Formats the value using the given formatter. Read more
source§

impl PartialEq<Token> for Token

source§

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

This method tests for self and other values to be equal, and is used by ==.
1.0.0 · source§

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl Copy for Token

source§

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§

source§

impl<T> Any for Twhere T: 'static + ?Sized,

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

impl<T> Borrow<T> for Twhere T: ?Sized,

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

impl<T> BorrowMut<T> for Twhere T: ?Sized,

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> Configure for Twhere T: ?Sized,

source§

fn readable(self) -> Readable<Self>where Self: Sized,

Marks self as using is_human_readable == true
source§

fn compact(self) -> Compact<Self>where Self: Sized,

Marks self as using is_human_readable == false
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

impl<T, U> Into<U> for Twhere U: From<T>,

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

impl<T> ToOwned for Twhere T: Clone,

§

type Owned = T

The resulting type after obtaining ownership.
source§

fn to_owned(&self) -> T

Creates owned data from borrowed data, usually by cloning. Read more
source§

fn clone_into(&self, target: &mut T)

Uses borrowed data to replace owned data, usually by cloning. Read more
source§

impl<T> ToString for Twhere T: Display + ?Sized,

source§

default fn to_string(&self) -> String

Converts the given value to a String. Read more
source§

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.
source§

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

§

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

The type returned in the event of a conversion error.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.