Struct `RangedU64ValueParser`

struct RangedU64ValueParser<T: TryFrom<u64> = u64> { ... }

Parse number that fall within a range of 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!(u64).range(3000..))
            .action(clap::ArgAction::Set)
            .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:

# 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::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>`

fn new() -> Self: Select full range of u64
fn range<B: RangeBounds<u64>>(self: Self, range: B) -> Self: Narrow the supported range

`impl<I> IntoResettable for RangedU64ValueParser<T>`

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

`impl<T> Any for RangedU64ValueParser<T>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for RangedU64ValueParser<T>`

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

`impl<T> BorrowMut for RangedU64ValueParser<T>`

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

`impl<T> CloneToUninit for RangedU64ValueParser<T>`

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

`impl<T> Freeze for RangedU64ValueParser<T>`

`impl<T> From for RangedU64ValueParser<T>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T> RefUnwindSafe for RangedU64ValueParser<T>`

`impl<T> Send for RangedU64ValueParser<T>`

`impl<T> Sync for RangedU64ValueParser<T>`

`impl<T> ToOwned for RangedU64ValueParser<T>`

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

`impl<T> Unpin for RangedU64ValueParser<T>`

`impl<T> UnsafeUnpin for RangedU64ValueParser<T>`

`impl<T> UnwindSafe for RangedU64ValueParser<T>`

`impl<T, U> Into for RangedU64ValueParser<T>`

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 RangedU64ValueParser<T>`

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

`impl<T, U> TryInto for RangedU64ValueParser<T>`

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

`impl<T: $crate::clone::Clone + TryFrom<u64>> Clone for RangedU64ValueParser<T>`

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

`impl<T: $crate::fmt::Debug + TryFrom<u64>> Debug for RangedU64ValueParser<T>`

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

`impl<T: $crate::marker::Copy + TryFrom<u64>> Copy for RangedU64ValueParser<T>`

`impl<T: TryFrom<u64> + Clone + Send + Sync + 'static> TypedValueParser for RangedU64ValueParser<T>`

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

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

fn default() -> Self

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

fn from(range: B) -> Self