Merge module seq into module map because of it size

Author: Mingun

src/de/map.rs

@@ -2,9 +2,9 @@
 
 use crate::{
     de::key::QNameDeserializer,
-    de::seq::{not_in, TagFilter},
     de::simple_type::SimpleTypeDeserializer,
     de::{str2bool, DeEvent, Deserializer, XmlRead, TEXT_KEY, VALUE_KEY},
+    encoding::Decoder,
     errors::serialize::DeError,
     events::attributes::IterState,
     events::BytesStart,
@@ -144,6 +144,8 @@ enum ValueSource {
     Nested,
 }
 
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /// A deserializer that extracts map-like structures from an XML. This deserializer
 /// represents a one XML tag:
 ///
@@ -549,6 +551,72 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
+/// Check if tag `start` is included in the `fields` list. `decoder` is used to
+/// get a string representation of a tag.
+///
+/// Returns `true`, if `start` is not in the `fields` list and `false` otherwise.
+fn not_in(
+    fields: &'static [&'static str],
+    start: &BytesStart,
+    decoder: Decoder,
+) -> Result<bool, DeError> {
+    let tag = decoder.decode(start.name().into_inner())?;
+
+    Ok(fields.iter().all(|&field| field != tag.as_ref()))
+}
+
+/// A filter that determines, what tags should form a sequence.
+///
+/// There are two types of sequences:
+/// - sequence where each element represented by tags with the same name
+/// - sequence where each element can have a different tag
+///
+/// The first variant could represent a collection of structs, the second --
+/// a collection of enum variants.
+///
+/// In the second case we don't know what tag name should be expected as a
+/// sequence element, so we accept any element. Since the sequence are flattened
+/// into maps, we skip elements which have dedicated fields in a struct by using an
+/// `Exclude` filter that filters out elements with names matching field names
+/// from the struct.
+///
+/// # Lifetimes
+///
+/// `'de` represents a lifetime of the XML input, when filter stores the
+/// dedicated tag name
+#[derive(Debug)]
+enum TagFilter<'de> {
+    /// A `SeqAccess` interested only in tags with specified name to deserialize
+    /// an XML like this:
+    ///
+    /// ```xml
+    /// <...>
+    ///   <tag/>
+    ///   <tag/>
+    ///   <tag/>
+    ///   ...
+    /// </...>
+    /// ```
+    ///
+    /// The tag name is stored inside (`b"tag"` for that example)
+    Include(BytesStart<'de>), //TODO: Need to store only name instead of a whole tag
+    /// A `SeqAccess` interested in tags with any name, except explicitly listed.
+    /// Excluded tags are used as struct field names and therefore should not
+    /// fall into a `$value` category
+    Exclude(&'static [&'static str]),
+}
+
+impl<'de> TagFilter<'de> {
+    fn is_suitable(&self, start: &BytesStart, decoder: Decoder) -> Result<bool, DeError> {
+        match self {
+            Self::Include(n) => Ok(n.name() == start.name()),
+            Self::Exclude(fields) => not_in(fields, start, decoder),
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
 /// 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
@@ -750,3 +818,20 @@ where
         self.map.de.is_human_readable()
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////////////////////////
+
+#[test]
+fn test_not_in() {
+    let tag = BytesStart::new("tag");
+
+    assert_eq!(not_in(&[], &tag, Decoder::utf8()).unwrap(), true);
+    assert_eq!(
+        not_in(&["no", "such", "tags"], &tag, Decoder::utf8()).unwrap(),
+        true
+    );
+    assert_eq!(
+        not_in(&["some", "tag", "included"], &tag, Decoder::utf8()).unwrap(),
+        false
+    );
+}

src/de/mod.rs

@@ -333,7 +333,6 @@ macro_rules! deserialize_primitives {
 mod escape;
 mod key;
 mod map;
-mod seq;
 mod simple_type;
 mod var;