Struct AtParser 

pub struct AtParser<'a, T>
where
    T: AtContext,
{
    pub commands: &'a mut [(&'static str, &'a mut T)],
}

The main AT command parser Generic over T which must implement AtContext trait

Fields

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

Array of registered commands with their name and handler

Implementations

impl<'a, T> AtParser<'a, T>

where T: AtContext,

pub fn new() -> Self

Create a new empty parser

Examples found in repository

examples/basic_parser.rs (line 49)

fn main() {
    println!("=== AtParser Example ===\n");

    // Create command instances
    let mut cmd1 = TestCommand { value: 0 };
    let mut cmd2 = TestCommand { value: 5 };
    let mut cmd3 = TestCommand { value: 10 };

    // Create parser instance
    let mut parser = AtParser::new();
    
    // Register commands
    let commands: &mut [(&str, &mut TestCommand)] = &mut [
        ("AT+CMD1", &mut cmd1),
        ("AT+CMD2", &mut cmd2),
        ("AT+CMD3", &mut cmd3),
    ];

    parser.set_commands(commands);

    println!("Registered commands: AT+CMD1, AT+CMD2, AT+CMD3\n");

    // Test cases
    let test_cases = vec![
        ("AT+CMD1", "Execute CMD1"),
        ("AT+CMD1?", "Query CMD1 value"),
        ("AT+CMD1=?", "Test CMD1"),
        ("AT+CMD1=42", "Set CMD1 to 42"),
        ("AT+CMD1?", "Query CMD1 after set"),
        ("AT+CMD2", "Execute CMD2"),
        ("AT+CMD2?", "Query CMD2 value"),
        ("AT+CMD3=100", "Set CMD3 to 100"),
        ("AT+CMD3?", "Query CMD3"),
        ("AT+UNKNOWN", "Unknown command error"),
        ("AT+CMD1=abc", "Invalid argument error"),
    ];

    for (cmd, description) in test_cases {
        println!("Test: {}", description);
        println!("  Command: {}", cmd);
        match parser.execute(cmd) {
            Ok(response) => println!("  Response: {}", response),
            Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
            Err(AtError::NotSupported) => println!("  Error: Not supported"),
            Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
        }
        println!();
    }

    println!("=== Example completed ===");
}

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

Register commands that this parser will handle

Examples found in repository

examples/basic_parser.rs (line 58)

fn main() {
    println!("=== AtParser Example ===\n");

    // Create command instances
    let mut cmd1 = TestCommand { value: 0 };
    let mut cmd2 = TestCommand { value: 5 };
    let mut cmd3 = TestCommand { value: 10 };

    // Create parser instance
    let mut parser = AtParser::new();
    
    // Register commands
    let commands: &mut [(&str, &mut TestCommand)] = &mut [
        ("AT+CMD1", &mut cmd1),
        ("AT+CMD2", &mut cmd2),
        ("AT+CMD3", &mut cmd3),
    ];

    parser.set_commands(commands);

    println!("Registered commands: AT+CMD1, AT+CMD2, AT+CMD3\n");

    // Test cases
    let test_cases = vec![
        ("AT+CMD1", "Execute CMD1"),
        ("AT+CMD1?", "Query CMD1 value"),
        ("AT+CMD1=?", "Test CMD1"),
        ("AT+CMD1=42", "Set CMD1 to 42"),
        ("AT+CMD1?", "Query CMD1 after set"),
        ("AT+CMD2", "Execute CMD2"),
        ("AT+CMD2?", "Query CMD2 value"),
        ("AT+CMD3=100", "Set CMD3 to 100"),
        ("AT+CMD3?", "Query CMD3"),
        ("AT+UNKNOWN", "Unknown command error"),
        ("AT+CMD1=abc", "Invalid argument error"),
    ];

    for (cmd, description) in test_cases {
        println!("Test: {}", description);
        println!("  Command: {}", cmd);
        match parser.execute(cmd) {
            Ok(response) => println!("  Response: {}", response),
            Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
            Err(AtError::NotSupported) => println!("  Error: Not supported"),
            Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
        }
        println!();
    }

    println!("=== Example completed ===");
}

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

Parse and execute an AT command string

Arguments

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

Returns

• Ok(&str) - Success response from the command handler
• Err(AtError) - Error if parsing fails or command is not found

Examples found in repository

examples/basic_parser.rs (line 80)

fn main() {
    println!("=== AtParser Example ===\n");

    // Create command instances
    let mut cmd1 = TestCommand { value: 0 };
    let mut cmd2 = TestCommand { value: 5 };
    let mut cmd3 = TestCommand { value: 10 };

    // Create parser instance
    let mut parser = AtParser::new();
    
    // Register commands
    let commands: &mut [(&str, &mut TestCommand)] = &mut [
        ("AT+CMD1", &mut cmd1),
        ("AT+CMD2", &mut cmd2),
        ("AT+CMD3", &mut cmd3),
    ];

    parser.set_commands(commands);

    println!("Registered commands: AT+CMD1, AT+CMD2, AT+CMD3\n");

    // Test cases
    let test_cases = vec![
        ("AT+CMD1", "Execute CMD1"),
        ("AT+CMD1?", "Query CMD1 value"),
        ("AT+CMD1=?", "Test CMD1"),
        ("AT+CMD1=42", "Set CMD1 to 42"),
        ("AT+CMD1?", "Query CMD1 after set"),
        ("AT+CMD2", "Execute CMD2"),
        ("AT+CMD2?", "Query CMD2 value"),
        ("AT+CMD3=100", "Set CMD3 to 100"),
        ("AT+CMD3?", "Query CMD3"),
        ("AT+UNKNOWN", "Unknown command error"),
        ("AT+CMD1=abc", "Invalid argument error"),
    ];

    for (cmd, description) in test_cases {
        println!("Test: {}", description);
        println!("  Command: {}", cmd);
        match parser.execute(cmd) {
            Ok(response) => println!("  Response: {}", response),
            Err(AtError::UnknownCommand) => println!("  Error: Unknown command"),
            Err(AtError::NotSupported) => println!("  Error: Not supported"),
            Err(AtError::InvalidArgs) => println!("  Error: Invalid arguments"),
        }
        println!();
    }

    println!("=== Example completed ===");
}