Struct RawArgs 

pub struct RawArgs { /* private fields */ }

Command-line arguments

Implementations

impl RawArgs

pub fn from_args() -> Self

NOTE: The argument returned will be the current binary.

Example

let raw = clap_lex::RawArgs::from_args();
let mut cursor = raw.cursor();
let _bin = raw.next_os(&mut cursor);

let mut paths = raw.remaining(&mut cursor).map(PathBuf::from).collect::<Vec<_>>();
println!("{paths:?}");

pub fn new(iter: impl IntoIterator<Item = impl Into<OsString>>) -> Self

Example

let raw = clap_lex::RawArgs::new(["bin", "foo.txt"]);
let mut cursor = raw.cursor();
let _bin = raw.next_os(&mut cursor);

let mut paths = raw.remaining(&mut cursor).map(PathBuf::from).collect::<Vec<_>>();
println!("{paths:?}");

pub fn cursor(&self) -> ArgCursor

Create a cursor for walking the arguments

Example

let raw = clap_lex::RawArgs::new(["bin", "foo.txt"]);
let mut cursor = raw.cursor();
let _bin = raw.next_os(&mut cursor);

let mut paths = raw.remaining(&mut cursor).map(PathBuf::from).collect::<Vec<_>>();
println!("{paths:?}");

pub fn next<'s>(&'s self, cursor: &mut ArgCursor) -> Option<ParsedArg<'s>>

Advance the cursor, returning the next ParsedArg

pub fn next_os<'s>(&'s self, cursor: &mut ArgCursor) -> Option<&'s OsStr>

Advance the cursor, returning a raw argument value.

pub fn peek<'s>(&'s self, cursor: &ArgCursor) -> Option<ParsedArg<'s>>

Return the next ParsedArg

pub fn peek_os<'s>(&'s self, cursor: &ArgCursor) -> Option<&'s OsStr>

Return a raw argument value.

pub fn remaining<'s>( &'s self, cursor: &mut ArgCursor, ) -> impl Iterator<Item = &'s OsStr>

Return all remaining raw arguments, advancing the cursor to the end

Example

let raw = clap_lex::RawArgs::new(["bin", "foo.txt"]);
let mut cursor = raw.cursor();
let _bin = raw.next_os(&mut cursor);

let mut paths = raw.remaining(&mut cursor).map(PathBuf::from).collect::<Vec<_>>();
println!("{paths:?}");

pub fn seek(&self, cursor: &mut ArgCursor, pos: SeekFrom)

Adjust the cursor’s position

pub fn insert( &mut self, cursor: &ArgCursor, insert_items: impl IntoIterator<Item = impl Into<OsString>>, )

Inject arguments before the RawArgs::next

pub fn is_end(&self, cursor: &ArgCursor) -> bool

Any remaining args?

Trait Implementations

impl Clone for RawArgs

fn clone(&self) -> RawArgs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for RawArgs

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

Formats the value using the given formatter.

impl Default for RawArgs

fn default() -> RawArgs

Returns the “default value” for a type.

impl Eq for RawArgs

impl<I, T> From<I> for RawArgs

where I: Iterator<Item = T>, T: Into<OsString>,

fn from(val: I) -> Self

Converts to this type from the input type.

impl PartialEq for RawArgs

fn eq(&self, other: &RawArgs) -> 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 StructuralPartialEq for RawArgs