cbor

Module decoder

Source
Expand description

CBOR (RFC 7049) decoder implementation supporting the following features:

  • Generic decoding using an intermediate representation
  • Tag validation
  • Resource limits (e.g. maximum nesting level)
  • Direct decoding into Rust types
  • Indefinite sized bytes, strings, arrays and objects

The module is structured as follows:

  1. Kernel contains the basic decoding functionality, capable of decoding simple unstructured types.
  2. Decoder directly decodes into native Rust types.
  3. GenericDecoder handles arbitrary CBOR items and decodes them into an Value AST.

§Example 1: Direct decoding

use cbor::{Config, Decoder};
use std::io::Cursor;

let mut d = Decoder::new(Config::default(), Cursor::new(vec![0u8]));
assert_eq!(Some(0), d.u64().ok())

§Example 2: Direct decoding (nested array)

extern crate cbor;
extern crate rustc_serialize;

use cbor::{Config, Decoder};
use rustc_serialize::hex::FromHex;
use std::io::Cursor;

fn main() {
    let input   = Cursor::new("828301020383010203".from_hex().unwrap());
    let mut dec = Decoder::new(Config::default(), input);
    let mut res = Vec::new();
    for _ in 0 .. dec.array().unwrap() {
        let mut vec = Vec::new();
        for _ in 0 .. dec.array().unwrap() {
            vec.push(dec.u8().unwrap())
        }
        res.push(vec)
    }
    assert_eq!(vec![vec![1, 2, 3], vec![1, 2, 3]], res)
}

§Example 3: Generic decoding

extern crate cbor;
extern crate rustc_serialize;

use cbor::{Config, GenericDecoder};
use cbor::value::{self, Key};
use rustc_serialize::hex::FromHex;
use std::io::Cursor;

fn main() {
    let input = Cursor::new("a2616101028103".from_hex().unwrap());
    let mut d = GenericDecoder::new(Config::default(), input);
    let value = d.value().unwrap();
    let     c = value::Cursor::new(&value);
    assert_eq!(Some(1), c.field("a").u8());
    assert_eq!(Some(3), c.get(Key::u64(2)).at(0).u8())
}

§Example 4: Direct decoding (optional value)

use cbor::{opt, Config, Decoder};
use std::io::Cursor;

let mut d = Decoder::new(Config::default(), Cursor::new(vec![0xF6]));
assert_eq!(None, opt(d.u8()).unwrap())

Structs§

BytesIter
Iterator over the chunks of an indefinite bytes item.
Config
Config contains various settings which limit resource consumption or enable certain validation options. Please note that the various maximum length/size values apply to an individual element only.
Decoder
The actual decoder type definition
GenericDecoder
A generic decoder decodes arbitrary CBOR into a Value AST.
Kernel
This decoding kernel reads from an underlying std::io::Read type primitive CBOR values such as unsigned and signed integers as well as raw bytes. It forms the basis on which Decoder and GenericDecoder add logic for handling Tags, heterogenous data and generic value decoding.
TextIter
Iterator over the chunks of an indefinite text item.

Enums§

DecodeError

Functions§

maybe
When decoding an item which may be Undefined this function will map Undefined to None and any other value to Some(value).
opt
When decoding an optional item, i.e. a Null value has to be considered, this function will map Null to None and any other value to Some(value).
or_break
When decoding an indefinite item, every element item can be a Break value. By wrapping it in or_break, this case can be handled more conveniently.

Type Aliases§

DecodeResult
TypeInfo