Method deserialize_map

src/serde/de.rs:392–465

(mut self, v: V)

    }

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

        struct Access<'a, 'de> {
            decoders: &'a mut (SerdeDecoder<'de>, SerdeDecoder<'de>),
            input: &'a mut &'de [u8],
            len: usize,
            key_deserialized: bool,
        }

        impl<'de> MapAccess<'de> for Access<'_, 'de> {
            type Error = Error;

            #[inline(always)]
            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
            where
                K: DeserializeSeed<'de>,
            {
                guard_zst::<K::Value>(self.len)?;
                if self.len != 0 {
                    self.len -= 1;
                    // Safety: Make sure next_value_seed is called at most once after each len decrement.
                    // We don't care if DeserializeSeed fails after this (not critical to safety).
                    self.key_deserialized = true;
                    Ok(Some(DeserializeSeed::deserialize(
                        seed,
                        DecoderWrapper {
                            decoder: &mut self.decoders.0,
                            input: &mut *self.input,
                        },
                    )?))
                } else {
                    Ok(None)
                }
            }

            #[inline(always)]
            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
            where
                V: DeserializeSeed<'de>,
            {
                // Safety: Make sure next_value_seed is called at most once after each len decrement
                // since only len values exist.
                assert!(
                    std::mem::take(&mut self.key_deserialized),
                    "next_value_seed before next_key_seed"
                );
                DeserializeSeed::deserialize(
                    seed,
                    DecoderWrapper {
                        decoder: &mut self.decoders.1,
                        input: &mut *self.input,
                    },
                )