Struct DirectDecoder

Source

pub struct DirectDecoder<R> { /* private fields */ }

Expand description

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.)

Struct DirectDecoderCopy item path

Implementations§

impl CborDecoder<Cursor<Vec<u8>>>

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

impl<R: Read> CborDecoder<BufReader<R>>

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

Trait Implementations§

impl<R: Read> Decoder for CborDecoder<R>

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>,

Auto Trait Implementations§

impl<R> Freeze for CborDecoder<R>where R: Freeze,

impl<R> RefUnwindSafe for CborDecoder<R>where R: RefUnwindSafe,

impl<R> Send for CborDecoder<R>where R: Send,

impl<R> Sync for CborDecoder<R>where R: Sync,

impl<R> Unpin for CborDecoder<R>where R: Unpin,

impl<R> UnwindSafe for CborDecoder<R>where R: UnwindSafe,

Blanket Implementations§

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<D> DecoderHelpers for Dwhere D: Decoder,

fn read_to_vec<T, F>(&mut self, f: F) -> Result<Vec<T>, <D as Decoder>::Error>where F: FnMut(&mut D) -> Result<T, <D as Decoder>::Error>,

impl<T> From<T> for T

fn from(t: T) -> T

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Struct DirectDecoder

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

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>,

impl<R> Freeze for CborDecoder<R>
where R: Freeze,

impl<R> RefUnwindSafe for CborDecoder<R>
where R: RefUnwindSafe,

impl<R> Send for CborDecoder<R>
where R: Send,

impl<R> Sync for CborDecoder<R>
where R: Sync,

impl<R> Unpin for CborDecoder<R>
where R: Unpin,

impl<R> UnwindSafe for CborDecoder<R>
where R: UnwindSafe,

impl<T> Any for T
where T: 'static + ?Sized,

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

impl<D> DecoderHelpers for D
where D: Decoder,

fn read_to_vec<T, F>(&mut self, f: F) -> Result<Vec<T>, <D as Decoder>::Error>
where F: FnMut(&mut D) -> Result<T, <D as Decoder>::Error>,

impl<T, U> Into<U> for T
where U: From<T>,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,