[go: up one dir, main page]

Struct cbor::DirectDecoder [−] [src]

pub struct DirectDecoder<R> {
    // some fields omitted
}

Experimental and incomplete direct decoder.

WARNING: Do not use this to decode CBOR data that you don't control. It is currently subject to an attack vector that permits an attacker to cause your process to abort due to an out-of-memory error. See: https://github.com/rust-lang/rustc-serialize/issues/115 (The normal decoder in this crate is not subject to this problem.)

A "direct" decoder is one that does not use an intermediate abstact syntax representation. Namely, the bytes are decoded directly into types. This significantly impacts performance. For example, it doesn't have to box and unbox every data item.

However, implementing a direct decoder is much harder in the existing serialization infrastructure. Currently, structs and enums are not implemented. (But Vecs, tuples, Options and maps should work.)

Methods

impl CborDecoder<Cursor<Vec<u8>>>
[src]

fn from_bytes<'a, T>(bytes: T) -> CborDecoder<Cursor<Vec<u8>>> where T: Into<Vec<u8>>

Create a new CBOR decoder that reads from the buffer given.

The buffer is usually given as either a Vec<u8> or a &[u8].

impl<R: Read> CborDecoder<BufReader<R>>
[src]

fn from_reader(rdr: R) -> CborDecoder<BufReader<R>>

Create a new CBOR decoder that reads from the reader given.

Trait Implementations

impl<R: Read> RustcDecoder for CborDecoder<R>
[src]

type Error = CborError

fn error(&mut self, err: &str) -> CborError

fn read_nil(&mut self) -> CborResult<()>

fn read_usize(&mut self) -> CborResult<usize>

fn read_u64(&mut self) -> CborResult<u64>

fn read_u32(&mut self) -> CborResult<u32>

fn read_u16(&mut self) -> CborResult<u16>

fn read_u8(&mut self) -> CborResult<u8>

fn read_isize(&mut self) -> CborResult<isize>

fn read_i64(&mut self) -> CborResult<i64>

fn read_i32(&mut self) -> CborResult<i32>

fn read_i16(&mut self) -> CborResult<i16>

fn read_i8(&mut self) -> CborResult<i8>

fn read_bool(&mut self) -> CborResult<bool>

fn read_f64(&mut self) -> CborResult<f64>

fn read_f32(&mut self) -> CborResult<f32>

fn read_char(&mut self) -> CborResult<char>

fn read_str(&mut self) -> CborResult<String>

fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> CborResult<T> where F: FnMut(&mut CborDecoder<R>, usize) -> CborResult<T>

fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> CborResult<T> where F: FnMut(&mut CborDecoder<R>, usize) -> CborResult<T>

fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_tuple<T, F>(&mut self, len: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_tuple_struct<T, F>(&mut self, _s_name: &str, len: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_option<T, F>(&mut self, f: F) -> CborResult<T> where F: FnMut(&mut CborDecoder<R>, bool) -> CborResult<T>

fn read_seq<T, F>(&mut self, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>, usize) -> CborResult<T>

fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_map<T, F>(&mut self, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>, usize) -> CborResult<T>

fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>

fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> CborResult<T> where F: FnOnce(&mut CborDecoder<R>) -> CborResult<T>