Update to account for changes made in 0.4.1

1 files changed, 37 insertions, 12 deletions

diff --git a/src/framework/standard/args.rs b/src/framework/standard/args.rs
index 30264b3..f59908a 100644
--- a/src/framework/standard/args.rs
+++ b/src/framework/standard/args.rs
@@ -53,6 +53,10 @@ impl<E: StdError> fmt::Display for Error<E> {
 
 type Result<T, E> = ::std::result::Result<T, Error<E>>;
 
+/// A utility struct for handling arguments of a command.
+///
+/// General functionality is done via removing an item, parsing it, then returning it; this however
+/// can be mitigated with the `*_n` methods, which just parse and return.
 #[derive(Clone, Debug)]
 pub struct Args {
     delimiter: String,
@@ -116,10 +120,7 @@ impl Args {
         let mut vec = Vec::with_capacity(i as usize);
 
         for _ in 0..i {
-            vec.push(match self.delimiter_split.shift() {
-                Some(x) => x,
-                None => return None,
-            });
+            vec.push(try_opt!(self.delimiter_split.shift()));
         }
 
         Some(vec)
@@ -161,16 +162,14 @@ impl Args {
     }
 
     /// Empty outs the internal vector while parsing (if necessary) and returning them
-    pub fn list<T: FromStr>(self) -> Result<Vec<T>, T::Err>
+    pub fn list<T: FromStr>(mut self) -> Result<Vec<T>, T::Err>
         where T::Err: StdError {
-        if self.delimiter_split.is_empty() {
-            return Err(Error::Eos);
-        }
+        Iter::<T>::new(&mut self).collect()
+    }
 
-        self.delimiter_split
-            .into_iter()
-            .map(|s| s.parse::<T>().map_err(Error::Parse))
-            .collect()
+    /// Provides an iterator of items: (`T: FromStr`) `Result<T, T::Err>`.
+    pub fn iter<T: FromStr>(&mut self) -> Iter<T> where T::Err: StdError  {
+        Iter::new(self)
     }
 
     /// This method is just `internal_vector.join(delimiter)`
@@ -221,3 +220,29 @@ impl ::std::ops::Deref for Args {
 
     fn deref(&self) -> &Self::Target { &self.delimiter_split }
 }
+
+use std::marker::PhantomData;
+
+/// Provides `list`'s functionality, but as an iterator.
+pub struct Iter<'a, T: FromStr> where T::Err: StdError {
+    args: &'a mut Args,
+    _marker: PhantomData<T>,
+}
+
+impl<'a, T: FromStr> Iter<'a, T> where T::Err: StdError {
+    fn new(args: &'a mut Args) -> Self {
+        Iter { args, _marker: PhantomData }
+    }
+}
+
+impl<'a, T: FromStr> Iterator for Iter<'a, T> where T::Err: StdError  {
+    type Item = Result<T, T::Err>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.args.is_empty() {
+            None
+        } else {
+            Some(self.args.single::<T>())
+        }
+    }
+}