Merging upstream version 1.71.1+dfsg1.

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 515 insertions, 0 deletions

diff --git a/vendor/bincode/src/de/mod.rs b/vendor/bincode/src/de/mod.rs
new file mode 100644
index 000000000..7b2bdf528
--- /dev/null
+++ b/vendor/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

+}