Struct clap_lex::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(&self, cursor: &mut ArgCursor) -> Option<ParsedArg<'_>>

Advance the cursor, returning the next ParsedArg

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

Advance the cursor, returning a raw argument value.

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

Return the next ParsedArg

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

Return a raw argument value.

pub fn remaining(&self, cursor: &mut ArgCursor) -> impl Iterator<Item = &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 copy 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<I, T> From<I> for RawArgswhere
    I: Iterator<Item = T>,
    T: Into<OsString>,

fn from(val: I) -> Self

Converts to this type from the input type.

impl PartialEq<RawArgs> for RawArgs

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl Eq for RawArgs

impl StructuralEq for RawArgs

impl StructuralPartialEq for RawArgs