impl ValueParser

fn type_id(self: &Self) -> AnyValueId

Describes the content of AnyValue

fn possible_values(self: &Self) -> Option<Box<dyn Iterator<Item = PossibleValue> + '_>>

Reflect on enumerated value properties

Error checking should not be done with this; it is mostly targeted at user-facing applications like errors and completion.

impl ValueParser

fn new<P>(other: P) -> Self
where
    P: TypedValueParser

Custom parser for argument values

Pre-existing TypedValueParser implementations include:

• Fn(&str) -> Result<T, E>
• EnumValueParser and PossibleValuesParser for static enumerated values
• BoolishValueParser and FalseyValueParser for alternative bool implementations
• RangedI64ValueParser and RangedU64ValueParser
• NonEmptyStringValueParser

Example

# use clap_builder as clap;
type EnvVar = (String, Option<String>);
fn parse_env_var(env: &str) -> Result<EnvVar, std::io::Error> {
    if let Some((var, value)) = env.split_once('=') {
        Ok((var.to_owned(), Some(value.to_owned())))
    } else {
        Ok((env.to_owned(), None))
    }
}

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("env")
            .value_parser(clap::builder::ValueParser::new(parse_env_var))
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "key=value"]).unwrap();
let port: &EnvVar = m.get_one("env")
    .expect("required");
assert_eq!(*port, ("key".into(), Some("value".into())));

const fn bool() -> Self

bool parser for argument values

See also:

• BoolishValueParser for different human readable bool representations
• FalseyValueParser for assuming non-false is true

Example

# use clap_builder as clap;
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("download")
            .value_parser(clap::value_parser!(bool))
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "true"]).unwrap();
let port: bool = *m.get_one("download")
    .expect("required");
assert_eq!(port, true);

assert!(cmd.try_get_matches_from_mut(["cmd", "forever"]).is_err());

const fn string() -> Self

String parser for argument values

See also:

• NonEmptyStringValueParser

Example

# use clap_builder as clap;
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("port")
            .value_parser(clap::value_parser!(String))
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "80"]).unwrap();
let port: &String = m.get_one("port")
    .expect("required");
assert_eq!(port, "80");

const fn os_string() -> Self

[OsString][std::ffi::OsString] parser for argument values

Example

# #[cfg(unix)] {
# use clap_builder as clap;
# use clap::{Command, Arg, builder::ValueParser};
use std::ffi::OsString;
use std::os::unix::ffi::{OsStrExt,OsStringExt};
let r = Command::new("myprog")
    .arg(
        Arg::new("arg")
        .required(true)
        .value_parser(ValueParser::os_string())
    )
    .try_get_matches_from(vec![
        OsString::from("myprog"),
        OsString::from_vec(vec![0xe9])
    ]);

assert!(r.is_ok());
let m = r.unwrap();
let arg: &OsString = m.get_one("arg")
    .expect("required");
assert_eq!(arg.as_bytes(), &[0xe9]);
# }

const fn path_buf() -> Self

[PathBuf][std::path::PathBuf] parser for argument values

Example

# use clap_builder as clap;
# use std::path::PathBuf;
# use std::path::Path;
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("output")
            .value_parser(clap::value_parser!(PathBuf))
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "hello.txt"]).unwrap();
let port: &PathBuf = m.get_one("output")
    .expect("required");
assert_eq!(port, Path::new("hello.txt"));

assert!(cmd.try_get_matches_from_mut(["cmd", ""]).is_err());

impl Clone for ValueParser

fn clone(self: &Self) -> Self

impl Debug for ValueParser

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result<(), Error>

impl Freeze for ValueParser

impl From for ValueParser

fn from(value: RangeTo<i64>) -> Self

impl From for ValueParser

fn from(value: RangeInclusive<i64>) -> Self

impl From for ValueParser

fn from(value: RangeToInclusive<i64>) -> Self

impl From for ValueParser

fn from(value: RangeFrom<i64>) -> Self

impl From for ValueParser

fn from(value: Range<i64>) -> Self

impl From for ValueParser

fn from(value: RangeFull) -> Self

impl RefUnwindSafe for ValueParser

impl Send for ValueParser

impl Sync for ValueParser

impl Unpin for ValueParser

impl UnsafeUnpin for ValueParser

impl UnwindSafe for ValueParser

impl<I> IntoResettable for ValueParser

fn into_resettable(self: Self) -> Resettable<ValueParser>

impl<P> From for ValueParser

fn from(p: P) -> Self

impl<P> From for ValueParser

fn from(values: Vec<P>) -> Self

impl<P, C: usize> From for ValueParser

fn from(values: [P; C]) -> Self

impl<T> Any for ValueParser

fn type_id(self: &Self) -> TypeId

impl<T> Borrow for ValueParser

fn borrow(self: &Self) -> &T

impl<T> BorrowMut for ValueParser

fn borrow_mut(self: &mut Self) -> &mut T

impl<T> CloneToUninit for ValueParser

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

impl<T> From for ValueParser

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for ValueParser

fn to_owned(self: &Self) -> T

fn clone_into(self: &Self, target: &mut T)

impl<T, U> Into for ValueParser

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

impl<T, U> TryFrom for ValueParser

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto for ValueParser

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>