rename functions

src/decoder/adsb/acas.rs

@@ -17,7 +17,7 @@ mod tests {
     #[test]
     fn test_threat_encounter() {
         let squitter = "8D40621D58C382D690C8AC2863A7";
-        if let Some(message) = decoder::message(squitter) {
+        if let Some(message) = decoder::get_message(squitter) {
             assert_eq!(threat_encounter(&message), Some('\u{2072}'));
         }
     }

src/decoder/adsb/ais.rs

@@ -46,12 +46,12 @@ pub(crate) fn ais(message: &[u32]) -> Option<String> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::decoder::message;
+    use crate::decoder::get_message;
 
     #[test]
     fn test_ais() {
         let squitter = "8DAAAA9225041331DF3820CAC7A4";
-        if let Some(message) = message(squitter) {
+        if let Some(message) = get_message(squitter) {
             if let Some(result) = ais(&message) {
                 assert_eq!(result, "AAL173");
             }
@@ -66,7 +66,7 @@ mod tests {
         ];
 
         for (squitter, value) in squitters.iter() {
-            if let Some(message) = message(squitter) {
+            if let Some(message) = get_message(squitter) {
                 let result = ais(&message);
                 match result {
                     Some(r) => assert_eq!(r.as_str(), *value, "{}", squitter),

src/decoder/adsb/altitude.rs

@@ -24,7 +24,7 @@ pub fn altitude(message: &[u32], df: u32) -> Option<u32> {
                 "DF:{} C:{:b} M:{} ALT:{}",
                 df,
                 code?,
-                crate::decoder::hex_message(message),
+                crate::decoder::get_hex_message(message),
                 a
             );
             None
@@ -61,17 +61,17 @@ mod tests {
 
     #[test]
     fn test_alt() {
-        if let Some(message) = decoder::message("A8281200200464B3CF7820CD194C") {
-            let df = decoder::df(&message).expect("Failed to get downlink format");
+        if let Some(message) = decoder::get_message("A8281200200464B3CF7820CD194C") {
+            let df = decoder::get_downlink_format(&message).expect("Failed to get downlink format");
             let result = altitude(&message, df);
             assert_eq!(result, Some(14300));
         }
     }
 
     #[test]
     fn test_alt_e() {
-        if let Some(message) = decoder::message("A020100A10020A80F000004F24AF") {
-            let df = decoder::df(&message).expect("Failed to get downlink format");
+        if let Some(message) = decoder::get_message("A020100A10020A80F000004F24AF") {
+            let df = decoder::get_downlink_format(&message).expect("Failed to get downlink format");
             let result = altitude(&message, df);
             assert_eq!(result, None);
         }

src/decoder/adsb/altitude/graytobin.rs

@@ -56,7 +56,7 @@ mod tests {
 
     #[test]
     fn test_graytobin() {
-        if let Some(message) = decoder::message("A8281200200464B3CF7820CD194C") {
+        if let Some(message) = decoder::get_message("A8281200200464B3CF7820CD194C") {
             let (high, low) = graytobin(&message);
             assert_eq!(high, 31);
             assert_eq!(low, 0);
@@ -65,7 +65,7 @@ mod tests {
 
     #[test]
     fn test_graytobin_e() {
-        if let Some(message) = decoder::message("A020100A10020A80F000004F24AF") {
+        if let Some(message) = decoder::get_message("A020100A10020A80F000004F24AF") {
             let (high, low) = graytobin(&message);
             assert_eq!(high, 2);
             assert_eq!(low, 0);

src/decoder/adsb/icao.rs

@@ -14,9 +14,9 @@ use crate::decoder::get_crc;
 /// # Examples
 ///
 /// ```
-/// use squitterator::{message, df, icao};
-/// if let Some(message) = message("A0001838300000000000007ADA59") {
-///     if let Some(df) = df(&message) {
+/// use squitterator::{get_message, get_downlink_format, icao};
+/// if let Some(message) = get_message("A0001838300000000000007ADA59") {
+///     if let Some(df) = get_downlink_format(&message) {
 ///         if let Some(icao_address) = icao(&message, df) {
 ///             assert_eq!(icao_address, 7453696);
 ///         }
@@ -59,7 +59,7 @@ pub(crate) fn icao_wtc(vc: &(u32, u32)) -> Option<char> {
 
 #[cfg(test)]
 mod tests {
-    use crate::decoder::{df, icao, message};
+    use crate::decoder::{get_downlink_format, get_message, icao};
 
     #[test]
     fn test_icao() {
@@ -79,8 +79,8 @@ mod tests {
         ];
 
         for (squitter, value) in squitters.iter() {
-            if let Some(message) = message(squitter) {
-                if let Some(df) = df(&message) {
+            if let Some(message) = get_message(squitter) {
+                if let Some(df) = get_downlink_format(&message) {
                     if let Some(result) = icao(&message, df) {
                         assert_eq!(result, *value, "Squitter: {} ICAO:{:X}", squitter, result);
                     }

src/decoder/adsb/squawk.rs

@@ -23,7 +23,7 @@ pub(crate) fn squawk(message: &[u32]) -> Option<u32> {
 
 #[cfg(test)]
 mod tests {
-    use crate::decoder::{message, squawk};
+    use crate::decoder::{get_message, squawk};
 
     #[test]
     fn test_squawk() {
@@ -40,7 +40,7 @@ mod tests {
         ];
 
         for (squitter, value) in squitters.iter() {
-            if let Some(message) = message(squitter) {
+            if let Some(message) = get_message(squitter) {
                 let result = squawk(&message);
                 assert_eq!(result, Some(*value));
             }

src/decoder/bds.rs

@@ -58,20 +58,20 @@ pub(crate) fn goodflags(message: &[u32], flag: u32, sb: u32, eb: u32) -> bool {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::decoder::message;
+    use crate::decoder::get_message;
 
     #[test]
     fn test_bds() {
         let squitter = "8D40621D58C382D690C8AC2863A7";
-        if let Some(message) = message(squitter) {
+        if let Some(message) = get_message(squitter) {
             assert_eq!(bds(&message), (0, 0));
         }
     }
 
     #[test]
     fn test_bds_21() {
         let squitter = "A8000096300000000000007F5EBC";
-        if let Some(message) = message(squitter) {
+        if let Some(message) = get_message(squitter) {
             assert_eq!(bds(&message), (3, 0));
         }
     }

src/decoder/bds/bds_4_4.rs

@@ -63,7 +63,7 @@ pub fn is_bds_4_4(message: &[u32]) -> Option<Meteo> {
         );
         debug!(
             "DF:{} F:{:b} {:?}",
-            decoder::df(message)?,
+            decoder::get_downlink_format(message)?,
             decoder::range_value(message, 33, 36)?,
             meteo
         );

src/decoder/downlink.rs

@@ -22,46 +22,46 @@ use crate::range_value;
 /// # Examples
 ///
 /// ```
-/// use squitterator::{message, df};
+/// use squitterator::{get_message, get_downlink_format};
 /// let squitter = "8D40621D58C382D690C8AC2863A7";
-/// if let Some(message) = message(squitter) {
-///     if let Some(df) = df(&message) {
+/// if let Some(message) = get_message(squitter) {
+///     if let Some(df) = get_downlink_format(&message) {
 ///         assert_eq!(df, 17);
 ///     }
 /// }
 /// ```
-pub fn df(message: &[u32]) -> Option<u32> {
+pub fn get_downlink_format(message: &[u32]) -> Option<u32> {
     range_value(message, 1, 5)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::decoder::message;
+    use crate::decoder::get_message;
 
     #[test]
     fn test_df_17() {
         let squitter = "8D40621D58C382D690C8AC2863A7";
-        if let Some(message) = message(squitter) {
-            let result = df(&message).unwrap_or(0);
+        if let Some(message) = get_message(squitter) {
+            let result = get_downlink_format(&message).unwrap_or(0);
             assert_eq!(result, 17);
         }
     }
 
     #[test]
     fn test_df_21() {
         let squitter = "A8281200200464B3CF7820CD194C";
-        if let Some(message) = message(squitter) {
-            let result = df(&message).unwrap_or(0);
+        if let Some(message) = get_message(squitter) {
+            let result = get_downlink_format(&message).unwrap_or(0);
             assert_eq!(result, 21);
         }
     }
 
     #[test]
     fn test_df_22() {
         let squitter = "A020100A10020A80F000004F24AF";
-        if let Some(message) = message(squitter) {
-            let result = df(&message).unwrap_or(0);
+        if let Some(message) = get_message(squitter) {
+            let result = get_downlink_format(&message).unwrap_or(0);
             assert_eq!(result, 20);
         }
     }

src/decoder/downlink/dfs.rs

@@ -7,7 +7,7 @@ use std::{
 
 use log::debug;
 
-use super::{df, Ext, Mds, Srt};
+use super::{get_downlink_format, Ext, Mds, Srt};
 
 #[derive(Debug)]
 pub enum DF {
@@ -49,13 +49,13 @@ impl DF {
 }
 
 impl Downlink for DF {
-    fn from_message(message: &[u32]) -> Result<Self, &str> {
-        match df(message) {
+    fn from_get_message(message: &[u32]) -> Result<Self, &str> {
+        match get_downlink_format(message) {
             Some(value) => {
                 let dl = match value {
-                    0..=16 => DF::SRT(Srt::from_message(message)?),
-                    17 => DF::EXT(Ext::from_message(message)?),
-                    20 | 21 => DF::MDS(Mds::from_message(message)?),
+                    0..=16 => DF::SRT(Srt::from_get_message(message)?),
+                    17 => DF::EXT(Ext::from_get_message(message)?),
+                    20 | 21 => DF::MDS(Mds::from_get_message(message)?),
                     _ => DF::SRT(Srt::new()),
                 };
                 Ok(dl)
@@ -82,7 +82,7 @@ impl Downlink for DF {
 }
 
 pub trait Downlink: Sized {
-    fn from_message(message: &[u32]) -> Result<Self, &str>;
+    fn from_get_message(message: &[u32]) -> Result<Self, &str>;
     fn update(&mut self, message: &[u32]);
     fn icao(&self) -> Option<u32>;
 }

src/decoder/downlink/extended/update.rs

@@ -55,18 +55,18 @@ impl Ext {
 }
 
 impl decoder::Downlink for Ext {
-    fn from_message(message: &[u32]) -> Result<Self, &str> {
+    fn from_get_message(message: &[u32]) -> Result<Self, &str> {
         let mut dl = Ext::new();
         dl.update(message);
         Ok(dl)
     }
 
     fn update(&mut self, message: &[u32]) {
-        if let Some(df) = decoder::df(message) {
+        if let Some(df) = decoder::get_downlink_format(message) {
             self.df = Some(df);
             self.icao = decoder::icao(message, df);
-            self.capability = decoder::ca(message);
-            self.message_type = decoder::message_type(message);
+            self.capability = decoder::get_capability(message);
+            self.message_type = decoder::get_message_type(message);
             match self.message_type.0 {
                 1..=4 => {
                     self.update_mt_1_4(message);

src/decoder/downlink/mode_s.rs

@@ -93,14 +93,14 @@ impl Display for Mds {
 }
 
 impl decoder::Downlink for Mds {
-    fn from_message(message: &[u32]) -> Result<Self, &str> {
+    fn from_get_message(message: &[u32]) -> Result<Self, &str> {
         let mut dl = Mds::new();
         dl.update(message);
         Ok(dl)
     }
 
     fn update(&mut self, message: &[u32]) {
-        if let Some(df) = decoder::df(message) {
+        if let Some(df) = decoder::get_downlink_format(message) {
             self.df = Some(df);
             self.icao = decoder::icao(message, df);
             self.altitude = decoder::altitude(message, df);

src/decoder/downlink/short.rs

@@ -59,14 +59,14 @@ impl Display for Srt {
 }
 
 impl decoder::Downlink for Srt {
-    fn from_message(message: &[u32]) -> Result<Self, &str> {
+    fn from_get_message(message: &[u32]) -> Result<Self, &str> {
         let mut dl = Srt::new();
         dl.update(message);
         Ok(dl)
     }
 
     fn update(&mut self, message: &[u32]) {
-        if let Some(df) = decoder::df(message) {
+        if let Some(df) = decoder::get_downlink_format(message) {
             self.df = Some(df);
             self.icao = decoder::icao(message, df);
             match df {
@@ -77,7 +77,7 @@ impl decoder::Downlink for Srt {
                     self.squawk = decoder::squawk(message);
                 }
                 11 => {
-                    self.capability = Some(decoder::ca(message));
+                    self.capability = Some(decoder::get_capability(message));
                 }
                 _ => {}
             }

src/decoder/ehs/base.rs

@@ -44,7 +44,7 @@ mod tests {
 
     #[test]
     fn test_track_and_groundspeed() {
-        if let Some(message) = decoder::message("8DC06A75990D0628B0040C8AA788") {
+        if let Some(message) = decoder::get_message("8DC06A75990D0628B0040C8AA788") {
             if let (Some(track), Some(groundspeed)) = track_and_groundspeed(&message, false) {
                 assert_eq!(groundspeed, 416);
                 assert_eq!(track, 321);

src/decoder/ehs/bds_4_0.rs

@@ -1,9 +1,9 @@
 use log::debug;
 
-use crate::decoder::{flag_and_range_value, hex_message};
+use crate::decoder::{flag_and_range_value, get_hex_message};
 
 pub(crate) fn mcp_selected_altitude(message: &[u32]) -> Option<u32> {
-    debug!("MCP, {}", hex_message(message));
+    debug!("MCP, {}", get_hex_message(message));
     flag_and_range_value(message, 33, 34, 45)
         .filter(|&f| f.0 == 1)
         .map(|v| v.1 << 4)
@@ -36,7 +36,7 @@ pub(crate) fn target_altitude_source(message: &[u32]) -> Option<u32> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::decoder::message;
+    use crate::decoder::get_message;
     #[test]
     fn test_mcp_selected_altitude_value() {
         let s = [
@@ -45,7 +45,7 @@ mod tests {
             ("A80004BAB8AE4270A80000823C66", 29008),
         ];
         for (squitter, value) in s.iter() {
-            if let Some(message) = message(squitter) {
+            if let Some(message) = get_message(squitter) {
                 assert_eq!(mcp_selected_altitude(&message), Some(*value as u32));
             }
         }
@@ -59,7 +59,7 @@ mod tests {
             ("A80004BAB8AE4270A80000823C66", 37008),
         ];
         for (squitter, value) in s.iter() {
-            if let Some(message) = message(squitter) {
+            if let Some(message) = get_message(squitter) {
                 assert_eq!(fms_selected_altitude(&message), Some(*value as u32));
             }
         }

src/decoder/plane.rs

@@ -118,7 +118,7 @@ impl Plane {
         }
     }
 
-    pub fn from_message(message: &[u32], df: u32, icao: u32, relaxed: bool) -> Self {
+    pub fn from_get_message(message: &[u32], df: u32, icao: u32, relaxed: bool) -> Self {
         let mut plane = Plane::new();
         plane.icao = icao;
         (_, plane.reg) = super::icao_to_country(icao);

src/decoder/plane/from_squitter/from_bcast.rs

@@ -12,7 +12,7 @@ impl Plane {
         }
 
         if df == 11 || df == 17 {
-            self.capability.0 = decoder::ca(message);
+            self.capability.0 = decoder::get_capability(message);
         }
     }
 }