Enum ParseError 

pub enum ParseError {
    Empty,
    Oversized,
    MissingSeparator,
    EmptySegment,
    InvalidAddress,
}

Fail-closed packet parse errors.

Variants

Empty

No bytes were supplied.

Oversized

Packet exceeds MAX_PACKET_LEN.

MissingSeparator

Packet does not contain the required APRS > and : separators.

EmptySegment

Packet contains an empty source, path, or payload segment.

InvalidAddress

Packet source or path contains bytes outside the conservative address set.

Implementations

impl ParseError

pub fn code(&self) -> &'static str

Returns a stable parse error code for logs and external systems.

Examples found in repository

examples/process_file.rs (line 28)

fn main() -> std::io::Result<()> {
    let Some(path) = std::env::args().nth(1) else {
        eprintln!("usage: process_file <packets.aprs>");
        std::process::exit(2);
    };

    let input = read_all_with_limit(File::open(path)?, DEFAULT_TRANSPORT_READ_LIMIT)?;
    let mut engine = Engine::new(Policy::strict());

    for packet_bytes in LineTransport::new(&input).packets() {
        match engine.process(packet_bytes) {
            EngineResult::Accepted { packet } => {
                let summary = packet.summary();
                println!(
                    "accepted source={} destination={} semantic={}",
                    String::from_utf8_lossy(summary.source),
                    String::from_utf8_lossy(summary.destination),
                    summary.semantic
                );
            }
            EngineResult::Rejected { reason, .. } => eprintln!("rejected: {}", reason.code()),
            EngineResult::ParseError(error) => eprintln!("malformed: {}", error.code()),
        }
    }

    Ok(())
}

examples/encode_packets.rs (line 14)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    let path = [b"APRS".as_slice(), b"WIDE1-1".as_slice()];

    let status = encode_status(b"N0CALL", &path, b"encoder example")?;
    assert_eq!(
        parse_packet(&status)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .raw()
            .as_bytes(),
        b"N0CALL>APRS,WIDE1-1:>encoder example"
    );

    let position = encode_uncompressed_position(
        b"N0CALL",
        &path,
        UncompressedPositionEncoding {
            messaging: false,
            latitude: b"4903.50N",
            symbol_table: b'/',
            longitude: b"07201.75W",
            symbol_code: b'-',
            comment: b"encoded",
        },
    )?;
    assert_eq!(
        parse_packet(&position)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .summary()
            .semantic,
        "position"
    );

    let telemetry = encode_telemetry(b"N0CALL", &path, 1, [111, 222, 33, 44, 55], None)?;
    assert_eq!(
        parse_packet(&telemetry)
            .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error.code()))?
            .summary()
            .semantic,
        "telemetry"
    );

    Ok(())
}

pub fn diagnostic(&self) -> ErrorDiagnostic

Returns structured parse error metadata for operator diagnostics.

Trait Implementations

impl Clone for ParseError

fn clone(&self) -> ParseError

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ParseError

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for ParseError

fn eq(&self, other: &ParseError) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for ParseError

impl StructuralPartialEq for ParseError