wasmtime 20.0.2 → 21.0.1

data/ext/cargo-vendor/bincode-1.3.3/src/de/mod.rs

@@ -1,515 +0,0 @@
-use config::{BincodeByteOrder, Options};
-use std::io::Read;
-
-use self::read::{BincodeRead, IoReader, SliceReader};
-use byteorder::ReadBytesExt;
-use config::{IntEncoding, SizeLimit};
-use serde;
-use serde::de::Error as DeError;
-use serde::de::IntoDeserializer;
-use {Error, ErrorKind, Result};
-
-/// Specialized ways to read data into bincode.
-pub mod read;
-
-/// A Deserializer that reads bytes from a buffer.
-///
-/// This struct should rarely be used.
-/// In most cases, prefer the `deserialize_from` function.
-///
-/// The ByteOrder that is chosen will impact the endianness that
-/// is used to read integers out of the reader.
-///
-/// ```ignore
-/// let d = Deserializer::new(&mut some_reader, SizeLimit::new());
-/// serde::Deserialize::deserialize(&mut deserializer);
-/// let bytes_read = d.bytes_read();
-/// ```
-pub struct Deserializer<R, O: Options> {
-    pub(crate) reader: R,
-    options: O,
-}
-
-macro_rules! impl_deserialize_literal {
-    ($name:ident : $ty:ty = $read:ident()) => {
-        #[inline]
-        pub(crate) fn $name(&mut self) -> Result<$ty> {
-            self.read_literal_type::<$ty>()?;
-            self.reader
-                .$read::<<O::Endian as BincodeByteOrder>::Endian>()
-                .map_err(Into::into)
-        }
-    };
-}
-
-impl<'de, IR: Read, O: Options> Deserializer<IoReader<IR>, O> {
-    /// Creates a new Deserializer with a given `Read`er and options.
-    pub fn with_reader(r: IR, options: O) -> Self {
-        Deserializer {
-            reader: IoReader::new(r),
-            options,
-        }
-    }
-}
-
-impl<'de, O: Options> Deserializer<SliceReader<'de>, O> {
-    /// Creates a new Deserializer that will read from the given slice.
-    pub fn from_slice(slice: &'de [u8], options: O) -> Self {
-        Deserializer {
-            reader: SliceReader::new(slice),
-            options,
-        }
-    }
-}
-
-impl<'de, R: BincodeRead<'de>, O: Options> Deserializer<R, O> {
-    /// Creates a new Deserializer with the given `BincodeRead`er
-    pub fn with_bincode_read(r: R, options: O) -> Deserializer<R, O> {
-        Deserializer { reader: r, options }
-    }
-
-    pub(crate) fn deserialize_byte(&mut self) -> Result<u8> {
-        self.read_literal_type::<u8>()?;
-        self.reader.read_u8().map_err(Into::into)
-    }
-
-    impl_deserialize_literal! { deserialize_literal_u16 : u16 = read_u16() }
-    impl_deserialize_literal! { deserialize_literal_u32 : u32 = read_u32() }
-    impl_deserialize_literal! { deserialize_literal_u64 : u64 = read_u64() }
-
-    serde_if_integer128! {
-        impl_deserialize_literal! { deserialize_literal_u128 : u128 = read_u128() }
-    }
-
-    fn read_bytes(&mut self, count: u64) -> Result<()> {
-        self.options.limit().add(count)
-    }
-
-    fn read_literal_type<T>(&mut self) -> Result<()> {
-        use std::mem::size_of;
-        self.read_bytes(size_of::<T>() as u64)
-    }
-
-    fn read_vec(&mut self) -> Result<Vec<u8>> {
-        let len = O::IntEncoding::deserialize_len(self)?;
-        self.read_bytes(len as u64)?;
-        self.reader.get_byte_buffer(len)
-    }
-
-    fn read_string(&mut self) -> Result<String> {
-        let vec = self.read_vec()?;
-        String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into())
-    }
-}
-
-macro_rules! impl_deserialize_int {
-    ($name:ident = $visitor_method:ident ($dser_method:ident)) => {
-        #[inline]
-        fn $name<V>(self, visitor: V) -> Result<V::Value>
-        where
-            V: serde::de::Visitor<'de>,
-        {
-            visitor.$visitor_method(O::IntEncoding::$dser_method(self)?)
-        }
-    };
-}
-
-impl<'de, 'a, R, O> serde::Deserializer<'de> for &'a mut Deserializer<R, O>
-where
-    R: BincodeRead<'de>,
-    O: Options,
-{
-    type Error = Error;
-
-    #[inline]
-    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        Err(Box::new(ErrorKind::DeserializeAnyNotSupported))
-    }
-
-    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        match self.deserialize_byte()? {
-            1 => visitor.visit_bool(true),
-            0 => visitor.visit_bool(false),
-            value => Err(ErrorKind::InvalidBoolEncoding(value).into()),
-        }
-    }
-
-    impl_deserialize_int!(deserialize_u16 = visit_u16(deserialize_u16));
-    impl_deserialize_int!(deserialize_u32 = visit_u32(deserialize_u32));
-    impl_deserialize_int!(deserialize_u64 = visit_u64(deserialize_u64));
-    impl_deserialize_int!(deserialize_i16 = visit_i16(deserialize_i16));
-    impl_deserialize_int!(deserialize_i32 = visit_i32(deserialize_i32));
-    impl_deserialize_int!(deserialize_i64 = visit_i64(deserialize_i64));
-
-    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        self.read_literal_type::<f32>()?;
-        let value = self
-            .reader
-            .read_f32::<<O::Endian as BincodeByteOrder>::Endian>()?;
-        visitor.visit_f32(value)
-    }
-
-    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        self.read_literal_type::<f64>()?;
-        let value = self
-            .reader
-            .read_f64::<<O::Endian as BincodeByteOrder>::Endian>()?;
-        visitor.visit_f64(value)
-    }
-
-    serde_if_integer128! {
-        impl_deserialize_int!(deserialize_u128 = visit_u128(deserialize_u128));
-        impl_deserialize_int!(deserialize_i128 = visit_i128(deserialize_i128));
-    }
-
-    #[inline]
-    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_u8(self.deserialize_byte()? as u8)
-    }
-
-    #[inline]
-    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_i8(self.deserialize_byte()? as i8)
-    }
-
-    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-
-    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        use std::str;
-
-        let error = || ErrorKind::InvalidCharEncoding.into();
-
-        let mut buf = [0u8; 4];
-
-        // Look at the first byte to see how many bytes must be read
-        self.reader.read_exact(&mut buf[..1])?;
-        let width = utf8_char_width(buf[0]);
-        if width == 1 {
-            return visitor.visit_char(buf[0] as char);
-        }
-        if width == 0 {
-            return Err(error());
-        }
-
-        if self.reader.read_exact(&mut buf[1..width]).is_err() {
-            return Err(error());
-        }
-
-        let res = str::from_utf8(&buf[..width])
-            .ok()
-            .and_then(|s| s.chars().next())
-            .ok_or_else(error)?;
-        visitor.visit_char(res)
-    }
-
-    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let len = O::IntEncoding::deserialize_len(self)?;
-        self.read_bytes(len as u64)?;
-        self.reader.forward_read_str(len, visitor)
-    }
-
-    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_string(self.read_string()?)
-    }
-
-    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let len = O::IntEncoding::deserialize_len(self)?;
-        self.read_bytes(len as u64)?;
-        self.reader.forward_read_bytes(len, visitor)
-    }
-
-    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_byte_buf(self.read_vec()?)
-    }
-
-    fn deserialize_enum<V>(
-        self,
-        _enum: &'static str,
-        _variants: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        impl<'de, 'a, R: 'a, O> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, O>
-        where
-            R: BincodeRead<'de>,
-            O: Options,
-        {
-            type Error = Error;
-            type Variant = Self;
-
-            fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
-            where
-                V: serde::de::DeserializeSeed<'de>,
-            {
-                let idx: u32 = O::IntEncoding::deserialize_u32(self)?;
-                let val: Result<_> = seed.deserialize(idx.into_deserializer());
-                Ok((val?, self))
-            }
-        }
-
-        visitor.visit_enum(self)
-    }
-
-    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        struct Access<'a, R: Read + 'a, O: Options + 'a> {
-            deserializer: &'a mut Deserializer<R, O>,
-            len: usize,
-        }
-
-        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::SeqAccess<'de>
-            for Access<'a, R, O>
-        {
-            type Error = Error;
-
-            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
-            where
-                T: serde::de::DeserializeSeed<'de>,
-            {
-                if self.len > 0 {
-                    self.len -= 1;
-                    let value =
-                        serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
-                    Ok(Some(value))
-                } else {
-                    Ok(None)
-                }
-            }
-
-            fn size_hint(&self) -> Option<usize> {
-                Some(self.len)
-            }
-        }
-
-        visitor.visit_seq(Access {
-            deserializer: self,
-            len,
-        })
-    }
-
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let value: u8 = serde::de::Deserialize::deserialize(&mut *self)?;
-        match value {
-            0 => visitor.visit_none(),
-            1 => visitor.visit_some(&mut *self),
-            v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()),
-        }
-    }
-
-    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let len = O::IntEncoding::deserialize_len(self)?;
-
-        self.deserialize_tuple(len, visitor)
-    }
-
-    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        struct Access<'a, R: Read + 'a, O: Options + 'a> {
-            deserializer: &'a mut Deserializer<R, O>,
-            len: usize,
-        }
-
-        impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::MapAccess<'de>
-            for Access<'a, R, O>
-        {
-            type Error = Error;
-
-            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
-            where
-                K: serde::de::DeserializeSeed<'de>,
-            {
-                if self.len > 0 {
-                    self.len -= 1;
-                    let key =
-                        serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
-                    Ok(Some(key))
-                } else {
-                    Ok(None)
-                }
-            }
-
-            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
-            where
-                V: serde::de::DeserializeSeed<'de>,
-            {
-                let value = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
-                Ok(value)
-            }
-
-            fn size_hint(&self) -> Option<usize> {
-                Some(self.len)
-            }
-        }
-
-        let len = O::IntEncoding::deserialize_len(self)?;
-
-        visitor.visit_map(Access {
-            deserializer: self,
-            len,
-        })
-    }
-
-    fn deserialize_struct<V>(
-        self,
-        _name: &str,
-        fields: &'static [&'static str],
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        self.deserialize_tuple(fields.len(), visitor)
-    }
-
-    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let message = "Bincode does not support Deserializer::deserialize_identifier";
-        Err(Error::custom(message))
-    }
-
-    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_newtype_struct(self)
-    }
-
-    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        visitor.visit_unit()
-    }
-
-    fn deserialize_tuple_struct<V>(
-        self,
-        _name: &'static str,
-        len: usize,
-        visitor: V,
-    ) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        self.deserialize_tuple(len, visitor)
-    }
-
-    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        let message = "Bincode does not support Deserializer::deserialize_ignored_any";
-        Err(Error::custom(message))
-    }
-
-    fn is_human_readable(&self) -> bool {
-        false
-    }
-}
-
-impl<'de, 'a, R, O> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, O>
-where
-    R: BincodeRead<'de>,
-    O: Options,
-{
-    type Error = Error;
-
-    fn unit_variant(self) -> Result<()> {
-        Ok(())
-    }
-
-    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
-    where
-        T: serde::de::DeserializeSeed<'de>,
-    {
-        serde::de::DeserializeSeed::deserialize(seed, self)
-    }
-
-    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        serde::de::Deserializer::deserialize_tuple(self, len, visitor)
-    }
-
-    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'de>,
-    {
-        serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
-    }
-}
-static UTF8_CHAR_WIDTH: [u8; 256] = [
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, // 0x1F
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, // 0x3F
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, // 0x5F
-    1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
-    1, // 0x7F
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, // 0x9F
-    0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
-    0, // 0xBF
-    0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
-    2, // 0xDF
-    3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
-    4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
-];
-
-// This function is a copy of core::str::utf8_char_width
-fn utf8_char_width(b: u8) -> usize {
-    UTF8_CHAR_WIDTH[b as usize] as usize
-}

