Add from iterator impl

src/array_string.rs

@@ -295,6 +295,36 @@ impl<const CAP: usize> ArrayString<CAP>
         Ok(())
     }
 
+    pub fn try_push_iterator<I: IntoIterator<Item = char>>(&mut self, value: I) -> Result<(), CapacityError<()>> {
+        let mut len = self.len();
+        let value = value.into_iter();
+        if value.size_hint().0 > self.capacity() - len {
+            return Err(CapacityError::new(()));
+        }
+
+        unsafe {
+            let mut ptr = self.as_mut_ptr().add(self.len());
+            for c in value {
+                let remaining_cap = self.capacity() - len;
+                match encode_utf8(c, ptr, remaining_cap) {
+                    Ok(n) => {
+                        len += n;
+                        ptr = ptr.add(n);
+                    }
+                    Err(_) => return Err(CapacityError::new(())),
+                }
+            }
+            self.set_len(len);
+            Ok(())
+        }
+    }
+
+    pub fn try_from_iterator<I: IntoIterator<Item = char>>(value: I) -> Result<Self, CapacityError<()>> {
+        let mut string = Self::new();
+        string.try_push_iterator(value)?;
+        Ok(string)
+    }
+
     /// Removes the last character from the string and returns it.
     ///
     /// Returns `None` if this `ArrayString` is empty.

tests/tests.rs

@@ -774,3 +774,28 @@ fn test_arraystring_zero_filled_has_some_sanity_checks() {
     assert_eq!(string.as_str(), "\0\0\0\0");
     assert_eq!(string.len(), 4);
 }
+
+#[test]
+fn test_string_collect() {
+    let text = "hello world";
+    let u = ArrayString::<11>::try_from_iterator(text.chars()).unwrap();
+    assert_eq!(u.as_str(), text);
+    assert_eq!(u.len(), text.len());
+}
+
+#[test]
+fn test_string_collect_seveal_times() {
+    let text = "hello world";
+    let mut u = ArrayString::<22>::try_from_iterator(text.chars()).unwrap();
+    u.try_push_iterator(text.chars()).unwrap();
+    assert_eq!(u.as_str(), &format!("{}{}", text, text));
+    assert_eq!(u.len(), text.len()*2);
+}
+
+
+#[test]
+fn test_string_collect_error_on_overflow() {
+    let text = "hello world";
+    ArrayString::<10>::try_from_iterator(text.chars()).unwrap_err();
+}
+