Struct NonEmptyStringValueParser

#[non_exhaustive]
pub struct NonEmptyStringValueParser {}

Parse non-empty string values

See also:

Example

Usage:

# use clap_builder as clap;
let mut cmd = clap::Command::new("raw")
    .arg(
        clap::Arg::new("append")
            .value_parser(clap::builder::NonEmptyStringValueParser::new())
            .required(true)
    );

let m = cmd.try_get_matches_from_mut(["cmd", "true"]).unwrap();
let port: &String = m.get_one("append")
    .expect("required");
assert_eq!(port, "true");

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::NonEmptyStringValueParser::new();
assert_eq!(value_parser.parse_ref(&cmd, arg, OsStr::new("random")).unwrap(), "random");
assert!(value_parser.parse_ref(&cmd, arg, OsStr::new("")).is_err());

Implementations

impl NonEmptyStringValueParser

fn new() -> Self

Parse non-empty string values

Trait Implementations

impl Clone for NonEmptyStringValueParser

fn clone(&self) -> NonEmptyStringValueParser

impl Copy for NonEmptyStringValueParser

impl Debug for NonEmptyStringValueParser

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

impl Default for NonEmptyStringValueParser

fn default() -> Self

impl TypedValueParser for NonEmptyStringValueParser

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

Auto Trait Implementations

impl Freeze for NonEmptyStringValueParser

impl RefUnwindSafe for NonEmptyStringValueParser

impl Send for NonEmptyStringValueParser

impl Sync for NonEmptyStringValueParser

impl Unpin for NonEmptyStringValueParser

impl UnsafeUnpin for NonEmptyStringValueParser

impl UnwindSafe for NonEmptyStringValueParser

Blanket Implementations

impl<I> IntoResettable<ValueParser> for NonEmptyStringValueParser where I: Into<ValueParser>,

fn into_resettable(self) -> Resettable<ValueParser>

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

impl<T> From<T> for NonEmptyStringValueParser

fn from(t: T) -> T

Returns the argument unchanged.

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

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

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

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