Merge pull request #157 from jacobcalvert/jacobcalvert/add-objects

refactoring parsing to support addition of Objects and Items

Author: scd31

src/components/extensions.rs

@@ -1,11 +1,72 @@
 use std::io::Write;
-use std::ops::Deref;
+use std::ops::{Deref, RangeInclusive};
 
 use base91;
 use bytes::parse_bytes;
 use DecodeError;
 use EncodeError;
-use Precision;
+
+#[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Ord, Eq)]
+pub enum Precision {
+    TenDegree,
+    OneDegree,
+    TenMinute,
+    OneMinute,
+    TenthMinute,
+    HundredthMinute,
+}
+
+impl Precision {
+    /// Returns the width of the precision in degrees.
+    /// For example, `Precision::OneDegree` would return 1.0.
+    pub fn width(&self) -> f64 {
+        match self {
+            Precision::HundredthMinute => 1.0 / 6000.0,
+            Precision::TenthMinute => 1.0 / 600.0,
+            Precision::OneMinute => 1.0 / 60.0,
+            Precision::TenMinute => 1.0 / 6.0,
+            Precision::OneDegree => 1.0,
+            Precision::TenDegree => 10.0,
+        }
+    }
+
+    pub(crate) fn range(&self, center: f64) -> RangeInclusive<f64> {
+        let width = self.width();
+
+        (center - (width / 2.0))..=(center + (width / 2.0))
+    }
+
+    pub(crate) fn num_digits(&self) -> u8 {
+        match self {
+            Precision::HundredthMinute => 0,
+            Precision::TenthMinute => 1,
+            Precision::OneMinute => 2,
+            Precision::TenMinute => 3,
+            Precision::OneDegree => 4,
+            Precision::TenDegree => 5,
+        }
+    }
+
+    pub(crate) fn from_num_digits(digits: u8) -> Option<Self> {
+        let res = match digits {
+            0 => Precision::HundredthMinute,
+            1 => Precision::TenthMinute,
+            2 => Precision::OneMinute,
+            3 => Precision::TenMinute,
+            4 => Precision::OneDegree,
+            5 => Precision::TenDegree,
+            _ => return None,
+        };
+
+        Some(res)
+    }
+}
+
+impl Default for Precision {
+    fn default() -> Self {
+        Self::HundredthMinute
+    }
+}
 
 #[derive(Debug, Copy, Clone, PartialOrd, PartialEq, Default)]
 pub struct Latitude(f64);
