Struct AtParser 

pub struct AtParser<'a, T, const SIZE: usize>
where
    T: AtContext<SIZE> + ?Sized,
{
    pub commands: &'a mut [(&'static str, &'a mut T)],
}

The main AT command parser

Generic over T which must implement the AtContext<SIZE> trait, and over the const SIZE which determines the response buffer size.

Generic Design

The parser is generic over the command handler type T and response size SIZE to allow compile-time type checking when all handlers are of the same type. This provides:

• Type safety: Compile-time verification of handler types
• Zero overhead: No dynamic dispatch when using concrete types
• Flexibility: Can be used with trait objects (dyn AtContext<SIZE>) for mixed handler types

Usage Patterns

With trait objects (recommended for mixed types):

const SIZE: usize = 64;
let mut parser: AtParser<dyn AtContext<SIZE>, SIZE> = AtParser::new();
let commands: &mut [(&str, &mut dyn AtContext<SIZE>)] = &mut [
    ("AT+ECHO", &mut echo_handler),
    ("AT+RST", &mut reset_handler),
];
parser.set_commands(commands);

With concrete types (for homogeneous handlers):

const SIZE: usize = 64;
let mut parser: AtParser<MyHandler, SIZE> = AtParser::new();
let commands: &mut [(&str, &mut MyHandler)] = &mut [
    ("AT+CMD1", &mut handler1),
    ("AT+CMD2", &mut handler2),
];
parser.set_commands(commands);

Fields

commands: &'a mut [(&'static str, &'a mut T)]

Array of registered commands with their name and handler

Implementations

impl<'a, T, const SIZE: usize> AtParser<'a, T, SIZE>

where T: AtContext<SIZE> + ?Sized,

pub const fn new() -> Self

Create a new empty parser

pub fn set_commands(&mut self, commands: &'a mut [(&'static str, &'a mut T)])

Register commands that this parser will handle

pub fn execute(&mut self, input: &str) -> AtResult<SIZE>

Parse and execute an AT command string

Arguments

• input - The raw AT command string (e.g., “AT+CMD?”)

Returns

• Ok(Bytes<SIZE>) - Success response from the command handler
• Err(AtError) - Error if parsing fails or command is not found