2 files changed, 717 insertions, 0 deletions
diff --git a/third_party/rust/bincode/src/de/mod.rs b/third_party/rust/bincode/src/de/mod.rs
new file mode 100644
index 0000000000..7b2bdf5286
--- /dev/null
+++ b/third_party/rust/bincode/src/de/mod.rs
@@ -0,0 +1,515 @@
+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
+}
diff --git a/third_party/rust/bincode/src/de/read.rs b/third_party/rust/bincode/src/de/read.rs
new file mode 100644
index 0000000000..08b76adc90
--- /dev/null
+++ b/third_party/rust/bincode/src/de/read.rs
@@ -0,0 +1,202 @@
+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());
+    }
+}