Struct Metadata 

pub struct Metadata {
    pub app_name: &'static str,
    pub app_description: &'static str,
    pub help_flag_name: Option<&'static str>,
    pub help_mode: bool,
    pub full_help: bool,
    pub is_valid_flag_chars: fn(&str) -> bool,
}

Metadata of RawArgs.

Fields

app_name: &'static str

Application name (e.g., env!("CARGO_PKG_NAME")).

app_description: &'static str

Application description (e.g., env!("CARGO_PKG_DESCRIPTION")).

help_flag_name: Option<&'static str>

Flag name for help (default: Some("help")).

help_mode: bool

When enabled, the following help mode behaviors apply:

• RawArgs::finish() will return Ok(Some(help_text)) if successful
• Only default and example values will be used when calling ArgSpec::take() or OptSpec::take()

full_help: bool

If true, a full help text will be displayed.

is_valid_flag_chars: fn(&str) -> bool

Predicate function to determine if a string contains only valid flag characters.

This function is used when parsing short flags to distinguish between:

• Multiple flags (e.g., -abc where each character is a flag)
• Options with concatenated values (e.g., -khello where ‘k’ is an option and “hello” is its value)

The default implementation accepts only ASCII alphabetic characters, which prevents ambiguity in parsing. For example, with -khello world, the presence of space and non-alphabetic characters indicates this is an option with a concatenated value rather than multiple flags.

Example: Only accept flags actually defined by the app

use noargs::{raw_args, flag};

let mut args = raw_args();

// Define the valid short flags for your app
const VALID_FLAGS: &[char] = &['h', 'v', 'q', 'd'];

// Only allow characters that correspond to actual flags in your app
args.metadata_mut().is_valid_flag_chars = |chars| {
    chars.chars().all(|c| VALID_FLAGS.contains(&c))
};

// Now only -h, -v, -q, -d and their combinations (like -hv, -vd) are valid
// Anything else like -khello be treated as an option with concatenated value
let help_flag = flag("help").short('h').take(&mut args);
let verbose_flag = flag("verbose").short('v').take(&mut args);
let quiet_flag = flag("quiet").short('q').take(&mut args);
let debug_flag = flag("debug").short('d').take(&mut args);

Trait Implementations

impl Clone for Metadata

fn clone(&self) -> Metadata

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Metadata

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

Formats the value using the given formatter.

impl Default for Metadata

fn default() -> Self

Returns the “default value” for a type.

impl Hash for Metadata

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

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Metadata

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Metadata

impl Eq for Metadata

impl StructuralPartialEq for Metadata