Struct RangedI64ValueParser

pub struct RangedI64ValueParser<T: TryFrom<i64> + Clone + Send + Sync = i64> { /* 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][crate::Arg::allow_negative_numbers] or [Arg::allow_hyphen_values][crate::Arg::allow_hyphen_values].

Example

Usage:

# use clap_builder as clap;
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:

# use clap_builder as clap;
# use std::ffi::OsStr;
# use clap::builder::TypedValueParser;
# let cmd = clap::Command::new("test");
# let arg = None;
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: TryFrom<i64> + Clone + Send + Sync> RangedI64ValueParser<T>

fn new() -> Self

Select full range of i64

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

Narrow the supported range

Trait Implementations

impl<T: Clone + TryFrom<i64> + Clone + Send + Sync> Clone for RangedI64ValueParser<T>

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

impl<T: Copy + TryFrom<i64> + Clone + Send + Sync> Copy for RangedI64ValueParser<T>

impl<T: Debug + TryFrom<i64> + Clone + Send + Sync> Debug for RangedI64ValueParser<T>

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

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

type Value = T;
fn parse_ref(&self, cmd: &Command, arg: Option<&Arg>, raw_value: &OsStr) -> Result<Self::Value, Error>

impl<T: TryFrom<i64> + Clone + Send + Sync> Default for RangedI64ValueParser<T>

fn default() -> Self

impl<T: TryFrom<i64> + Clone + Send + Sync, B: RangeBounds<i64>> From<B> for RangedI64ValueParser<T>

fn from(range: B) -> Self

Auto Trait Implementations

impl<T> Freeze for RangedI64ValueParser<T> where PhantomData<T>: Freeze,

impl<T> RefUnwindSafe for RangedI64ValueParser<T> where PhantomData<T>: RefUnwindSafe,

impl<T> Send for RangedI64ValueParser<T> where PhantomData<T>: Send,

impl<T> Sync for RangedI64ValueParser<T> where PhantomData<T>: Sync,

impl<T> Unpin for RangedI64ValueParser<T> where PhantomData<T>: Unpin,

impl<T> UnsafeUnpin for RangedI64ValueParser<T> where PhantomData<T>: UnsafeUnpin,

impl<T> UnwindSafe for RangedI64ValueParser<T> where PhantomData<T>: UnwindSafe,

Blanket Implementations

impl<I> IntoResettable<ValueParser> for RangedI64ValueParser<T> where I: Into<ValueParser>,

fn into_resettable(self) -> Resettable<ValueParser>

impl<T> Any for RangedI64ValueParser<T> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for RangedI64ValueParser<T> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for RangedI64ValueParser<T> where T: ?Sized,

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

impl<T> CloneToUninit for RangedI64ValueParser<T> where T: Clone,

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

impl<T> From<T> for RangedI64ValueParser<T>

fn from(t: T) -> T

Returns the argument unchanged.

impl<T> ToOwned for RangedI64ValueParser<T> where T: Clone,

type Owned = T;
fn to_owned(&self) -> T
fn clone_into(&self, target: &mut T)

impl<T, U> Into<U> for RangedI64ValueParser<T> where U: From<T>,

fn into(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<U> for RangedI64ValueParser<T> where U: Into<T>,

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

impl<T, U> TryInto<U> for RangedI64ValueParser<T> where U: TryFrom<T>,

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