Struct clap::builder::RangedU64ValueParser

pub struct RangedU64ValueParser<T: TryFrom<u64> = u64> { /* private fields */ }

Parse number that fall within a range of values

Example

Usage:

let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("port")
            .long("port")
            .value_parser(clap::value_parser!(u64).range(3000..))
            .takes_value(true)
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "--port", "3001"]).unwrap();
let port: u64 = *m.get_one("port")
    .expect("required");
assert_eq!(port, 3001);

Semantics:

let value_parser = clap::builder::RangedU64ValueParser::<u32>::new().range(0..200);
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("random")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("-200")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("300")).is_err());
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("-1")).is_err());
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("0")).unwrap(), 0);
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("50")).unwrap(), 50);

Implementations

impl<T: TryFrom<u64>> RangedU64ValueParser<T>

pub fn new() -> Self

Select full range of u64

pub fn range<B: RangeBounds<u64>>(self, range: B) -> Self

Narrow the supported range

Trait Implementations

impl<T: Clone + TryFrom<u64>> Clone for RangedU64ValueParser<T>

fn clone(&self) -> RangedU64ValueParser<T>

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<T: Debug + TryFrom<u64>> Debug for RangedU64ValueParser<T>

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

Formats the value using the given formatter.

impl<T: TryFrom<u64>> Default for RangedU64ValueParser<T>

fn default() -> Self

Returns the “default value” for a type.

impl<T: TryFrom<u64>, B: RangeBounds<u64>> From<B> for RangedU64ValueParser<T>

fn from(range: B) -> Self

Converts to this type from the input type.

impl<T: TryFrom<u64> + Clone + Send + Sync + 'static> TypedValueParser for RangedU64ValueParser<T>where
    <T as TryFrom<u64>>::Error: Send + Sync + 'static + Error + ToString,

type Value = T

Argument’s value type

fn parse_ref(
    &self,
    cmd: &Command<'_>,
    arg: Option<&Arg<'_>>,
    raw_value: &OsStr
) -> Result<Self::Value, Error>

Parse the argument value

fn parse(
    &self,
    cmd: &Command<'_>,
    arg: Option<&Arg<'_>>,
    value: OsString
) -> Result<Self::Value, Error>

Parse the argument value

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

Reflect on enumerated value properties

fn map<T, F>(self, func: F) -> MapValueParser<Self, F>where
    T: Send + Sync + Clone,
    F: Fn(Self::Value) -> T + Clone,

Adapt a TypedValueParser from one value to another

impl<T: Copy + TryFrom<u64>> Copy for RangedU64ValueParser<T>