Struct LineTransport 

pub struct LineTransport<'a> { /* private fields */ }

Line-oriented packet source for file/stdin style transports.

Implementations

impl<'a> LineTransport<'a>

pub fn new(input: &'a [u8]) -> Self

Creates a transport over newline-separated packet bytes.

Examples found in repository

examples/process_file.rs (line 16)

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 } => println!("{}", packet.to_json()),
            EngineResult::Rejected { reason, .. } => eprintln!("rejected: {}", reason.code()),
            EngineResult::ParseError(error) => eprintln!("malformed: {}", error.code()),
        }
    }

    Ok(())
}

examples/service_ingest.rs (line 9)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process(packet) {
            EngineResult::Accepted { packet } => {
                println!("accepted semantic={}", packet.summary().semantic);
            }
            EngineResult::Rejected { reason, .. } => {
                let diagnostic = reason.diagnostic();
                println!(
                    "rejected code={} remediation={}",
                    diagnostic.code, diagnostic.remediation
                );
            }
            EngineResult::ParseError(error) => {
                let diagnostic = error.diagnostic();
                println!(
                    "malformed code={} remediation={}",
                    diagnostic.code, diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

pub fn packets(&self) -> Vec<&'a [u8]>

Iterates packet lines without trailing CR/LF bytes.

Examples found in repository

examples/process_file.rs (line 16)

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 } => println!("{}", packet.to_json()),
            EngineResult::Rejected { reason, .. } => eprintln!("rejected: {}", reason.code()),
            EngineResult::ParseError(error) => eprintln!("malformed: {}", error.code()),
        }
    }

    Ok(())
}

pub fn packets_with_limit(&self, max_packet_len: usize) -> Result<Vec<&'a [u8]>>

Iterates packet lines while enforcing a per-packet byte limit.

The limit is applied after removing one trailing carriage return from CRLF-framed lines and before allocating owned packet copies.

Examples found in repository

examples/service_ingest.rs (line 9)

fn main() -> Result<(), std::io::Error> {
    let input = b"N0CALL>APRS:>service online\nN1CALL>APRS:~opaque\nbad packet\n";
    let mut engine = Engine::new(Policy::strict());

    let packets = LineTransport::new(input).packets_with_limit(MAX_PACKET_LEN)?;

    for packet in packets {
        match engine.process(packet) {
            EngineResult::Accepted { packet } => {
                println!("accepted semantic={}", packet.summary().semantic);
            }
            EngineResult::Rejected { reason, .. } => {
                let diagnostic = reason.diagnostic();
                println!(
                    "rejected code={} remediation={}",
                    diagnostic.code, diagnostic.remediation
                );
            }
            EngineResult::ParseError(error) => {
                let diagnostic = error.diagnostic();
                println!(
                    "malformed code={} remediation={}",
                    diagnostic.code, diagnostic.remediation
                );
            }
        }
    }

    let counters = engine.counters();
    println!(
        "summary accepted={} rejected={} malformed={}",
        counters.accepted, counters.rejected, counters.malformed
    );

    Ok(())
}

Trait Implementations

impl<'a> Clone for LineTransport<'a>

fn clone(&self) -> LineTransport<'a>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for LineTransport<'a>

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

Formats the value using the given formatter.

impl PacketSource for LineTransport<'_>

type Error = Error

Source-specific error type.

fn recv_packets(&mut self) -> Result<Vec<Vec<u8>>, Self::Error>

Reads a bounded batch of packet byte vectors.

impl<'a> PartialEq for LineTransport<'a>

fn eq(&self, other: &LineTransport<'a>) -> 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<'a> Eq for LineTransport<'a>

impl<'a> StructuralPartialEq for LineTransport<'a>