Iterating over Ini yields "Section" type instead of "SectionIter" (2.0 - breaking change)

src/lib.rs

@@ -68,7 +68,7 @@ impl Ini {
         Ini { document: OrderedHashMap::new(), last_section_name: String::new(), empty_section: Section::new() }
     }
 
-    /// Private construct method which creaate [Ini] struct from input string
+    /// Private construct method which create [Ini] struct from input string
     fn parse(string: &str) -> Result<Ini, Error> {
         let mut result = Ini::new();
         for (index, line) in string.lines().enumerate() {
@@ -251,6 +251,7 @@ impl Ini {
         self.document
             .entry(self.last_section_name.clone())
             .or_insert_with(Section::new)
+            .inner
             .insert(name.into(), value.to_string());
         self
     }
@@ -405,7 +406,7 @@ impl Ini {
 
     /// Private method which get value by `key` from `section`
     fn get_raw(&self, section: &str, key: &str) -> Option<&String> {
-        self.document.get(section).and_then(|s| s.get(key))
+        self.document.get(section).and_then(|s| s.get_raw(key))
     }
 
     /// Get scalar value of key in section.
@@ -473,7 +474,7 @@ impl Ini {
             .and_then(|x| x.split(sep).map(|s| s.trim().parse()).collect::<Result<Vec<T>, _>>().ok())
     }
 
-    /// An iterator visiting all key-value pairs in order of appearance in section.
+    /// An iterator visiting all key-value pairs of a section in order of appearance.
     ///
     /// If section with given name doesn't exist in document, method returns empty iterator
     ///
@@ -492,13 +493,11 @@ impl Ini {
     /// assert_eq!(conf.section_iter("absent").count(), 0);
     /// ```
     pub fn section_iter(&self, section: &str) -> SectionIter {
-        let section = self.document.get(section).unwrap_or(&self.empty_section);
-        SectionIter { document: &section, iter: section.iter() }
+        self.document.get(section).unwrap_or(&self.empty_section).iter()
     }
 
-    /// Iterate over all sections in order of appearance, yielding pairs of
-    /// section name and iterator over the section elements. The iterator
-    /// element type is `(&'a String, SectionIter<'a>)`.
+    /// Iterate over all sections in order of appearance, yielding pairs of section name
+    /// and section instance, which can be iterated over or queried similarly to Ini instances.
     ///
     /// # Example
     /// ```
@@ -509,10 +508,10 @@ impl Ini {
     ///                      .section("bar")
     ///                      .item("one", "1");
     ///
-    /// for (name, section_iter) in conf.iter() {
+    /// for (name, section) in conf.iter() {
     ///     match name.as_str() {
-    ///         "foo" => assert_eq!(section_iter.count(), 2),
-    ///         "bar" => assert_eq!(section_iter.count(), 1),
+    ///         "foo" => assert_eq!(section.iter().count(), 2),
+    ///         "bar" => assert_eq!(section.iter().count(), 1),
     ///         _ => assert!(false),
     ///     }
     /// }
@@ -533,14 +532,14 @@ impl Ini {
     ///                          .section("bar")
     ///                          .item("one", "1");
     ///
-    /// for (name, section_iter) in conf.iter_mut() {
-    ///     for (key, val) in section_iter {
+    /// for (name, section) in conf.iter_mut() {
+    ///     for (key, val) in section.iter_mut() {
     ///         *val = String::from("replaced");
     ///     }
     /// }
     ///
-    /// for (name, section_iter) in conf.iter() {
-    ///     for (key, val) in section_iter {
+    /// for (name, section) in conf.iter() {
+    ///     for (key, val) in section.iter() {
     ///         assert_eq!(val.as_str(), "replaced");
     ///     }
     /// }
@@ -556,7 +555,7 @@ impl fmt::Display for Ini {
             // insert section block
             items.push(format!("[{}]", name));
             // add items
-            for (key, value) in section {
+            for (key, value) in section.iter() {
                 items.push(format!("{} = {}", key, value));
             }
             // and blank line between sections
@@ -572,54 +571,74 @@ impl Default for Ini {
     }
 }
 
-/// An iterator over the sections of an ini documet
+/// An iterator over the sections of an ini document
 pub struct IniIter<'a> {
     #[doc(hidden)]
     iter: ordered_hashmap::Iter<'a, String, Section>,
 }
 
 impl<'a> Iterator for IniIter<'a> {
-    type Item = (&'a String, SectionIter<'a>);
+    type Item = (&'a String, &'a Section);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(|(name, section)| (name, SectionIter { document: &section, iter: section.iter() }))
+        self.iter.next()
     }
 }
 
-/// A mutable iterator over the sections of an ini documet
+/// A mutable iterator over the sections of an ini document
 pub struct IniIterMut<'a> {
     #[doc(hidden)]
     iter: ordered_hashmap::IterMut<'a, String, Section>,
 }
 
 impl<'a> Iterator for IniIterMut<'a> {
-    type Item = (&'a String, SectionIterMut<'a>);
+    type Item = (&'a String, &'a mut Section);
 
     #[inline]
     fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next().map(|(name, section)| (name, SectionIterMut { iter: section.iter_mut() }))
+        self.iter.next()
     }
 }
 
-type Section = OrderedHashMap<String, String>;
+#[derive(Debug)]
+pub struct Section {
+    inner: OrderedHashMap<String, String>
+}
 
-/// An iterator over the entries of a section
 pub struct SectionIter<'a> {
     #[doc(hidden)]
-    document: &'a Section,
     iter: ordered_hashmap::Iter<'a, String, String>,
 }
 
 impl<'a> Iterator for SectionIter<'a> {
     type Item = (&'a String, &'a String);
 
+    #[inline]
     fn next(&mut self) -> Option<Self::Item> {
         self.iter.next()
     }
 }
 
-impl<'a> SectionIter<'a> {
+pub struct SectionIterMut<'a> {
+    #[doc(hidden)]
+    iter: ordered_hashmap::IterMut<'a, String, String>,
+}
+
+impl<'a> Iterator for SectionIterMut<'a> {
+    type Item = (&'a String, &'a mut String);
+
+    #[inline]
+    fn next(&mut self) -> Option<Self::Item> {
+        self.iter.next()
+    }
+}
+
+impl Section {
+    pub fn new() -> Self {
+        Section { inner: OrderedHashMap::new() }
+    }
+
     /// Get scalar value of key
     ///
     /// - output type `T` must implement [FromStr] trait for auto conversion
@@ -636,28 +655,35 @@ impl<'a> SectionIter<'a> {
     ///     assert_eq!(value, Some(2));
     /// }
     /// ```
-    pub fn get<T>(&'a self, key: &str) -> Option<T>
+    pub fn get<'a, T>(&'a self, key: &str) -> Option<T>
     where
-        T: FromStr,
+        T: FromStr
     {
-        self.document.get(key).and_then(|x| x.parse().ok())
+        self.inner.get(key).and_then(|x| x.parse().ok())
     }
-}
 
-/// A mutable iterator over the entries of a section
-pub struct SectionIterMut<'a> {
-    #[doc(hidden)]
-    iter: ordered_hashmap::IterMut<'a, String, String>,
-}
+    pub fn get_raw<'a>(&'a self, key: &str) -> Option<&String> {
+        self.inner.get(key)
+    }
 
-impl<'a> Iterator for SectionIterMut<'a> {
-    type Item = (&'a String, &'a mut String);
+    pub fn remove(&mut self, key: &str) -> Option<String> {
+        self.inner.remove(key)
+    }
 
-    fn next(&mut self) -> Option<Self::Item> {
-        self.iter.next()
+    pub fn insert(&mut self, key: String, value: String) {
+        self.inner.insert(key, value);
+    }
+
+    pub fn iter(&self) -> SectionIter {
+        SectionIter { iter: self.inner.iter() }
+    }
+
+    pub fn iter_mut(&mut self) -> SectionIterMut {
+        SectionIterMut { iter: self.inner.iter_mut() }
     }
 }
 
+
 #[cfg(test)]
 mod library_test {
     use super::*;
@@ -748,4 +774,28 @@ mod library_test {
         assert_eq!(["c", "b", "a"], keys[..]);
         Ok(())
     }
+
+    #[test]
+    fn random_access_section() -> Result<(), Error> {
+        let ini = Ini::from_string("[a]\nc = 1\nb = 2\na = 3\n\n[b]\na = 1\nb = 2\nc = 3\n\n[c]\na=0\nd=4")?;
+        for (name, section) in ini.iter() {
+            match name.as_str() {
+                "a" => {
+                    assert_eq!(section.get_raw("a"), Some(&"3".to_owned()));
+                    assert_eq!(section.get_raw("d"), None);
+                },
+                "b" => {
+                    assert_eq!(section.get_raw("a"), Some(&"1".to_owned()));
+                    assert_eq!(section.get_raw("d"), None);
+                },
+                "c" => {
+                    assert_eq!(section.get_raw("a"), Some(&"0".to_owned()));
+                    assert_eq!(section.get_raw("b"), None);
+                    assert_eq!(section.get_raw("d"), Some(&"4".to_owned()));
+                },
+                _ => unreachable!()
+            }
+        }
+        Ok(())
+    }
 }

src/ordered_hashmap.rs

@@ -250,17 +250,6 @@ where
     }
 }
 
-impl<K, V> IntoIterator for OrderedHashMap<K, V>
-where
-    K: Eq + Hash,
-{
-    type Item = (K, V);
-    type IntoIter = IntoIter<K, V>;
-
-    fn into_iter(self) -> Self::IntoIter {
-        IntoIter { base: self.base, keys_iterator: self.keys.into_iter() }
-    }
-}
 
 impl<K, V> FromIterator<(K, V)> for OrderedHashMap<K, V>
 where