Struct Policy 

pub struct Policy {
    pub allow_unsupported: bool,
    pub allow_malformed_semantics: bool,
    pub reject_invalid_nmea_checksum: bool,
    pub max_path_components: usize,
}

Policy options applied after parsing.

Fields

allow_unsupported: bool

Allow semantic packets represented as unsupported.

allow_malformed_semantics: bool

Allow semantic packets represented as malformed.

reject_invalid_nmea_checksum: bool

Reject NMEA sentences when a present checksum does not match.

max_path_components: usize

Maximum allowed path component count including destination.

Implementations

impl Policy

pub fn strict() -> Self

Strict policy: reject malformed semantics, unsupported formats, and long paths.

Examples found in repository

examples/process_file.rs (line 14)

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 permissive() -> Self

Permissive policy: accept unsupported and malformed semantic packets.

pub fn evaluate( &self, packet: &ParsedPacket, semantic: &AprsData<'_>, ) -> PolicyDecision

Evaluates a parsed packet and semantic view.

Trait Implementations

impl Clone for Policy

fn clone(&self) -> Policy

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Policy

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

Formats the value using the given formatter.

impl Default for Policy

fn default() -> Self

Returns the “default value” for a type.

impl PartialEq for Policy

fn eq(&self, other: &Policy) -> 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 Policy

impl StructuralPartialEq for Policy