Struct rustc_serialize::opaque::Decoder

pub struct Decoder<'a> {
    pub data: &'a [u8],
    position: usize,
}

Fields

data: &'a [u8]

position: usize

Implementations

impl<'a> Decoder<'a>

pub fn new(data: &'a [u8], position: usize) -> Decoder<'a>

pub fn position(&self) -> usize

pub fn set_position(&mut self, pos: usize)

pub fn advance(&mut self, bytes: usize)

pub fn read_raw_bytes(&mut self, bytes: usize) -> &'a [u8]

Trait Implementations

impl<'a> Decodable<Decoder> for Vec<u8>

fn decode(d: &mut Decoder<'a>) -> Result<Self, String>

impl<'a> Decodable<Decoder> for IntEncodedWithFixedSize

fn decode(decoder: &mut Decoder<'a>) -> Result<IntEncodedWithFixedSize, String>

impl<'a> Decoder for Decoder<'a>

type Error = String

fn read_nil(&mut self) -> Result<(), Self::Error>

fn read_u128(&mut self) -> Result<u128, Self::Error>

fn read_u64(&mut self) -> Result<u64, Self::Error>

fn read_u32(&mut self) -> Result<u32, Self::Error>

fn read_u16(&mut self) -> Result<u16, Self::Error>

fn read_u8(&mut self) -> Result<u8, Self::Error>

fn read_usize(&mut self) -> Result<usize, Self::Error>

fn read_i128(&mut self) -> Result<i128, Self::Error>

fn read_i64(&mut self) -> Result<i64, Self::Error>

fn read_i32(&mut self) -> Result<i32, Self::Error>

fn read_i16(&mut self) -> Result<i16, Self::Error>

fn read_i8(&mut self) -> Result<i8, Self::Error>

fn read_isize(&mut self) -> Result<isize, Self::Error>

fn read_bool(&mut self) -> Result<bool, Self::Error>

fn read_f64(&mut self) -> Result<f64, Self::Error>

fn read_f32(&mut self) -> Result<f32, Self::Error>

fn read_char(&mut self) -> Result<char, Self::Error>

fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error>

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

fn read_raw_bytes_into(&mut self, s: &mut [u8]) -> Result<(), String>

fn read_enum<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_enum_variant<T, F>(
    &mut self,
    _names: &[&str],
    f: F
) -> Result<T, Self::Error> where
    F: FnMut(&mut Self, usize) -> Result<T, Self::Error>, 

fn read_enum_variant_arg<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_struct<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_struct_field<T, F>(
    &mut self,
    _f_name: &str,
    f: F
) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_tuple_arg<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_option<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnMut(&mut Self, bool) -> Result<T, Self::Error>, 

fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>, 

fn read_seq_elt<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>, 

fn read_map_elt_key<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

fn read_map_elt_val<T, F>(&mut self, f: F) -> Result<T, Self::Error> where
    F: FnOnce(&mut Self) -> Result<T, Self::Error>, 

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: 24 bytes