Struct Args

pub struct Args<'a>(&'a [*mut c_char]);

Available on riot_module_shell only.

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.

Tuple Fields

0: &'a [*mut c_char]

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.

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: 8 bytes