Struct clap::builder::RangedI64ValueParser

pub struct RangedI64ValueParser<T = i64>
where
    T: TryFrom<i64> + Clone + Send + Sync,
{ /* private fields */ }

Parse number that fall within a range of values

NOTE: To capture negative values, you will also need to set Arg::allow_negative_numbers or Arg::allow_hyphen_values.

Example

Usage:

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

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

Semantics:

let value_parser = clap::builder::RangedI64ValueParser::<i32>::new().range(-1..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_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("-1")).unwrap(), -1);
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> RangedI64ValueParser<T>

where T: TryFrom<i64> + Clone + Send + Sync,

pub fn new() -> RangedI64ValueParser<T>

Select full range of i64

pub fn range<B>(self, range: B) -> RangedI64ValueParser<T>

where B: RangeBounds<i64>,

Narrow the supported range

Trait Implementations

impl<T> Clone for RangedI64ValueParser<T>

where T: Clone + TryFrom<i64> + Send + Sync,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Debug for RangedI64ValueParser<T>

where T: Debug + TryFrom<i64> + Clone + Send + Sync,

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

Formats the value using the given formatter.

impl<T> Default for RangedI64ValueParser<T>

where T: TryFrom<i64> + Clone + Send + Sync,

fn default() -> RangedI64ValueParser<T>

Returns the “default value” for a type.

impl<T, B> From<B> for RangedI64ValueParser<T>

where T: TryFrom<i64> + Clone + Send + Sync, B: RangeBounds<i64>,

fn from(range: B) -> RangedI64ValueParser<T>

Converts to this type from the input type.

impl<T> TypedValueParser for RangedI64ValueParser<T>

where T: TryFrom<i64> + Clone + Send + Sync + 'static, <T as TryFrom<i64>>::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<<RangedI64ValueParser<T> as TypedValueParser>::Value, Error>

Parse the argument value

fn parse_ref_( &self, cmd: &Command, arg: Option<&Arg>, value: &OsStr, _source: ValueSource, ) -> 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 parse_( &self, cmd: &Command, arg: Option<&Arg>, value: OsString, _source: ValueSource, ) -> Result<Self::Value, Error>

Parse the argument value

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

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

fn try_map<T, E, F>(self, func: F) -> TryMapValueParser<Self, F>

where F: Fn(Self::Value) -> Result<T, E> + Clone + Send + Sync + 'static, T: Send + Sync + Clone, E: Into<Box<dyn Error + Sync + Send>>,

Adapt a TypedValueParser from one value to another

impl<T> Copy for RangedI64ValueParser<T>

where T: Copy + TryFrom<i64> + Clone + Send + Sync,