Enum minicbor::decode::Token[−][src]

pub enum Token<'b> {
Show 25 variants
    Bool(bool),
    U8(u8),
    U16(u16),
    U32(u32),
    U64(u64),
    I8(i8),
    I16(i16),
    I32(i32),
    I64(i64),
    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,
}

Expand description

Representation of possible CBOR tokens.

Requires feature "half".

Variants

Bool(bool)

Tuple Fields of Bool

0: bool

U8(u8)

Tuple Fields of U8

0: u8

U16(u16)

Tuple Fields of U16

0: u16

U32(u32)

Tuple Fields of U32

0: u32

U64(u64)

Tuple Fields of U64

0: u64

I8(i8)

Tuple Fields of I8

0: i8

I16(i16)

Tuple Fields of I16

0: i16

I32(i32)

Tuple Fields of I32

0: i32

I64(i64)

Tuple Fields of I64

0: i64

F16(f32)

Tuple Fields of F16

0: f32

F32(f32)

Tuple Fields of F32

0: f32

F64(f64)

Tuple Fields of F64

0: f64

Bytes(&'b [u8])

Tuple Fields of Bytes

0: &'b [u8]

String(&'b str)

Tuple Fields of String

0: &'b str

Array(u64)

Tuple Fields of Array

0: u64

Map(u64)

Tuple Fields of Map

0: u64

Tag(Tag)

Tuple Fields of Tag

0: Tag

Simple(u8)

Tuple Fields of Simple

0: 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

[src]

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

[src]

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

Returns a copy of the value. Read more

1.0.0[src]

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

Performs copy-assignment from source. Read more

[src]

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

[src]

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

Formats the value using the given formatter. Read more

[src]

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.