Struct MapValueSeqAccess 

struct MapValueSeqAccess<'de, 'd, 'm, R, E>
where
    R: XmlRead<'de>,
    E: EntityResolver,
{
    map: &'m mut ElementMapAccess<'de, 'd, R, E>,
    filter: TagFilter<'de>,
    checkpoint: usize,
}

An accessor to sequence elements forming a value for struct field. Technically, this sequence is flattened out into structure and sequence elements are overlapped with other fields of a structure. Each call to Self::next_element_seed consumes a next sub-tree or consequent list of Text and CData events.

<>
  ...
  <item>The is the one item</item>
  This is <![CDATA[one another]]> item<!-- even when--> it splitted by comments
  <tag>...and that is the third!</tag>
  ...
</>

Depending on Self::filter, only some of that possible constructs would be an element.

Fields

map: &'m mut ElementMapAccess<'de, 'd, R, E>

Accessor to a map that creates this accessor and to a deserializer for a sequence items.

filter: TagFilter<'de>

Filter that determines whether a tag is a part of this sequence.

When feature overlapped-lists is not activated, iteration will stop when found a tag that does not pass this filter.

When feature overlapped-lists is activated, all tags, that not pass this check, will be skipped.

checkpoint: usize

Checkpoint after which all skipped events should be returned. All events, that was skipped before creating this checkpoint, will still stay buffered and will not be returned

Trait Implementations

impl<'de, 'd, 'm, R, E> Drop for MapValueSeqAccess<'de, 'd, 'm, R, E>

where R: XmlRead<'de>, E: EntityResolver,

fn drop(&mut self)

Executes the destructor for this type.

impl<'de, 'd, 'm, R, E> SeqAccess<'de> for MapValueSeqAccess<'de, 'd, 'm, R, E>

where R: XmlRead<'de>, E: EntityResolver,

type Error = DeError

The error type that can be returned if some error occurs during deserialization.

fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, DeError>

where T: DeserializeSeed<'de>,

This returns Ok(Some(value)) for the next value in the sequence, or Ok(None) if there are no more remaining items.

fn next_element<T>(&mut self) -> Result<Option<T>, Self::Error>

where T: Deserialize<'de>,

This returns Ok(Some(value)) for the next value in the sequence, or Ok(None) if there are no more remaining items.

fn size_hint(&self) -> Option<usize>

Returns the number of elements remaining in the sequence, if known.