Enum minicbor::decode::Token

pub enum Token<'b> {
    Bool(bool),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    Int(Int),
    F16(f32),
    F32(f32),
    F64(f64),
    Bytes(&'b [u8]),
    String(&'b str),
    Array(u64),
    Map(u64),
    Tag(Tag),
    Simple(u8),
    Break,
    Null,
    Undefined,
    BeginBytes,
    BeginString,
    BeginArray,
    BeginMap,
}

Representation of possible CBOR tokens.

Requires feature "half".

Variants

Bool(bool)

U8(u8)

U16(u16)

U32(u32)

U64(u64)

I8(i8)

I16(i16)

I32(i32)

I64(i64)

Int(Int)

F16(f32)

F32(f32)

F64(f64)

Bytes(&'b [u8])

String(&'b str)

Array(u64)

Map(u64)

Tag(Tag)

Simple(u8)

Break

Null

Undefined

BeginBytes

Start of indefinite byte string.

BeginString

Start of indefinite text string.

BeginArray

Start of indefinite array.

BeginMap

Start of indefinite map.

Trait Implementations

impl<'b> Clone for Token<'b>

fn clone(&self) -> Token<'b>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'b> Debug for Token<'b>

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

Formats the value using the given formatter.

impl Display for Token<'_>

Pretty print a token.

Since we only show a single token we can not use diagnostic notation as in the Display impl of Tokenizer. Instead, the following syntax is used:

• Numeric values and booleans are displayed as in Rust. Floats are always shown in scientific notation.
• Text strings are displayed in double quotes.
• Byte strings are displayed in single quotes prefixed with h and hex-encoded, e.g. h'01 02 ef'.
• An array is displayed as A[n] where n denotes the number of elements. The following n tokens are elements of this array.
• A map is displayed as M[n] where n denotes the number of pairs. The following n tokens are entries of this map.
• Tags are displayed with T(t) where t is the tag number.
• Simple values are displayed as simple(n) where n denotes the numeric value.
• Indefinite items start with:
  • ?B[ for byte strings,
  • ?S[ for text strings,
  • ?A[ for arrays,
  • ?M[ for maps, and end with ] when a Token::Break is encountered. All tokens in between belong to the indefinite container.
• Token::Null is displayed as null and Token::Undefined as undefined.

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

Formats the value using the given formatter.

impl<'b> PartialEq for Token<'b>

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

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

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.

impl<'b> Copy for Token<'b>

impl<'b> StructuralPartialEq for Token<'b>