add parameter reading

src/full_parser/mod.rs

@@ -195,4 +195,10 @@ mod tests {
         );
         read_file(&filename).unwrap();
     }
+
+    #[test]
+    fn reads_other_log_file() {
+        let filename = format!("{}/tests/fixtures/sample.ulg", env!("CARGO_MANIFEST_DIR"));
+        read_file(&filename).unwrap();
+    }
 }

src/stream_parser/file_reader.rs

@@ -11,7 +11,9 @@ use std::sync::Arc;
 use super::model;
 use crate::unpack;
 
-use self::model::{DataMessage, FlattenedField, FlattenedFieldType, FlattenedFormat, MultiId};
+use self::model::{
+    DataMessage, FlattenedField, FlattenedFieldType, FlattenedFormat, MultiId, ParameterMessage,
+};
 
 #[derive(Debug, PartialEq)]
 enum ParseStatus {
@@ -85,6 +87,7 @@ impl DataFormat {
 pub struct LogParser<'c> {
     data_message_callback: Option<&'c mut FnMut(&model::DataMessage)>,
     logged_string_message_callback: Option<&'c mut FnMut(&model::LoggedStringMessage)>,
+    parameter_message_callback: Option<&'c mut FnMut(&model::ParameterMessage)>,
     version: u8,
     timestamp: u64,
     leftover: Vec<u8>,
@@ -127,6 +130,12 @@ impl<'c> LogParser<'c> {
     ) {
         self.logged_string_message_callback = Some(c)
     }
+    pub fn set_parameter_message_callback<CB: FnMut(&model::ParameterMessage)>(
+        &mut self,
+        c: &'c mut CB,
+    ) {
+        self.parameter_message_callback = Some(c)
+    }
     pub fn consume_bytes(&mut self, mut buf: &[u8]) -> Result<(), UlogParseError> {
         if !self.leftover.is_empty() {
             assert!(self.leftover.len() < MAX_MESSAGE_SIZE);
@@ -257,6 +266,63 @@ impl<'c> LogParser<'c> {
                 self.flattened_format
                     .register_msg_id(msg_id, message_name, multi_id)?;
             }
+            model::MessageType::Parameter => {
+                let log_stage = match self.status {
+                    ParseStatus::Beginning => {
+                        return Err(UlogParseError::new(
+                            ParseErrorType::Other,
+                            "parameter message encountered bad status",
+                        ));
+                    }
+                    ParseStatus::AfterHeader => {
+                        self.status = ParseStatus::InDefinitions;
+                        model::LogStage::Definitions
+                    }
+                    ParseStatus::InDefinitions => model::LogStage::Definitions,
+                    ParseStatus::InData => model::LogStage::Data,
+                };
+                let key_len = msg.data[0];
+                let value_bytes = &msg.data()[(1 + key_len as usize)..];
+                if value_bytes.len() != 4 {
+                    return Err(UlogParseError::new(
+                        ParseErrorType::Other,
+                        "parameter message with wrong size encountered",
+                    ));
+                }
+                let key =
+                    std::str::from_utf8(&msg.data()[1..(1 + key_len as usize)]).map_err(|_| {
+                        UlogParseError::new(
+                            ParseErrorType::Other,
+                            "parameter format message is not a string",
+                        )
+                    })?;
+                let parts: Vec<&str> = key.split(" ").collect();
+                if parts.len() != 2 {
+                    return Err(UlogParseError::new(
+                        ParseErrorType::Other,
+                        "parameter format message is not a string",
+                    ));
+                }
+                let parameter_message = match parts[0] {
+                    "int32_t" => Ok(ParameterMessage::Int32(
+                        parts[1],
+                        unpack::as_i32_le(value_bytes),
+                        log_stage,
+                    )),
+                    "float" => Ok(ParameterMessage::Float(
+                        parts[1],
+                        unpack::as_f32_le(value_bytes),
+                        log_stage,
+                    )),
+                    _ => Err(UlogParseError::new(
+                        ParseErrorType::Other,
+                        "parameter format message unexpected type",
+                    )),
+                }?;
+                if let Some(cb) = &mut self.parameter_message_callback {
+                    cb(&parameter_message);
+                }
+            }
             model::MessageType::Logging => {
                 self.transition_to_data_section_if_necessary(msg.msg_type())?;
                 if msg.data.len() < 9 {
@@ -715,6 +781,7 @@ pub enum SimpleCallbackResult {
 pub enum Message<'a> {
     Data(&'a model::DataMessage<'a>),
     LoggedMessage(&'a model::LoggedStringMessage<'a>),
+    ParameterMessage(&'a model::ParameterMessage<'a>),
 }
 
 pub fn read_file_with_simple_callback<CB: FnMut(&Message) -> SimpleCallbackResult>(
@@ -737,9 +804,17 @@ pub fn read_file_with_simple_callback<CB: FnMut(&Message) -> SimpleCallbackResul
             stop_reading.store(true, Ordering::Relaxed)
         }
     };
+    let mut wrapped_parameter_message_callback = |parameter_message: &model::ParameterMessage| {
+        if let SimpleCallbackResult::Stop =
+            c_cell.as_ref().borrow_mut().deref_mut()(&Message::ParameterMessage(&parameter_message))
+        {
+            stop_reading.store(true, Ordering::Relaxed)
+        }
+    };
     let mut log_parser = LogParser::default();
     log_parser.set_data_message_callback(&mut wrapped_data_message_callback);
     log_parser.set_logged_string_message_callback(&mut wrapped_string_message_callback);
+    log_parser.set_parameter_message_callback(&mut wrapped_parameter_message_callback);
 
     let mut total_bytes_read: usize = 0;
     let mut f = std::fs::File::open(file_path)?;

src/stream_parser/mod.rs

@@ -6,6 +6,8 @@ pub use self::file_reader::read_file_with_simple_callback;
 pub use self::file_reader::LogParser;
 pub use self::file_reader::Message;
 pub use self::model::DataMessage;
+pub use self::model::LogStage;
+pub use self::model::ParameterMessage;
 pub use self::model::FieldParser;
 pub use self::model::LoggedStringMessage;
 pub use self::model::ParseableFieldType;

src/stream_parser/model.rs

@@ -213,6 +213,18 @@ pub struct DataMessage<'a> {
     pub data: &'a [u8], // this includes the bytes of the msg_id.
 }
 
+#[derive(Debug)]
+pub enum LogStage {
+    Definitions,
+    Data,
+}
+
+#[derive(Debug)]
+pub enum ParameterMessage<'a> {
+    Float(&'a str, f32, LogStage),
+    Int32(&'a str, i32, LogStage),
+}
+
 pub struct LoggedStringMessage<'a> {
     pub log_level: u8,
     pub timestamp: u64,