itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 23:35:26 +00:00
Code Issues Packages Projects Releases Wiki Activity

Remove FlatInternallyTaggedAccess because it is the same as FlatMapAccess

Browse Source
This commit is contained in:
Mingun 2023-05-08 09:25:18 +05:00
parent 25381be0c9
commit c399e9c368
1 changed files with 5 additions and 47 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

52
serde/src/private/de.rs
View File

@ -2738,11 +2738,7 @@ where
where where
V: Visitor<'de>, V: Visitor<'de>,
{ {
visitor.visit_map(FlatInternallyTaggedAccess { self.deserialize_map(visitor)
iter: self.0.iter_mut(),
pending: None,
_marker: PhantomData,
})
} }
fn deserialize_enum<V>( fn deserialize_enum<V>(
@ -2878,6 +2874,10 @@ where
for item in &mut self.iter { for item in &mut self.iter {
// Items in the vector are nulled out when used by a struct. // Items in the vector are nulled out when used by a struct.
if let Some((ref key, ref content)) = *item { if let Some((ref key, ref content)) = *item {
// Do not take(), instead borrow this entry. The internally tagged
// enum does its own buffering so we can't tell whether this entry
// is going to be consumed. Borrowing here leaves the entry
// available for later flattened fields.
self.pending_content = Some(content); self.pending_content = Some(content);
return seed.deserialize(ContentRefDeserializer::new(key)).map(Some); return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
} }
@ -2958,45 +2958,3 @@ where
} }
} }
} }
#[cfg(any(feature = "std", feature = "alloc"))]
pub struct FlatInternallyTaggedAccess<'a, 'de: 'a, E> {
iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
pending: Option<&'a Content<'de>>,
_marker: PhantomData<E>,
}
#[cfg(any(feature = "std", feature = "alloc"))]
impl<'a, 'de, E> MapAccess<'de> for FlatInternallyTaggedAccess<'a, 'de, E>
where
E: Error,
{
type Error = E;
fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
where
T: DeserializeSeed<'de>,
{
for item in &mut self.iter {
if let Some((ref key, ref content)) = *item {
// Do not take(), instead borrow this entry. The internally tagged
// enum does its own buffering so we can't tell whether this entry
// is going to be consumed. Borrowing here leaves the entry
// available for later flattened fields.
self.pending = Some(content);
return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
}
}
Ok(None)
}
fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
where
T: DeserializeSeed<'de>,
{
match self.pending.take() {
Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
None => panic!("value is missing"),
}
}
}