Struct riot_wrappers::shell::Args

pub struct Args<'a>(_);

Newtype around an (argc, argv) C style string array that presents itself as much as an &'a [&'a str] as possible. (Slicing is not implemented for reasons of laziness).

As this is used with the command line parser, it presents the individual strings as &str infallibly. If non-UTF8 input is received, a variation of from_utf8_lossy is applied: The complete string (rather than just the bad characters) is reported as “�”, but should have the same effect: Be visible as an encoding error without needlessly complicated error handling for niche cases.

Implementations

impl<'a> Args<'a>

pub unsafe fn new(
    argc: c_int,
    argv: *const *const c_char,
    _lifetime_marker: &'a ()
) -> Self

Create the slice from its parts.

Unsafe

argv must be a valid pointer, and its first argc items must be valid pointers. The underlying char strings do not need to be valid UTF-8, but must be null terminated.

pub fn iter(&self) -> ArgsIterator<'a>

Returns an iterator over the arguments.

pub fn get(&self, index: usize) -> Option<&str>

Returns the argument in the given position.

pub fn len(&self) -> usize

Length of the arguments list

Trait Implementations

impl<'a> Index<usize> for Args<'a>

type Output = str

The returned type after indexing.

fn index(&self, i: usize) -> &str

Performs the indexing (container[index]) operation.

impl<'a> IntoIterator for Args<'a>

type Item = &'a str

The type of the elements being iterated over.

type IntoIter = ArgsIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.