Method deserialize_seq

src/serde/de.rs:255–301

(mut self, v: V)

    }

    fn deserialize_seq<V>(mut self, v: V) -> Result<V::Value>
    where
        V: Visitor<'de>,
    {
        let (length_decoder, decoder) = specify!(self, Seq);
        let len = length_decoder.decode();

        struct Access<'a, 'de> {
            wrapper: DecoderWrapper<'a, 'de>,
            len: usize,
        }
        impl<'de> SeqAccess<'de> for Access<'_, 'de> {
            type Error = Error;

            #[inline(always)]
            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
            where
                T: DeserializeSeed<'de>,
            {
                guard_zst::<T::Value>(self.len)?;
                if self.len != 0 {
                    self.len -= 1;
                    Ok(Some(DeserializeSeed::deserialize(
                        seed,
                        DecoderWrapper {
                            decoder: &mut *self.wrapper.decoder,
                            input: &mut *self.wrapper.input,
                        },
                    )?))
                } else {
                    Ok(None)
                }
            }

            #[inline(always)]
            fn size_hint(&self) -> Option<usize> {
                Some(self.len)
            }
        }
        v.visit_seq(Access {
            wrapper: DecoderWrapper {
                decoder,
                input: self.input,
            },
            len,
        })
    }

    #[inline(always)]
    fn deserialize_tuple<V>(mut self, tuple_len: usize, v: V) -> Result<V::Value>