Add opts_present_any() and opts_str_first() interface functions

They work similar to opts_present() and opts_str() but accept a generic
iterator over string slices for the "names" argument.

Note that in contrast to opts_present() the opts_present_any() function
does panic on unknown option names for symmetry with opt_present().

Author: t-rapp

src/lib.rs

@@ -828,6 +828,41 @@ impl Matches {
             })
     }
 
+    /// Returns true if any of several options were matched.
+    ///
+    /// Similar to `opts_present` but accepts any argument that can be converted
+    /// into an iterator over string references.
+    ///
+    /// # Panics
+    ///
+    /// This function might panic if some option name is not defined.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use getopts::Options;
+    /// let mut opts = Options::new();
+    /// opts.optopt("a", "alpha", "first option", "STR");
+    /// opts.optopt("b", "beta", "second option", "STR");
+    ///
+    /// let args = vec!["-a", "foo"];
+    /// let matches = &match opts.parse(&args) {
+    ///     Ok(m) => m,
+    ///     _ => panic!(),
+    /// };
+    ///
+    /// assert!(matches.opts_present_any(&["alpha"]));
+    /// assert!(!matches.opts_present_any(&["beta"]));
+    /// ```
+    pub fn opts_present_any<C: IntoIterator>(&self, names: C) -> bool
+    where
+        C::Item: AsRef<str>,
+    {
+        names
+            .into_iter()
+            .any(|nm| !self.opt_vals(nm.as_ref()).is_empty())
+    }
+
     /// Returns the string argument supplied to one of several matching options or `None`.
     pub fn opts_str(&self, names: &[String]) -> Option<String> {
         names
@@ -839,6 +874,46 @@ impl Matches {
             .next()
     }
 
+    /// Returns the string argument supplied to the first matching option of
+    /// several options or `None`.
+    ///
+    /// Similar to `opts_str` but accepts any argument that can be converted
+    /// into an iterator over string references.
+    ///
+    /// # Panics
+    ///
+    /// This function might panic if some option name is not defined.
+    ///
+    /// # Example
+    ///
+    /// ```
+    /// # use getopts::Options;
+    /// let mut opts = Options::new();
+    /// opts.optopt("a", "alpha", "first option", "STR");
+    /// opts.optopt("b", "beta", "second option", "STR");
+    ///
+    /// let args = vec!["-a", "foo", "--beta", "bar"];
+    /// let matches = &match opts.parse(&args) {
+    ///     Ok(m) => m,
+    ///     _ => panic!(),
+    /// };
+    ///
+    /// assert_eq!(Some("foo".to_string()), matches.opts_str_first(&["alpha", "beta"]));
+    /// assert_eq!(Some("bar".to_string()), matches.opts_str_first(&["beta", "alpha"]));
+    /// ```
+    pub fn opts_str_first<C: IntoIterator>(&self, names: C) -> Option<String>
+    where
+        C::Item: AsRef<str>,
+    {
+        names
+            .into_iter()
+            .filter_map(|nm| match self.opt_val(nm.as_ref()) {
+                Some(Val(s)) => Some(s),
+                _ => None,
+            })
+            .next()
+    }
+
     /// Returns a vector of the arguments provided to all matches of the given
     /// option.
     ///

src/tests/mod.rs

@@ -626,6 +626,7 @@ fn test_multi() {
     opts.optopt("e", "", "encrypt", "ENCRYPT");
     opts.optopt("", "encrypt", "encrypt", "ENCRYPT");
     opts.optopt("f", "", "flag", "FLAG");
+    let no_opts: &[&str] = &[];
 
     let args_single = vec!["-e".to_string(), "foo".to_string()];
     let matches_single = &match opts.parse(&args_single) {
@@ -639,6 +640,12 @@ fn test_multi() {
     assert!(!matches_single.opts_present(&["thing".to_string()]));
     assert!(!matches_single.opts_present(&[]));
 
+    assert!(matches_single.opts_present_any(&["e"]));
+    assert!(matches_single.opts_present_any(&["encrypt", "e"]));
+    assert!(matches_single.opts_present_any(&["e", "encrypt"]));
+    assert!(!matches_single.opts_present_any(&["encrypt"]));
+    assert!(!matches_single.opts_present_any(no_opts));
+
     assert_eq!(matches_single.opts_str(&["e".to_string()]).unwrap(), "foo");
     assert_eq!(
         matches_single
@@ -653,6 +660,18 @@ fn test_multi() {
         "foo"
     );
 
+    assert_eq!(matches_single.opts_str_first(&["e"]).unwrap(), "foo");
+    assert_eq!(
+        matches_single.opts_str_first(&["e", "encrypt"]).unwrap(),
+        "foo"
+    );
+    assert_eq!(
+        matches_single.opts_str_first(&["encrypt", "e"]).unwrap(),
+        "foo"
+    );
+    assert_eq!(matches_single.opts_str_first(&["encrypt"]), None);
+    assert_eq!(matches_single.opts_str_first(no_opts), None);
+
     let args_both = vec![
         "-e".to_string(),
         "foo".to_string(),
@@ -671,6 +690,13 @@ fn test_multi() {
     assert!(!matches_both.opts_present(&["thing".to_string()]));
     assert!(!matches_both.opts_present(&[]));
 
+    assert!(matches_both.opts_present_any(&["e"]));
+    assert!(matches_both.opts_present_any(&["encrypt"]));
+    assert!(matches_both.opts_present_any(&["encrypt", "e"]));
+    assert!(matches_both.opts_present_any(&["e", "encrypt"]));
+    assert!(!matches_both.opts_present_any(&["f"]));
+    assert!(!matches_both.opts_present_any(no_opts));
+
     assert_eq!(matches_both.opts_str(&["e".to_string()]).unwrap(), "foo");
     assert_eq!(
         matches_both.opts_str(&["encrypt".to_string()]).unwrap(),
@@ -688,6 +714,22 @@ fn test_multi() {
             .unwrap(),
         "foo"
     );
+
+    assert_eq!(matches_both.opts_str_first(&["e"]).unwrap(), "foo");
+    assert_eq!(
+        matches_both.opts_str_first(&["encrypt"]).unwrap(),
+        "foo"
+    );
+    assert_eq!(
+        matches_both.opts_str_first(&["e", "encrypt"]).unwrap(),
+        "foo"
+    );
+    assert_eq!(
+        matches_both.opts_str_first(&["encrypt", "e"]).unwrap(),
+        "foo"
+    );
+    assert_eq!(matches_both.opts_str_first(&["f"]), None);
+    assert_eq!(matches_both.opts_str_first(no_opts), None);
 }
 
 #[test]