Token

serde_assert::token

Enum Token 

Source 
pub enum Token {

Show 40 variants    Bool(bool),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    I128(i128),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    U128(u128),
    F32(f32),
    F64(f64),
    Char(char),
    Str(String),
    Bytes(Vec<u8>),
    None,
    Some,
    Unit,
    UnitStruct {
        name: &'static str,
    },
    UnitVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    },
    NewtypeStruct {
        name: &'static str,
    },
    NewtypeVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
    },
    Seq {
        len: Option<usize>,
    },
    SeqEnd,
    Tuple {
        len: usize,
    },
    TupleEnd,
    TupleStruct {
        name: &'static str,
        len: usize,
    },
    TupleStructEnd,
    TupleVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    },
    TupleVariantEnd,
    Map {
        len: Option<usize>,
    },
    MapEnd,
    Field(&'static str),
    SkippedField(&'static str),
    Struct {
        name: &'static str,
        len: usize,
    },
    StructEnd,
    StructVariant {
        name: &'static str,
        variant_index: u32,
        variant: &'static str,
        len: usize,
    },
    StructVariantEnd,
    Unordered(&'static [&'static [Token]]),

}
Expand description

A single serialized value.

A Token is a single serialization output produced by the Serializer. The one exception to this is the Unordered variant, which contains multiple sets of tokens that can be in any order. This is never produced by the Serializer, and is for use when comparing equality of sequences of Tokens.

Normally, a sequence of Tokens are used to either compare against the output of a Serializer or to be used as input to a Deserializer.

Variants§

§

Bool(bool)

A bool.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(true.serialize(&serializer), [Token::Bool(true)]);
§

I8(i8)

An i8.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42i8.serialize(&serializer), [Token::I8(42)]);
§

I16(i16)

An i16.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42i16.serialize(&serializer), [Token::I16(42)]);
§

I32(i32)

An i32.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42i32.serialize(&serializer), [Token::I32(42)]);
§

I64(i64)

An i64.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42i64.serialize(&serializer), [Token::I64(42)]);
§

I128(i128)

An i128.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42i128.serialize(&serializer), [Token::I128(42)]);
§

U8(u8)

A u8.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42u8.serialize(&serializer), [Token::U8(42)]);
§

U16(u16)

A u16.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42u16.serialize(&serializer), [Token::U16(42)]);
§

U32(u32)

A u32.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42u32.serialize(&serializer), [Token::U32(42)]);
§

U64(u64)

A u64.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42u64.serialize(&serializer), [Token::U64(42)]);
§

U128(u128)

A u128.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42u128.serialize(&serializer), [Token::U128(42)]);
§

F32(f32)

A f32.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42.0f32.serialize(&serializer), [Token::F32(42.0)]);
§

F64(f64)

A f64.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(42.0f64.serialize(&serializer), [Token::F64(42.0)]);
§

Char(char)

A char.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!('a'.serialize(&serializer), [Token::Char('a')]);
§

Str(String)

A string.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!("foo".serialize(&serializer), [Token::Str("foo".to_owned())]);
§

Bytes(Vec<u8>)

Bytes.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};
use serde_bytes::Bytes;

let serializer = Serializer::builder().build();

assert_ok_eq!(
    Bytes::new(b"foo").serialize(&serializer),
    [Token::Bytes(b"foo".to_vec())]
);
§

None

An Option::None.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(Option::<()>::None.serialize(&serializer), [Token::None]);
§

Some

An Option::Some.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(Some(()).serialize(&serializer), [Token::Some, Token::Unit]);
§

Unit

A unit.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(().serialize(&serializer), [Token::Unit]);
§

UnitStruct

A unit struct.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
struct UnitStruct;

let serializer = Serializer::builder().build();

assert_ok_eq!(
    UnitStruct.serialize(&serializer),
    [Token::UnitStruct { name: "UnitStruct" }]
);

Fields

§name: &'static str
§

UnitVariant

A unit variant on an enum.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
enum Enum {
    Unit,
}

let serializer = Serializer::builder().build();

assert_ok_eq!(
    Enum::Unit.serialize(&serializer),
    [Token::UnitVariant {
        name: "Enum",
        variant_index: 0,
        variant: "Unit"
    }]
);

Fields

§name: &'static str
§variant_index: u32
§variant: &'static str
§

NewtypeStruct

A newtype struct.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
struct NewtypeStruct(u32);

let serializer = Serializer::builder().build();

assert_ok_eq!(
    NewtypeStruct(42).serialize(&serializer),
    [
        Token::NewtypeStruct {
            name: "NewtypeStruct"
        },
        Token::U32(42)
    ]
);

Fields

§name: &'static str
§

NewtypeVariant

A newtype variant on an enum.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
enum Enum {
    Newtype(u32),
}

let serializer = Serializer::builder().build();

assert_ok_eq!(
    Enum::Newtype(42).serialize(&serializer),
    [
        Token::NewtypeVariant {
            name: "Enum",
            variant_index: 0,
            variant: "Newtype"
        },
        Token::U32(42)
    ]
);

Fields

§name: &'static str
§variant_index: u32
§variant: &'static str
§

Seq

A sequence.

Must be followed by a SeqEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(
    vec![1u32, 2u32, 3u32].serialize(&serializer),
    [
        Token::Seq { len: Some(3) },
        Token::U32(1),
        Token::U32(2),
        Token::U32(3),
        Token::SeqEnd
    ]
);

Fields

§len: Option<usize>
§

SeqEnd

The end of a sequence.

This token must follow a Seq token.

§

Tuple

A tuple.

Must be followed by a TupleEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