@@ -276,7 +337,7 @@ impl Longitude {
 // returns the parsed value as well as the number of spaces we found
 fn parse_bytes_trailing_spaces(b: &[u8; 2], only_spaces: bool) -> Option<(u32, u8)> {
     if only_spaces {
-        if b == &[b' ', b' '] {
+        if b == b"  " {
             return Some((0, 2));
         } else {
             return None;
@@ -293,6 +354,13 @@ fn parse_bytes_trailing_spaces(b: &[u8; 2], only_spaces: bool) -> Option<(u32, u
 mod tests {
     use super::*;
 
+    #[test]
+    fn precision_e2e() {
+        for i in 0..6 {
+            assert_eq!(i, Precision::from_num_digits(i).unwrap().num_digits());
+        }
+    }
+
     #[test]
     fn test_latitude_out_of_bounds() {
         assert_eq!(None, Latitude::new(90.1));

src/lonlat.rs renamed to src/components/lonlat.rs

@@ -0,0 +1,4 @@
+pub mod extensions;
+pub mod lonlat;
+pub mod position;
+pub mod timestamp;

src/components/mod.rs

@@ -0,0 +1,139 @@
+use std::{
+    io::{Read, Write},
+    ops::RangeInclusive,
+};
+
+use crate::{AprsCompressedCs, AprsCompressionType, DecodeError, EncodeError};
+
+use super::lonlat::{Latitude, Longitude, Precision};
+
+#[derive(PartialEq, Debug, Clone)]
+pub enum AprsCst {
+    CompressedSome {
+        cs: AprsCompressedCs,
+        t: AprsCompressionType,
+    },
+    CompressedNone,
+    Uncompressed,
+}
+
+#[derive(PartialEq, Debug, Clone)]
+pub struct Position {
+    pub latitude: Latitude,
+    pub longitude: Longitude,
+    pub precision: Precision,
+    pub symbol_table: char,
+    pub symbol_code: char,
+    pub cst: AprsCst,
+}
+
+impl Position {
+    /// Latitudes in APRS aren't perfectly precise - they have a configurable level of ambiguity. This is stored in the `precision` field on the `Position` struct. This method returns a range of what the actual latitude value might be.
+    pub fn latitude_bounding(&self) -> RangeInclusive<f64> {
+        self.precision.range(self.latitude.value())
+    }
+
+    /// Longitudes in APRS aren't perfectly precise - they have a configurable level of ambiguity. This is stored in the `precision` field on the `Position` struct. This method returns a range of what the actual longitude value might be.
+    pub fn longitude_bounding(&self) -> RangeInclusive<f64> {
+        self.precision.range(self.longitude.value())
+    }
+
+    pub(crate) fn encode_uncompressed<W: Write>(&self, buf: &mut W) -> Result<(), EncodeError> {
+        self.latitude.encode_uncompressed(buf, self.precision)?;
+        write!(buf, "{}", self.symbol_table)?;
+        self.longitude.encode_uncompressed(buf)?;
+        write!(buf, "{}", self.symbol_code)?;
+        Ok(())
+    }
+
+    pub(crate) fn encode_compressed<W: Write>(&self, buf: &mut W) -> Result<(), EncodeError> {
+        write!(buf, "{}", self.symbol_table)?;
+
+        self.latitude.encode_compressed(buf)?;
+        self.longitude.encode_compressed(buf)?;
+
+        write!(buf, "{}", self.symbol_code)?;
+
+        match self.cst {
+            AprsCst::CompressedSome { cs, t } => cs.encode(buf, t)?,
+            AprsCst::CompressedNone => write!(buf, " sT")?,
+            AprsCst::Uncompressed => unreachable!(),
+        };
+
+        Ok(())
+    }
+    /// this function assumes we are getting the head of a byte list
+    /// representing a compressed or uncompressed position
+    ///
+    /// all position representations interleave the symbol table and code
+    /// so we stuff it all in here
+    pub(crate) fn decode(b: &[u8]) -> Result<(Option<&[u8]>, Self), DecodeError> {
+        // make sure we're not empty
+        if b.is_empty() {
+            return Err(DecodeError::InvalidPosition(b.to_vec()));
+        }
+        let is_uncompressed_position = (*b.first().unwrap_or(&0) as char).is_numeric();
+        if is_uncompressed_position {
+            if b.len() < 19 {
+                return Err(DecodeError::InvalidPosition(b.to_vec()));
+            }
+            let (latitude, precision) = Latitude::parse_uncompressed(&b[0..8])?;
+            let longitude = Longitude::parse_uncompressed(&b[9..18], precision)?;
+
+            let symbol_table = b[8] as char;
+            let symbol_code = b[18] as char;
+
+            Ok((
+                b.get(19..),
+                Self {
+                    latitude,
+                    longitude,
+                    precision,
+                    symbol_code,
+                    symbol_table,
+                    cst: AprsCst::Uncompressed,
+                },
+            ))
+        } else {
+            if b.len() < 13 {
+                return Err(DecodeError::InvalidPosition(b.to_vec()));
+            }
+            let symbol_table = b[0] as char;
+            let comp_lat = &b[1..5];
+            let comp_lon = &b[5..9];
+            let symbol_code = b[9] as char;
+            let course_speed = &b[10..12];
+            let comp_type = b[12];
+
+            b.take(12);
+
+            let latitude = Latitude::parse_compressed(comp_lat)?;
+            let longitude = Longitude::parse_compressed(comp_lon)?;
+
+            // From the APRS spec - if the c value is a space,
+            // the csT doesn't matter
+            let cst = match course_speed[0] {
+                b' ' => AprsCst::CompressedNone,
+                _ => {
+                    let t = comp_type
+                        .checked_sub(33)
+                        .ok_or_else(|| DecodeError::InvalidPosition(b.to_owned()))?
+                        .into();
+                    let cs = AprsCompressedCs::parse(course_speed[0], course_speed[1], t)?;
+                    AprsCst::CompressedSome { cs, t }
+                }
+            };
+            Ok((
+                b.get(13..),
+                Self {
+                    latitude,
+                    longitude,
+                    precision: Precision::default(),
+                    symbol_code,
+                    symbol_table,
+                    cst,
+                },
+            ))
+        }
+    }
+}

src/components/position.rs

@@ -1,5 +1,6 @@
 use Callsign;
 
+use crate::Extension;
 #[derive(Debug, Eq, PartialEq, thiserror::Error)]
 pub enum DecodeError {
     #[error("Invalid Callsign: {0:?}")]
@@ -28,6 +29,33 @@ pub enum DecodeError {
     InvalidMicEDestination(Callsign),
     #[error("Invalid Mic-E information field: {0:?}")]
     InvalidMicEInformation(Vec<u8>),
+    #[error("Invalid Object name {0:?}")]
+    InvalidObjectName(Vec<u8>),
+    #[error("Invalid Object liveness, expected '*' or '(space)', got '{0:?}'")]
+    InvalidObjectLiveness(char),
+    #[error("Invalid Object format")]
+    InvalidObject,
+    #[error("Invalid Item format")]
+    InvalidItem,
+    #[error("Invalid Item name {0:?}")]
+    InvalidItemName(Vec<u8>),
+    #[error("Invalid Item liveness, expected '!' or '(space)', got '{0:?}'")]
+    InvalidItemLiveness(char),
+    #[error("Invalid Extension data: {0:?}")]
+    InvalidExtension(Vec<u8>),
+
+    #[error("Invalid Extension Range value: {0:?}")]
+    InvalidExtensionRange(Vec<u8>),
+
+    #[error("Invalid Extension Direction/Speed value: {0:?}")]
+    InvalidExtensionDirectionSpeed(Vec<u8>),
+    #[error("Invalid Extension PHG value: {0:?}")]
+    InvalidExtensionPhg(Vec<u8>),
+    #[error("Invalid Extension DFS value: {0:?}")]
+    InvalidExtensionDfs(Vec<u8>),
+
+    #[error("Invalid Extension Area value: {0:?}")]
+    InvalidExtensionArea(Vec<u8>),
 }
 
 #[derive(Debug, thiserror::Error)]
@@ -46,4 +74,7 @@ pub enum EncodeError {
     NonGgaAltitude,
     #[error(transparent)]
     Write(#[from] std::io::Error),
+
+    #[error("Invalid Extension value: {0:?}")]
+    InvalidExtension(Extension),
 }