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(&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 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 Eq for RawArgs

impl StructuralPartialEq for RawArgs

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 24 bytes