2023-07-21 16:15:30 +00:00
|
|
|
use serde::de::{DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
|
2020-05-27 07:04:55 +00:00
|
|
|
use serde::Deserialize;
|
2021-07-04 15:16:13 +00:00
|
|
|
|
2020-05-27 07:04:55 +00:00
|
|
|
use std::borrow::Cow;
|
2021-07-21 19:52:20 +00:00
|
|
|
use std::io;
|
2020-05-27 07:04:55 +00:00
|
|
|
use std::marker::PhantomData;
|
2021-07-04 15:16:13 +00:00
|
|
|
|
2021-08-02 09:42:48 +00:00
|
|
|
use super::value::boundary as B;
|
2023-07-21 16:15:30 +00:00
|
|
|
use super::value::reader::{BytesBinarySource, IOBinarySource, Reader};
|
2021-08-02 09:42:48 +00:00
|
|
|
use super::value::{IOValue, IOValueDomainCodec, PackedReader, TextReader, ViaCodec};
|
2020-05-27 07:04:55 +00:00
|
|
|
|
|
|
|
pub use super::error::Error;
|
|
|
|
|
|
|
|
pub type Result<T> = std::result::Result<T, Error>;
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
pub struct Deserializer<'de, 'r, R: Reader<'de, IOValue>> {
|
2020-05-27 07:04:55 +00:00
|
|
|
pub read: &'r mut R,
|
|
|
|
phantom: PhantomData<&'de ()>,
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
pub fn from_bytes<'de, T>(bytes: &'de [u8]) -> Result<T>
|
2020-05-27 07:04:55 +00:00
|
|
|
where
|
2023-07-21 16:15:30 +00:00
|
|
|
T: Deserialize<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2023-07-21 16:15:30 +00:00
|
|
|
from_reader(&mut PackedReader::new(
|
|
|
|
&mut BytesBinarySource::new(bytes),
|
|
|
|
IOValueDomainCodec,
|
|
|
|
))
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
pub fn from_text<'de, T>(text: &'de str) -> Result<T>
|
|
|
|
where
|
|
|
|
T: Deserialize<'de>,
|
|
|
|
{
|
|
|
|
from_reader(&mut TextReader::new(
|
|
|
|
&mut BytesBinarySource::new(text.as_bytes()),
|
|
|
|
ViaCodec::new(IOValueDomainCodec),
|
|
|
|
))
|
2021-08-02 09:42:48 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
pub fn from_read<'de, 'r, IOR: io::Read + io::Seek, T>(read: &'r mut IOR) -> Result<T>
|
2020-05-27 07:04:55 +00:00
|
|
|
where
|
2023-07-21 16:15:30 +00:00
|
|
|
T: Deserialize<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2023-07-21 16:15:30 +00:00
|
|
|
from_reader(&mut PackedReader::new(
|
|
|
|
&mut IOBinarySource::new(read),
|
|
|
|
IOValueDomainCodec,
|
|
|
|
))
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
pub fn from_reader<'r, 'de, R: Reader<'de, IOValue>, T>(read: &'r mut R) -> Result<T>
|
2020-05-27 07:04:55 +00:00
|
|
|
where
|
2023-07-21 16:15:30 +00:00
|
|
|
T: Deserialize<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
let mut de = Deserializer::from_reader(read);
|
|
|
|
let t = T::deserialize(&mut de)?;
|
|
|
|
Ok(t)
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
impl<'r, 'de, R: Reader<'de, IOValue>> Deserializer<'de, 'r, R> {
|
2020-05-27 07:04:55 +00:00
|
|
|
pub fn from_reader(read: &'r mut R) -> Self {
|
2023-07-21 16:15:30 +00:00
|
|
|
Deserializer {
|
|
|
|
read,
|
|
|
|
phantom: PhantomData,
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
impl<'r, 'de, 'a, R: Reader<'de, IOValue>> serde::de::Deserializer<'de>
|
2021-09-14 20:45:12 +00:00
|
|
|
for &'a mut Deserializer<'de, 'r, R>
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
type Error = Error;
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
// Won't support this here -- use value::de::Deserializer for this
|
|
|
|
Err(Error::CannotDeserializeAny)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_bool(self.read.next_boolean()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_i8(self.read.next_i8()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_i16(self.read.next_i16()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_i32(self.read.next_i32()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_i64(self.read.next_i64()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_u8(self.read.next_u8()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_u16(self.read.next_u16()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_u32(self.read.next_u32()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_u64(self.read.next_u64()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-06-30 08:10:38 +00:00
|
|
|
visitor.visit_f32(self.read.next_f32()?)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-06-30 08:10:38 +00:00
|
|
|
visitor.visit_f64(self.read.next_f64()?)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_char(self.read.next_char()?)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
match self.read.next_str()? {
|
|
|
|
Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
|
|
|
|
Cow::Owned(s) => visitor.visit_str(&s),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
self.deserialize_str(visitor)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
match self.read.next_bytestring()? {
|
|
|
|
Cow::Borrowed(bs) => visitor.visit_borrowed_bytes(bs),
|
|
|
|
Cow::Owned(bs) => visitor.visit_bytes(&bs),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_byte_buf(self.read.next_bytestring()?.into_owned())
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
if let Some(mut b) = self.read.open_option()? {
|
2023-07-21 16:15:30 +00:00
|
|
|
self.read
|
|
|
|
.ensure_more_expected(&mut b, &B::Item::RecordField)?;
|
2021-08-02 09:42:48 +00:00
|
|
|
let result = visitor.visit_some(&mut *self)?;
|
|
|
|
self.read.ensure_complete(b, &B::Item::RecordField)?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
} else {
|
2021-08-02 09:42:48 +00:00
|
|
|
Ok(visitor.visit_none::<Error>()?)
|
|
|
|
}
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
let b = self.read.open_simple_record("tuple", Some(0))?;
|
2020-05-27 07:04:55 +00:00
|
|
|
let result = visitor.visit_unit::<Error>()?;
|
2021-08-02 09:42:48 +00:00
|
|
|
self.read.ensure_complete(b, &B::Item::RecordField)?;
|
2020-05-27 07:04:55 +00:00
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_unit_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
let b = self.read.open_simple_record(name, Some(0))?;
|
2020-05-27 07:04:55 +00:00
|
|
|
let result = visitor.visit_unit::<Error>()?;
|
2021-08-02 09:42:48 +00:00
|
|
|
self.read.ensure_complete(b, &B::Item::RecordField)?;
|
2020-05-27 07:04:55 +00:00
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2023-07-21 16:15:30 +00:00
|
|
|
match super::value::magic::transmit_input_value(name, || {
|
|
|
|
Ok(self.read.demand_next(true)?)
|
|
|
|
})? {
|
2020-05-27 07:04:55 +00:00
|
|
|
Some(v) => visitor.visit_u64(v),
|
|
|
|
None => {
|
2021-08-02 09:42:48 +00:00
|
|
|
let mut b = self.read.open_simple_record(name, Some(1))?;
|
2023-07-21 16:15:30 +00:00
|
|
|
self.read
|
|
|
|
.ensure_more_expected(&mut b, &B::Item::RecordField)?;
|
2020-05-27 07:04:55 +00:00
|
|
|
let result = visitor.visit_newtype_struct(&mut *self)?;
|
2021-08-02 09:42:48 +00:00
|
|
|
self.read.ensure_complete(b, &B::Item::RecordField)?;
|
2020-05-27 07:04:55 +00:00
|
|
|
Ok(result)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
|
|
|
{
|
2020-05-27 07:04:55 +00:00
|
|
|
// Hack around serde's model: Deserialize *sets* as sequences,
|
|
|
|
// too, and reconstruct them as Rust Sets on the visitor side.
|
2021-08-02 09:42:48 +00:00
|
|
|
let i = self.read.open_sequence_or_set()?;
|
|
|
|
visitor.visit_seq(Seq::new(self, B::Type::default(), i))
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
let b = self.read.open_simple_record("tuple", Some(len))?;
|
|
|
|
let mut seq = Seq::new(self, b, B::Item::RecordField);
|
2020-05-29 09:07:55 +00:00
|
|
|
let result = visitor.visit_seq(&mut seq)?;
|
|
|
|
seq.skip_remainder()?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_tuple_struct<V>(
|
|
|
|
self,
|
|
|
|
name: &'static str,
|
|
|
|
len: usize,
|
|
|
|
visitor: V,
|
|
|
|
) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
let b = self.read.open_simple_record(name, Some(len))?;
|
|
|
|
let mut seq = Seq::new(self, b, B::Item::RecordField);
|
2020-05-29 09:07:55 +00:00
|
|
|
let result = visitor.visit_seq(&mut seq)?;
|
|
|
|
seq.skip_remainder()?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
|
|
|
{
|
2021-01-06 16:42:02 +00:00
|
|
|
self.read.open_dictionary()?;
|
2021-08-02 09:42:48 +00:00
|
|
|
let mut seq = Seq::new(self, B::Type::default(), B::Item::DictionaryKey);
|
2020-05-29 09:07:55 +00:00
|
|
|
let result = visitor.visit_map(&mut seq)?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_struct<V>(
|
|
|
|
self,
|
|
|
|
name: &'static str,
|
|
|
|
fields: &'static [&'static str],
|
|
|
|
visitor: V,
|
|
|
|
) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
let b = self.read.open_simple_record(name, Some(fields.len()))?;
|
|
|
|
let mut seq = Seq::new(self, b, B::Item::RecordField);
|
2020-05-29 09:07:55 +00:00
|
|
|
let result = visitor.visit_seq(&mut seq)?;
|
|
|
|
seq.skip_remainder()?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_enum<V>(
|
|
|
|
self,
|
|
|
|
_name: &'static str,
|
|
|
|
_variants: &'static [&'static str],
|
|
|
|
visitor: V,
|
|
|
|
) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_enum(self)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
match self.read.next_symbol()? {
|
|
|
|
Cow::Borrowed(s) => visitor.visit_borrowed_str(s),
|
|
|
|
Cow::Owned(s) => visitor.visit_str(&s),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
|
|
|
visitor.visit_none()
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
pub struct Seq<'de, 'r, 'a, R: Reader<'de, IOValue>> {
|
2021-08-02 09:42:48 +00:00
|
|
|
b: B::Type,
|
|
|
|
i: B::Item,
|
2020-05-27 07:04:55 +00:00
|
|
|
de: &'a mut Deserializer<'de, 'r, R>,
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
impl<'de, 'r, 'a, R: Reader<'de, IOValue>> Seq<'de, 'r, 'a, R> {
|
2021-08-02 09:42:48 +00:00
|
|
|
fn new(de: &'a mut Deserializer<'de, 'r, R>, b: B::Type, i: B::Item) -> Self {
|
|
|
|
Seq { b, i, de }
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2020-05-29 09:07:55 +00:00
|
|
|
fn skip_remainder(&mut self) -> Result<()> {
|
2021-08-02 09:42:48 +00:00
|
|
|
while !self.de.read.close_compound(&mut self.b, &self.i)? {
|
|
|
|
self.de.read.skip_value()?;
|
|
|
|
}
|
|
|
|
Ok(())
|
2020-05-29 09:07:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn next_item<T>(&mut self, seed: T) -> Result<Option<T::Value>>
|
|
|
|
where
|
|
|
|
T: DeserializeSeed<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
match self.de.read.close_compound(&mut self.b, &self.i)? {
|
2021-01-06 16:42:02 +00:00
|
|
|
true => Ok(None),
|
|
|
|
false => Ok(Some(seed.deserialize(&mut *self.de)?)),
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
impl<'de, 'r, 'a, R: Reader<'de, IOValue>> SeqAccess<'de> for Seq<'de, 'r, 'a, R> {
|
2020-05-27 07:04:55 +00:00
|
|
|
type Error = Error;
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
|
|
|
|
where
|
|
|
|
T: DeserializeSeed<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
Ok(self.next_item(seed)?)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
impl<'de, 'r, 'a, R: Reader<'de, IOValue>> MapAccess<'de> for Seq<'de, 'r, 'a, R> {
|
2020-05-27 07:04:55 +00:00
|
|
|
type Error = Error;
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
|
|
|
|
where
|
|
|
|
K: DeserializeSeed<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
self.i = B::Item::DictionaryKey;
|
2020-05-27 07:04:55 +00:00
|
|
|
self.next_item(seed)
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
|
|
|
|
where
|
|
|
|
V: DeserializeSeed<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
self.i = B::Item::DictionaryValue;
|
2020-05-27 07:04:55 +00:00
|
|
|
match self.next_item(seed)? {
|
|
|
|
Some(item) => Ok(item),
|
|
|
|
None => Err(Error::MissingItem),
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
impl<'de, 'r, 'a, R: Reader<'de, IOValue>> EnumAccess<'de> for &'a mut Deserializer<'de, 'r, R> {
|
2020-05-27 07:04:55 +00:00
|
|
|
type Error = Error;
|
|
|
|
type Variant = Seq<'de, 'r, 'a, R>;
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
|
|
|
|
where
|
|
|
|
V: DeserializeSeed<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2021-08-02 09:42:48 +00:00
|
|
|
let b = self.read.open_record(None)?;
|
2020-05-27 07:04:55 +00:00
|
|
|
let variant = seed.deserialize(&mut *self)?;
|
2021-08-02 09:42:48 +00:00
|
|
|
Ok((variant, Seq::new(self, b, B::Item::RecordField)))
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2021-09-14 20:45:12 +00:00
|
|
|
impl<'de, 'r, 'a, R: Reader<'de, IOValue>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> {
|
2020-05-27 07:04:55 +00:00
|
|
|
type Error = Error;
|
|
|
|
|
|
|
|
fn unit_variant(mut self) -> Result<()> {
|
2020-05-29 09:07:55 +00:00
|
|
|
self.skip_remainder()
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value>
|
|
|
|
where
|
|
|
|
T: DeserializeSeed<'de>,
|
|
|
|
{
|
2020-05-27 07:04:55 +00:00
|
|
|
match self.next_item(seed)? {
|
|
|
|
None => Err(Error::MissingItem),
|
|
|
|
Some(v) => {
|
2020-05-29 09:07:55 +00:00
|
|
|
self.skip_remainder()?;
|
2020-05-27 07:04:55 +00:00
|
|
|
Ok(v)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn tuple_variant<V>(mut self, _len: usize, visitor: V) -> Result<V::Value>
|
2020-05-29 09:07:55 +00:00
|
|
|
where
|
2023-07-21 16:15:30 +00:00
|
|
|
V: Visitor<'de>,
|
2020-05-29 09:07:55 +00:00
|
|
|
{
|
|
|
|
let result = visitor.visit_seq(&mut self)?;
|
|
|
|
self.skip_remainder()?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
|
2023-07-21 16:15:30 +00:00
|
|
|
fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) -> Result<V::Value>
|
2020-05-29 09:07:55 +00:00
|
|
|
where
|
2023-07-21 16:15:30 +00:00
|
|
|
V: Visitor<'de>,
|
2020-05-27 07:04:55 +00:00
|
|
|
{
|
2020-05-29 09:07:55 +00:00
|
|
|
let result = visitor.visit_seq(&mut self)?;
|
|
|
|
self.skip_remainder()?;
|
|
|
|
Ok(result)
|
2020-05-27 07:04:55 +00:00
|
|
|
}
|
|
|
|
}
|