Struct `ValueRange`

pub struct ValueRange { /* private fields */ }

Values per occurrence for an argument

Implementations

`impl ValueRange`

const EMPTY: Self = _;

Nor argument values, or a flag

const SINGLE: Self = _;

A single argument value, the most common case for options

fn new(range: impl Into<Self>) -> Self

Create a range

Panics

In debug builds, if the range accepts no values. For an exclusive range (start..end) that means end must be greater than start, so both reversed ranges like 10..5 and empty ranges like 5..5 panic.

Examples

# use clap_builder as clap;
# use clap::builder::ValueRange;
let range = ValueRange::new(5);
let range = ValueRange::new(5..10);
let range = ValueRange::new(5..=10);
let range = ValueRange::new(5..);
let range = ValueRange::new(..10);
let range = ValueRange::new(..=10);

While these will panic:

# use clap_builder as clap;
# use clap::builder::ValueRange;
let range = ValueRange::new(10..5);  // Panics! (reversed)

# use clap_builder as clap;
# use clap::builder::ValueRange;
let range = ValueRange::new(5..5);  // Panics! (empty)

fn min_values(&self) -> usize

Fewest number of values the argument accepts

fn max_values(&self) -> usize

Most number of values the argument accepts

fn takes_values(&self) -> bool

Report whether the argument takes any values (ie is a flag)

Examples

# use clap_builder as clap;
# use clap::builder::ValueRange;
let range = ValueRange::new(5);
assert!(range.takes_values());

let range = ValueRange::new(0);
assert!(!range.takes_values());

Trait Implementations

`impl Clone for ValueRange`

fn clone(&self) -> ValueRange

`impl Copy for ValueRange`

`impl Debug for ValueRange`

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

`impl Default for ValueRange`

fn default() -> Self

`impl Display for ValueRange`

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

`impl Eq for ValueRange`

`impl From<Range<usize>> for ValueRange`

fn from(range: Range<usize>) -> Self

`impl From<RangeFrom<usize>> for ValueRange`

fn from(range: RangeFrom<usize>) -> Self

`impl From<RangeFull> for ValueRange`

fn from(RangeFull) -> Self

`impl From<RangeInclusive<usize>> for ValueRange`

fn from(range: RangeInclusive<usize>) -> Self

`impl From<RangeTo<usize>> for ValueRange`

fn from(range: RangeTo<usize>) -> Self

`impl From<RangeToInclusive<usize>> for ValueRange`

fn from(range: RangeToInclusive<usize>) -> Self

`impl From<usize> for ValueRange`

fn from(fixed: usize) -> Self

`impl Hash for ValueRange`

fn hash<__H: Hasher>(&self, state: &mut __H)

`impl PartialEq for ValueRange`

fn eq(&self, other: &ValueRange) -> bool

`impl RangeBounds<usize> for ValueRange`

fn start_bound(&self) -> Bound<&usize>
fn end_bound(&self) -> Bound<&usize>

`impl StructuralPartialEq for ValueRange`

Auto Trait Implementations

`impl Freeze for ValueRange`

`impl RefUnwindSafe for ValueRange`

`impl Send for ValueRange`

`impl Sync for ValueRange`

`impl Unpin for ValueRange`

`impl UnsafeUnpin for ValueRange`

`impl UnwindSafe for ValueRange`

Blanket Implementations

`impl<I> IntoResettable<ValueRange> for ValueRange where I: Into<ValueRange>,`

fn into_resettable(self) -> Resettable<ValueRange>

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

fn type_id(&self) -> TypeId

`impl<T> Borrow<T> for ValueRange where T: ?Sized,`

fn borrow(&self) -> &T

`impl<T> BorrowMut<T> for ValueRange where T: ?Sized,`

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

`impl<T> CloneToUninit for ValueRange where T: Clone,`

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

`impl<T> From<T> for ValueRange`

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

`impl<T> ToOwned for ValueRange where T: Clone,`

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

`impl<T> ToString for ValueRange where T: Display + ?Sized,`

fn to_string(&self) -> String

`impl<T, U> Into<U> for ValueRange 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 ValueRange 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 ValueRange where U: TryFrom<T>,`

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