Struct IgnoredAny

pub struct IgnoredAny;

An efficient way of discarding data from a deserializer.

Think of this like serde_json::Value in that it can be deserialized from any type, except that it does not store any information about the data that gets deserialized.

use serde::de::{
    self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
};
use std::fmt;
use std::marker::PhantomData;

/// A seed that can be used to deserialize only the `n`th element of a sequence
/// while efficiently discarding elements of any type before or after index `n`.
///
/// For example to deserialize only the element at index 3:
///
/// ```
/// NthElement::new(3).deserialize(deserializer)
/// ```
pub struct NthElement<T> {
    n: usize,
    marker: PhantomData<T>,
}

impl<T> NthElement<T> {
    pub fn new(n: usize) -> Self {
        NthElement {
            n: n,
            marker: PhantomData,
        }
    }
}

impl<'de, T> Visitor<'de> for NthElement<T>
where
    T: Deserialize<'de>,
{
    type Value = T;

    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
        write!(
            formatter,
            "a sequence in which we care about element {}",
            self.n
        )
    }

    fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
    where
        A: SeqAccess<'de>,
    {
        // Skip over the first `n` elements.
        for i in 0..self.n {
            // It is an error if the sequence ends before we get to element `n`.
            if seq.next_element::<IgnoredAny>()?.is_none() {
                return Err(de::Error::invalid_length(i, &self));
            }
        }

        // Deserialize the one we care about.
        let nth = match seq.next_element()? {
            Some(nth) => nth,
            None => {
                return Err(de::Error::invalid_length(self.n, &self));
            }
        };

        // Skip over any remaining elements in the sequence after `n`.
        while let Some(IgnoredAny) = seq.next_element()? {
            // ignore
        }

        Ok(nth)
    }
}

impl<'de, T> DeserializeSeed<'de> for NthElement<T>
where
    T: Deserialize<'de>,
{
    type Value = T;

    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
    where
        D: Deserializer<'de>,
    {
        deserializer.deserialize_seq(self)
    }
}

# fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
# where
#     D: Deserializer<'de>,
# {
// Deserialize only the sequence element at index 3 from this deserializer.
// The element at index 3 is required to be a string. Elements before and
// after index 3 are allowed to be of any type.
let s: String = NthElement::new(3).deserialize(deserializer)?;
#     Ok(())
# }

Trait Implementations

impl Clone for IgnoredAny

fn clone(&self) -> IgnoredAny

impl Copy for IgnoredAny

impl Debug for IgnoredAny

fn fmt(&self, f: &mut Formatter<'_>) -> Result

impl Default for IgnoredAny

fn default() -> IgnoredAny

impl PartialEq for IgnoredAny

fn eq(&self, other: &IgnoredAny) -> bool

impl StructuralPartialEq for IgnoredAny

impl<'de> Deserialize<'de> for IgnoredAny

fn deserialize<D>(deserializer: D) -> Result<IgnoredAny, D::Error>
where
    D: Deserializer<'de>,

impl<'de> Visitor<'de> for IgnoredAny

type Value = IgnoredAny;
fn expecting(&self, formatter: &mut Formatter<'_>) -> Result
fn visit_bool<E>(self, x: bool) -> Result<Self::Value, E>
fn visit_i64<E>(self, x: i64) -> Result<Self::Value, E>
fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E>
fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E>
fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E>
fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E>
fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
where
    E: Error,
fn visit_none<E>(self) -> Result<Self::Value, E>
fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
    D: Deserializer<'de>,
fn visit_newtype_struct<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
where
    D: Deserializer<'de>,
fn visit_unit<E>(self) -> Result<Self::Value, E>
fn visit_seq<A>(self, seq: A) -> Result<Self::Value, A::Error>
where
    A: SeqAccess<'de>,
fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
where
    A: MapAccess<'de>,
fn visit_bytes<E>(self, bytes: &[u8]) -> Result<Self::Value, E>
where
    E: Error,
fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
where
    A: EnumAccess<'de>,

Auto Trait Implementations

impl Freeze for IgnoredAny

impl RefUnwindSafe for IgnoredAny

impl Send for IgnoredAny

impl Sync for IgnoredAny

impl Unpin for IgnoredAny

impl UnsafeUnpin for IgnoredAny

impl UnwindSafe for IgnoredAny

Blanket Implementations

impl<'de, T> Expected for IgnoredAny where T: Visitor<'de>,

fn fmt(&self, formatter: &mut Formatter<'_>) -> Result

impl<T> Any for IgnoredAny where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for IgnoredAny where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for IgnoredAny where T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T> CloneToUninit for IgnoredAny where T: Clone,

unsafe fn clone_to_uninit(&self, dest: *mut u8)

impl<T> DeserializeOwned for IgnoredAny where T: for<'de> Deserialize<'de>,

impl<T> From<T> for IgnoredAny

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for IgnoredAny where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for IgnoredAny where U: From<T>,

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom<U> for IgnoredAny where U: Into<T>,

type Error = Infallible;
fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for IgnoredAny where U: TryFrom<T>,

type Error = <U as TryFrom<T>>::Error;
fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>