pub fn contains_all_mops(&self, needle_vec: Vec<&str>) -> bool {
        let some_haystack = parsers::parse_mops(&self.options);
        if some_haystack.is_some() {
            let haystack = some_haystack.unwrap();
            for needle in needle_vec {
                if !haystack.contains(&String::from(needle)) {
                    return false;
                }
            }
        } else {
            return false; // there were no mops parsed in the command so there is no match
        }

        true
    }
/// Returns a boolean for the question "Does the command include the option `needle` when the POSIX multi-option short syntax option style is used?"
///
/// # Remarks
/// The mops style defined by POSIX includes a single hyphen character followed by one or more alphanumeric characters in the Unicode Basic Latin set.  Each character represents a unique option switch.  For example, "-lmn" is used to indicate "-l -m -n".  This method tests against any short option formatted argument included in the command irrespective of the number of alphanumeric characters that are included.  The method does not test against long options (i.e., those that begin with two hyphens).
///
/// If you do not use the mops option syntax in your application, use the `Command::contains_all_options()` method instead.
///
/// # Examples
///
/// ```
/// let c = commandlines::Command::new();
///
/// if c.contains_all_mops(vec!["-j", "-k", "-l"]) {
///     // the `j`, `k` and `l` switches were identified in short format options on the command line
/// }
/// ```
Returns a boolean for the question "Does the command include the option `needle` when the POSIX multi-option short syntax option style is used?"
Returns a boolean for the question " Does the command include the option ` needle ` when the POSIX multi - option short syntax option style is used? "
pub fn contains_all_mops(&self, needle_vec: Vec<&str>) -> bool {
        let some_haystack = parsers::parse_mops(&self.options);
        if some_haystack.is_some() {
            let haystack = some_haystack.unwrap();
            for needle in needle_vec {
                if !haystack.contains(&String::from(needle)) {
                    return false;
                }
            }
        } else {
            return false; // there were no mops parsed in the command so there is no match
        }
        true
    }
pub fn contains_all_mops ( & self , needle_vec : Vec < & str > ) -> bool { let some_haystack = parsers :: parse_mops ( & self . options ) ; if some_haystack . is_some ( ) { let haystack = some_haystack . unwrap ( ) ; for needle in needle_vec { if ! haystack . contains ( & String :: from ( needle ) ) { return false ; } } } else { return false ; // there were no mops parsed in the command so there is no match } true }
Returns a boolean for the question "Does the command include the option `needle` when the POSIX multi-option short syntax option style is used?"
Returns a boolean for the question " Does the command include the option ` needle ` when the POSIX multi - option short syntax option style is used? "
&self
needle_vec
Vec<&str>
&self
needle_vec
Vec<&str>
remarks
The mops style defined by POSIX includes a single hyphen character followed by one or more alphanumeric characters in the Unicode Basic Latin set.  Each character represents a unique option switch.  For example, "-lmn" is used to indicate "-l -m -n".  This method tests against any short option formatted argument included in the command irrespective of the number of alphanumeric characters that are included.  The method does not test against long options .

If you do not use the mops option syntax in your application, use the `Command::contains_all_options()` method instead.
The mops style defined by POSIX includes a single hyphen character followed by one or more alphanumeric characters in the Unicode Basic Latin set . Each character represents a unique option switch . For example " - lmn " is used to indicate " - l - m - n " . This method tests against any short option formatted argument included in the command irrespective of the number of alphanumeric characters that are included . The method does not test against long options . If you do not use the mops option syntax in your application use the ` Command :: contains_all_options () ` method instead .
examples
```
let c = commandlines::Command::new().

if c.contains_all_mops(vec!["-j", "-k", "-l"]) {
the `j`, `k` and `l` switches were identified in short format options on the command line
}
```
` ` ` let c = commandlines :: Command :: new () . if c . contains_all_mops ( vec! [ " - j " " - k " " - l " ] ) { the ` j ` ` k ` and ` l ` switches were identified in short format options on the command line } ` ` `