Struct Command

pub struct Command<'a, Next, H, T = i32>
where
    Next: CommandListInternals,
    H: FnMut(&mut Stdio, Args<'_>) -> T,
    T: Termination,
{
    name: &'a CStr,
    desc: &'a CStr,
    handler: H,
    next: Next,
}

Available on riot_module_shell only.

Internal helper that holds the data assembled using the CommandList::and builder

(Exposed publicly as the CommandList::and trait method can not return an impl CommandList yet)

Fields

name: &'a CStr

desc: &'a CStr

handler: H

next: Next

Implementations

impl<'a, Next, H, T> Command<'a, Next, H, T>

where Next: CommandListInternals, H: FnMut(&mut Stdio, Args<'_>) -> T, T: Termination,

extern "C" fn handle<Root: CommandListInternals>( argc: i32, argv: *mut *mut c_char, ) -> i32

This is building a trampoline. As it’s static and thus can’t have the instance, we pass on a disambiguator (the command_index) for the globally stored root to pick our own self out of its tail again.

As all the commands in the list are serialized into a single CommandListInternals at the root, they are all nested, and thus have sequential tail sizes. Over using the own TypeId, this gives the advantage of building shorter trampolines (14 bytes rather than 24 on Cortex-M3), and also allows the find_self_and_run function to optimize better, as all its jumps are from a contiguous small range (think match ... {1 => one(), 2 => two(), _ => panic!()} rather than arbitrary large numbers; the compiler range check once and then pick the jump address from a table).

const fn tailsize() -> usize

Size of the own type’s built structs, in multiples of shell_command_t.

Usef for finding the own instance again, see handle documentation.

Trait Implementations

impl<'a, Next, H, T, const BUFSIZE: usize> CommandList<BUFSIZE> for Command<'a, Next, H, T>

where Next: CommandListInternals, H: FnMut(&mut Stdio, Args<'_>) -> T, T: Termination,

type WithBufferSizeResult<const NEWSIZE: usize> = Command<'a, Next, H, T>

fn with_buffer_size<const NEWSIZE: usize>( self, ) -> Self::WithBufferSizeResult<NEWSIZE>

Change the buffer size used for .run_forever_providing_buf().

fn run_once_with_buf(&mut self, linebuffer: &mut [u8])

fn run_forever_with_buf(&mut self, linebuffer: &mut [u8]) -> !

fn run_forever(&mut self) -> !

Run the shell prompt on stdio

fn run_once(&mut self)

Run the shell prompt on stdio until EOF is reached

fn run_forever_providing_buf(&mut self) -> !

👎Deprecated since 0.9: Renamed to run_forever

fn run_once_providing_buf(&mut self)

👎Deprecated since 0.9: Renamed to run_once

fn and<'a, H, T>( self, name: &'a CStr, desc: &'a CStr, handler: H, ) -> impl CommandList<BUFSIZE>

where H: FnMut(&mut Stdio, Args<'_>) -> T, T: Termination,

Extend the list of commands by an additional one.

impl<'a, Next, H, T> CommandListInternals for Command<'a, Next, H, T>

where Next: CommandListInternals, H: FnMut(&mut Stdio, Args<'_>) -> T, T: Termination,

type Built = BuiltCommand<<Next as CommandListInternals>::Built>

fn build_shell_command<Root: CommandListInternals>(&self) -> Self::Built

fn find_self_and_run( &mut self, argc: i32, argv: *mut *mut c_char, command_index: usize, ) -> i32

Run your own callback with argc and argv if the called argument is what the implementation put into its own entry of its Built, or defer to its next.

fn run_any<R, F: Fn(*const shell_command_t, *mut c_char, i32) -> R>( &mut self, linebuffer: &mut [u8], cb: F, ) -> R

fn find_root_and_run( argc: i32, argv: *mut *mut c_char, command_index: usize, ) -> i32

Layout

Note: Unable to compute type layout, possibly due to this type having generic parameters. Layout can only be computed for concrete, fully-instantiated types.