Enum 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, C> CborLen<C> for Token<'b>

fn cbor_len(&self, ctx: &mut C) -> usize

Compute the CBOR encoding length in bytes of this value.

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

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

Returns a duplicate 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<(), Error>

Formats the value using the given formatter.

impl<'b, C> Decode<'b, C> for Token<'b>

fn decode(d: &mut Decoder<'b>, _: &mut C) -> Result<Token<'b>, Error>

Decode a value using the given Decoder.

fn nil() -> Option<Self>

If possible, return a nil value of Self.

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 crate::decode::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<(), Error>

Formats the value using the given formatter.

impl<'b, C> Encode<C> for Token<'b>

fn encode<W>( &self, e: &mut Encoder<W>, _: &mut C, ) -> Result<(), Error<<W as Write>::Error>>

where W: Write,

Encode a value of this type using the given Encoder.

fn is_nil(&self) -> bool

Is this value of Self a nil value?

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

fn eq(&self, other: &Token<'b>) -> 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<'b> Copy for Token<'b>

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