Enum Size

pub enum Size {
    Head,
    Bytes(u64),
    Items(u64),
    Indef,
}

Information about a CBOR item size.

Usage example

use minicbor::decode::info::Size;

let val  = vec![1, 2, 3, 4, 5];
let cbor = minicbor::to_vec(val)?;
let hlen = Size::head(cbor[0])?;
let size = Size::tail(&cbor[.. hlen])?;
assert_eq!(Size::Items(5), size);

Variants

Head

The item consists only of the head.

Bytes(u64)

The item is some text or byte string with the given number of bytes.

Items(u64)

The item is an array or map with the given number of items.

Indef

The item is an indefinite value.

Implementations

impl Size

pub fn head(fst: u8) -> Result<usize, Error>

Given the first byte, derive the length of the item head.

pub fn tail(head: &[u8]) -> Result<Self, Error>

Given the item head, derive the CBOR item’s size information.

Trait Implementations

impl Clone for Size

fn clone(&self) -> Size

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Size

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

Formats the value using the given formatter.

impl PartialEq for Size

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

impl Eq for Size

impl StructuralPartialEq for Size

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes

Size for each variant:

• Head: 0 bytes
• Bytes: 8 bytes
• Items: 8 bytes
• Indef: 0 bytes