esl01-mincode 0.3.0

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

use std::str;

use byteorder::NetworkEndian;
use byteorder::ReadBytesExt;
use serde::de;
use serde::de::Deserialize;
use serde::de::DeserializeSeed;
use serde::de::EnumAccess;
use serde::de::IntoDeserializer;
use serde::de::SeqAccess;
use serde::de::VariantAccess;
use serde::de::Visitor;
use vlqencoding::VLQDecode;

use crate::Error;
use crate::Result;

pub struct Deserializer<'de> {
    bytes: &'de [u8],
}

impl<'de> Deserializer<'de> {
    pub fn new(bytes: &'de [u8]) -> Self {
        Deserializer { bytes }
    }

    #[inline]
    fn read_slice(&mut self) -> Result<&'de [u8]> {
        let len = Deserialize::deserialize(&mut *self)?;
        let (slice, rest) = self.bytes.split_at(len);
        self.bytes = rest;
        Ok(slice)
    }

    #[inline]
    fn read_str(&mut self) -> Result<&'de str> {
        str::from_utf8(self.read_slice()?).map_err(Into::into)
    }
}

macro_rules! impl_nums {
    ($ty:ty, $dser_method:ident, $visitor_method:ident, $($reader_method:tt)*) => {
        #[inline]
        fn $dser_method<V>(self, visitor: V) -> Result<V::Value>
            where V: Visitor<'de>
        {
            let value = self.bytes.$($reader_method)*()?;
            visitor.$visitor_method(value)
        }
    };
}

impl<'de, 'a> serde::Deserializer<'de> for &'a mut Deserializer<'de> {
    type Error = Error;

    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        Err(Error::new("`deserialize_any` is not supported"))
    }

    #[inline]
    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        match self.bytes.read_u8()? {
            1 => visitor.visit_bool(true),
            0 => visitor.visit_bool(false),
            _ => Err(Error::new("invalid boolean")),
        }
    }

    impl_nums!(u8, deserialize_u8, visit_u8, read_u8);
    impl_nums!(u16, deserialize_u16, visit_u16, read_vlq);
    impl_nums!(u32, deserialize_u32, visit_u32, read_vlq);
    impl_nums!(u64, deserialize_u64, visit_u64, read_vlq);
    impl_nums!(i8, deserialize_i8, visit_i8, read_i8);
    impl_nums!(i16, deserialize_i16, visit_i16, read_vlq);
    impl_nums!(i32, deserialize_i32, visit_i32, read_vlq);
    impl_nums!(i64, deserialize_i64, visit_i64, read_vlq);
    impl_nums!(f32, deserialize_f32, visit_f32, read_f32::<NetworkEndian>);
    impl_nums!(f64, deserialize_f64, visit_f64, read_f64::<NetworkEndian>);

    #[inline]
    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_unit()
    }

    #[inline]
    fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let width = utf8_char_width(self.bytes[0]);
        if width == 1 {
            return visitor.visit_char(self.bytes[0] as char);
        }
        if width == 0 {
            return Err(Error::new("invalid char"));
        }
        let res = match str::from_utf8(&self.bytes[..width]) {
            Ok(s) => s.chars().next().unwrap(),
            Err(err) => {
                return Err(err.into());
            }
        };
        self.bytes = &self.bytes[width..];
        visitor.visit_char(res)
    }

    #[inline]
    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_borrowed_str(self.read_str()?)
    }

    #[inline]
    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_borrowed_str(self.read_str()?)
    }

    #[inline]
    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_borrowed_bytes(self.read_slice()?)
    }

    #[inline]
    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_borrowed_bytes(self.read_slice()?)
    }

    #[inline]
    fn deserialize_enum<V>(
        self,
        _enum: &'static str,
        _variants: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_enum(self)
    }

    #[inline]
    fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_seq(self)
    }

    #[inline]
    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        match self.bytes.read_u8()? {
            0 => visitor.visit_none(),
            1 => visitor.visit_some(self),
            _ => Err(Error::new("invalid Option")),
        }
    }

    #[inline]
    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        struct SeqAccess<'a, 'de: 'a> {
            deserializer: &'a mut Deserializer<'de>,
            remaining: usize,
        }

        impl<'de, 'a> de::SeqAccess<'de> for SeqAccess<'a, 'de> {
            type Error = Error;

            #[inline]
            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
            where
                T: DeserializeSeed<'de>,
            {
                if self.remaining > 0 {
                    self.remaining -= 1;
                    seed.deserialize(&mut *self.deserializer).map(Some)
                } else {
                    Ok(None)
                }
            }
        }

        let len = Deserialize::deserialize(&mut *self)?;

        visitor.visit_seq(SeqAccess {
            deserializer: self,
            remaining: len,
        })
    }

    #[inline]
    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        struct MapAccess<'a, 'de: 'a> {
            deserializer: &'a mut Deserializer<'de>,
            remaining: usize,
        }

        impl<'de, 'a> de::MapAccess<'de> for MapAccess<'a, 'de> {
            type Error = Error;

            #[inline]
            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
            where
                K: DeserializeSeed<'de>,
            {
                if self.remaining > 0 {
                    self.remaining -= 1;
                    seed.deserialize(&mut *self.deserializer).map(Some)
                } else {
                    Ok(None)
                }
            }

            #[inline]
            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
            where
                V: DeserializeSeed<'de>,
            {
                seed.deserialize(&mut *self.deserializer)
            }
        }

        let len = Deserialize::deserialize(&mut *self)?;

        visitor.visit_map(MapAccess {
            deserializer: self,
            remaining: len,
        })
    }

    #[inline]
    fn deserialize_struct<V>(
        self,
        _name: &str,
        _fields: &'static [&'static str],
        visitor: V,
    ) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_seq(self)
    }

    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        Err(Error::new("`deserialize_identifier` is not supported"))
    }

    #[inline]
    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_newtype_struct(self)
    }

    #[inline]
    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_unit()
    }

    #[inline]
    fn deserialize_tuple_struct<V>(
        self,
        _name: &'static str,
        _len: usize,
        visitor: V,
    ) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_seq(self)
    }

    fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        Err(Error::new("`deserialize_ignored_any` is not supported"))
    }
}

// For tuples, structs, tuple structs, and fixed size seqs.
impl<'de> SeqAccess<'de> for Deserializer<'de> {
    type Error = Error;

    #[inline]
    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
    where
        T: DeserializeSeed<'de>,
    {
        seed.deserialize(self).map(Some)
    }
}

impl<'de, 'a> EnumAccess<'de> for &'a mut Deserializer<'de> {
    type Error = Error;
    type Variant = Self;

    #[inline]
    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self)>
    where
        V: DeserializeSeed<'de>,
    {
        let index = Deserialize::deserialize(&mut *self)?;
        let deserializer = <u32 as IntoDeserializer<Error>>::into_deserializer(index);
        let value = seed.deserialize(deserializer)?;
        Ok((value, self))
    }
}

impl<'de, 'a> VariantAccess<'de> for &'a mut Deserializer<'de> {
    type Error = Error;

    #[inline]
    fn unit_variant(self) -> Result<()> {
        Ok(())
    }

    #[inline]
    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
    where
        T: DeserializeSeed<'de>,
    {
        seed.deserialize(self)
    }

    #[inline]
    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_seq(self)
    }

    #[inline]
    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        visitor.visit_seq(self)
    }
}

#[rustfmt::skip]
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
];

#[inline]
fn utf8_char_width(b: u8) -> usize {
    UTF8_CHAR_WIDTH[b as usize] as usize
}