let serializer = Serializer::builder().build();

assert_ok_eq!(
    (42u32, true).serialize(&serializer),
    [
        Token::Tuple { len: 2 },
        Token::U32(42),
        Token::Bool(true),
        Token::TupleEnd
    ]
);

Fields

§len: usize
§

TupleEnd

The end of a tuple.

This token must follow a Tuple token.

§

TupleStruct

A tuple struct.

Must be followed by a TupleStructEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
struct TupleStruct(u32, bool);

let serializer = Serializer::builder().build();

assert_ok_eq!(
    TupleStruct(42u32, true).serialize(&serializer),
    [
        Token::TupleStruct {
            name: "TupleStruct",
            len: 2
        },
        Token::U32(42),
        Token::Bool(true),
        Token::TupleStructEnd
    ]
);

Fields

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

TupleStructEnd

The end of a tuple struct.

This token must follow a TupleStruct token.

§

TupleVariant

A tuple variant on an enum.

Must be followed by a TupleVariantEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
enum Enum {
    Tuple(u32, bool),
}
struct TupleStruct(u32, bool);

let serializer = Serializer::builder().build();

assert_ok_eq!(
    Enum::Tuple(42u32, true).serialize(&serializer),
    [
        Token::TupleVariant {
            name: "Enum",
            variant_index: 0,
            variant: "Tuple",
            len: 2
        },
        Token::U32(42),
        Token::Bool(true),
        Token::TupleVariantEnd
    ]
);

Fields

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

TupleVariantEnd

The end of a tuple variant.

This token must follow a TupleVariant token.

§

Map

A map.

Must be followed by a MapEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};
use std::collections::HashMap;

let serializer = Serializer::builder().build();

let mut map = HashMap::new();
map.insert("foo", 42u32);

assert_ok_eq!(
    map.serialize(&serializer),
    [
        Token::Map { len: Some(1) },
        Token::Str("foo".to_owned()),
        Token::U32(42),
        Token::MapEnd
    ]
);

Fields

§len: Option<usize>
§

MapEnd

The end of a map.

This token must follow a Map token.

§

Field(&'static str)

A field within a Struct.

§

SkippedField(&'static str)

A field within a Struct, skipped during serialization.

This token is emitted when the SerializeStruct::skip_field() method is called during serialization.

§

Struct

A struct.

Must be followed by a StructEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
struct Struct {
    foo: u32,
    bar: bool,
}

let serializer = Serializer::builder().build();

assert_ok_eq!(
    Struct {
        foo: 42u32,
        bar: true
    }
    .serialize(&serializer),
    [
        Token::Struct {
            name: "Struct",
            len: 2
        },
        Token::Field("foo"),
        Token::U32(42),
        Token::Field("bar"),
        Token::Bool(true),
        Token::StructEnd
    ]
);

Fields

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

StructEnd

The end of a struct.

This token must follow a Struct token.

§

StructVariant

A struct variant on an enum.

Must be followed by a StructVariantEnd token.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};

#[derive(Serialize)]
enum Enum {
    Struct { foo: u32, bar: bool },
}

let serializer = Serializer::builder().build();

assert_ok_eq!(
    Enum::Struct {
        foo: 42u32,
        bar: true
    }
    .serialize(&serializer),
    [
        Token::StructVariant {
            name: "Enum",
            variant_index: 0,
            variant: "Struct",
            len: 2
        },
        Token::Field("foo"),
        Token::U32(42),
        Token::Field("bar"),
        Token::Bool(true),
        Token::StructVariantEnd
    ]
);

Fields

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

StructVariantEnd

The end of a struct variant.

This token must follow a StructVariant token.

§

Unordered(&'static [&'static [Token]])

Unordered sets of tokens.

This token is primarily used for evaluating output from a Serializer for containers or other types whose internal ordering is not defined (such as a HashSet).

This is a set of groups of tokens, where the groups may appear in any order when comparing equality of Tokens. In other words, the outer slice is unordered, while the inner slices are all ordered.

§Example

use claims::assert_ok_eq;
use serde::Serialize;
use serde_assert::{
    Serializer,
    Token,
};
use std::collections::HashMap;

let serializer = Serializer::builder().build();

let mut map = HashMap::<char, u32>::new();
map.insert('a', 1);
map.insert('b', 2);
map.insert('c', 3);

assert_ok_eq!(
    map.serialize(&serializer),
    [
        Token::Map { len: Some(3) },
        Token::Unordered(&[
            &[Token::Char('a'), Token::U32(1)],
            &[Token::Char('b'), Token::U32(2)],
            &[Token::Char('c'), Token::U32(3)]
        ]),
        Token::MapEnd
    ]
);

Trait Implementations§

Source§

impl Clone for Token

Source§

fn clone(&self) -> Token

Returns a duplicate 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

Auto Trait Implementations§

§

impl Freeze for Token

§

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 T
where T: 'static + ?Sized,

Source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
Source§

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

Source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
Source§

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

Source§

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

Mutably borrows from an owned value. Read more
Source§

impl<T> CloneToUninit for T
where T: Clone,

Source§

unsafe fn clone_to_uninit(&self, dest: *mut u8)

🔬This is a nightly-only experimental API. (clone_to_uninit)
Performs copy-assignment from self to dest. Read more
Source§

impl<T> From<T> for T

Source§

fn from(t: T) -> T

Returns the argument unchanged.

Source§

impl<T, U> Into<U> for T
where 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 T
where T: Clone,

Source§

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, U> TryFrom<U> for T
where U: Into<T>,

Source§

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 T
where U: TryFrom<T>,

Source§

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.