pub fn iter(&self) -> impl Iterator<Item = (&Name, &BytesStr)> + '_ {
        struct Iter<'s> {
            entries: slice::Iter<'s, Entry>,
            current: Option<(&'s Name, slice::Iter<'s, BytesStr>)>,
        }

        impl<'s> Iterator for Iter<'s> {
            type Item = (&'s Name, &'s BytesStr);

            fn next(&mut self) -> Option<Self::Item> {
                if let Some((name, iter)) = &mut self.current {
                    if let Some(val) = iter.next() {
                        return Some((name, val));
                    } else {
                        self.current = None;
                    }
                }

                let entry = self.entries.next()?;

                match &entry.values {
                    Values::One(val) => Some((&entry.name, val)),
                    Values::Many(values) => {
                        let mut iter = values.iter();
                        let ret = iter.next().expect("empty vec in values");

                        self.current = Some((&entry.name, iter));

                        Some((&entry.name, ret))
                    }
                }
            }
        }

        Iter {
            entries: self.entries.iter(),
            current: None,
        }
    }
/// Returns an iterator over [Name] and [BytesStr] pairs in the map.
Returns an iterator over [Name] and [BytesStr] pairs in the map.
Returns an iterator over [ Name ] and [ BytesStr ] pairs in the map .
pub fn iter(&self) -> impl Iterator<Item = (&Name, &BytesStr)> + '_ {
        struct Iter<'s> {
            entries: slice::Iter<'s, Entry>,
            current: Option<(&'s Name, slice::Iter<'s, BytesStr>)>,
        }
        impl<'s> Iterator for Iter<'s> {
            type Item = (&'s Name, &'s BytesStr);
            fn next(&mut self) -> Option<Self::Item> {
                if let Some((name, iter)) = &mut self.current {
                    if let Some(val) = iter.next() {
                        return Some((name, val));
                    } else {
                        self.current = None;
                    }
                }
                let entry = self.entries.next()?;
                match &entry.values {
                    Values::One(val) => Some((&entry.name, val)),
                    Values::Many(values) => {
                        let mut iter = values.iter();
                        let ret = iter.next().expect("empty vec in values");
                        self.current = Some((&entry.name, iter));
                        Some((&entry.name, ret))
                    }
                }
            }
        }
        Iter {
            entries: self.entries.iter(),
            current: None,
        }
    }
pub fn iter ( & self ) -> impl Iterator < Item = ( & Name , & BytesStr ) > + ' _ { struct Iter < ' s > { entries : slice :: Iter < ' s , Entry > , current : Option < ( & ' s Name , slice :: Iter < ' s , BytesStr > ) > , } impl < ' s > Iterator for Iter < ' s > { type Item = ( & ' s Name , & ' s BytesStr ) ; fn next ( & mut self ) -> Option < Self :: Item > { if let Some ( ( name , iter ) ) = & mut self . current { if let Some ( val ) = iter . next ( ) { return Some ( ( name , val ) ) ; } else { self . current = None ; } } let entry = self . entries . next ( ) ? ; match & entry . values { Values :: One ( val ) => Some ( ( & entry . name , val ) ) , Values :: Many ( values ) => { let mut iter = values . iter ( ) ; let ret = iter . next ( ) . expect ( " " ) ; self . current = Some ( ( & entry . name , iter ) ) ; Some ( ( & entry . name , ret ) ) } } } } Iter { entries : self . entries . iter ( ) , current : None , } }
Returns an iterator over [Name] and [BytesStr] pairs in the map.
Returns an iterator over [ Name ] and [ BytesStr ] pairs in the map .
&self