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(())
}

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.

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>