data/ext/cargo-vendor/bincode-1.3.3/src/de/read.rs

@@ -1,202 +0,0 @@
-use error::Result;
-use serde;
-use std::io;
-
-/// An optional Read trait for advanced Bincode usage.
-///
-/// It is highly recommended to use bincode with `io::Read` or `&[u8]` before
-/// implementing a custom `BincodeRead`.
-///
-/// The forward_read_* methods are necessary because some byte sources want
-/// to pass a long-lived borrow to the visitor and others want to pass a
-/// transient slice.
-pub trait BincodeRead<'storage>: io::Read {
-    /// Check that the next `length` bytes are a valid string and pass
-    /// it on to the serde reader.
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'storage>;
-
-    /// Transfer ownership of the next `length` bytes to the caller.
-    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>>;
-
-    /// Pass a slice of the next `length` bytes on to the serde reader.
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'storage>;
-}
-
-/// A BincodeRead implementation for byte slices
-pub struct SliceReader<'storage> {
-    slice: &'storage [u8],
-}
-
-/// A BincodeRead implementation for `io::Read`ers
-pub struct IoReader<R> {
-    reader: R,
-    temp_buffer: Vec<u8>,
-}
-
-impl<'storage> SliceReader<'storage> {
-    /// Constructs a slice reader
-    pub(crate) fn new(bytes: &'storage [u8]) -> SliceReader<'storage> {
-        SliceReader { slice: bytes }
-    }
-
-    #[inline(always)]
-    fn get_byte_slice(&mut self, length: usize) -> Result<&'storage [u8]> {
-        if length > self.slice.len() {
-            return Err(SliceReader::unexpected_eof());
-        }
-        let (read_slice, remaining) = self.slice.split_at(length);
-        self.slice = remaining;
-        Ok(read_slice)
-    }
-
-    pub(crate) fn is_finished(&self) -> bool {
-        self.slice.is_empty()
-    }
-}
-
-impl<R> IoReader<R> {
-    /// Constructs an IoReadReader
-    pub(crate) fn new(r: R) -> IoReader<R> {
-        IoReader {
-            reader: r,
-            temp_buffer: vec![],
-        }
-    }
-}
-
-impl<'storage> io::Read for SliceReader<'storage> {
-    #[inline(always)]
-    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
-        if out.len() > self.slice.len() {
-            return Err(io::ErrorKind::UnexpectedEof.into());
-        }
-        let (read_slice, remaining) = self.slice.split_at(out.len());
-        out.copy_from_slice(read_slice);
-        self.slice = remaining;
-
-        Ok(out.len())
-    }
-
-    #[inline(always)]
-    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
-        self.read(out).map(|_| ())
-    }
-}
-
-impl<R: io::Read> io::Read for IoReader<R> {
-    #[inline(always)]
-    fn read(&mut self, out: &mut [u8]) -> io::Result<usize> {
-        self.reader.read(out)
-    }
-    #[inline(always)]
-    fn read_exact(&mut self, out: &mut [u8]) -> io::Result<()> {
-        self.reader.read_exact(out)
-    }
-}
-
-impl<'storage> SliceReader<'storage> {
-    #[inline(always)]
-    fn unexpected_eof() -> Box<::ErrorKind> {
-        Box::new(::ErrorKind::Io(io::Error::new(
-            io::ErrorKind::UnexpectedEof,
-            "",
-        )))
-    }
-}
-
-impl<'storage> BincodeRead<'storage> for SliceReader<'storage> {
-    #[inline(always)]
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'storage>,
-    {
-        use ErrorKind;
-        let string = match ::std::str::from_utf8(self.get_byte_slice(length)?) {
-            Ok(s) => s,
-            Err(e) => return Err(ErrorKind::InvalidUtf8Encoding(e).into()),
-        };
-        visitor.visit_borrowed_str(string)
-    }
-
-    #[inline(always)]
-    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
-        self.get_byte_slice(length).map(|x| x.to_vec())
-    }
-
-    #[inline(always)]
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'storage>,
-    {
-        visitor.visit_borrowed_bytes(self.get_byte_slice(length)?)
-    }
-}
-
-impl<R> IoReader<R>
-where
-    R: io::Read,
-{
-    fn fill_buffer(&mut self, length: usize) -> Result<()> {
-        self.temp_buffer.resize(length, 0);
-
-        self.reader.read_exact(&mut self.temp_buffer)?;
-
-        Ok(())
-    }
-}
-
-impl<'a, R> BincodeRead<'a> for IoReader<R>
-where
-    R: io::Read,
-{
-    fn forward_read_str<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'a>,
-    {
-        self.fill_buffer(length)?;
-
-        let string = match ::std::str::from_utf8(&self.temp_buffer[..]) {
-            Ok(s) => s,
-            Err(e) => return Err(::ErrorKind::InvalidUtf8Encoding(e).into()),
-        };
-
-        visitor.visit_str(string)
-    }
-
-    fn get_byte_buffer(&mut self, length: usize) -> Result<Vec<u8>> {
-        self.fill_buffer(length)?;
-        Ok(::std::mem::replace(&mut self.temp_buffer, Vec::new()))
-    }
-
-    fn forward_read_bytes<V>(&mut self, length: usize, visitor: V) -> Result<V::Value>
-    where
-        V: serde::de::Visitor<'a>,
-    {
-        self.fill_buffer(length)?;
-        visitor.visit_bytes(&self.temp_buffer[..])
-    }
-}
-
-#[cfg(test)]
-mod test {
-    use super::IoReader;
-
-    #[test]
-    fn test_fill_buffer() {
-        let buffer = vec![0u8; 64];
-        let mut reader = IoReader::new(buffer.as_slice());
-
-        reader.fill_buffer(20).unwrap();
-        assert_eq!(20, reader.temp_buffer.len());
-
-        reader.fill_buffer(30).unwrap();
-        assert_eq!(30, reader.temp_buffer.len());
-
-        reader.fill_buffer(5).unwrap();
-        assert_eq!(5, reader.temp_buffer.len());
-    }
-}