Make Rust bindings compatiple with MXL 0.8.x

Signed-off-by: Pavel Cernohorsky <pavel.cernohorsky@appear.net>

Author: pac-work

rust/mxl/examples/flow-reader.rs

@@ -83,27 +83,27 @@ fn read_samples(
 ) -> Result<(), mxl::Error> {
     let flow_id = flow_info.common_flow_info().id().to_string();
     let sample_rate = flow_info.continuous_flow_info()?.sampleRate;
-    let continous_flow_info = flow_info.continuous_flow_info()?;
+    let common_flow_info = flow_info.common_flow_info();
     let batch_size = if let Some(batch_size) = batch_size {
-        if continous_flow_info.commitBatchSize != 0
-            && batch_size != continous_flow_info.commitBatchSize as u64
+        if common_flow_info.max_commit_batch_size_hint() != 0
+            && batch_size != common_flow_info.max_commit_batch_size_hint() as u64
         {
             warn!(
                 "Writer batch size is set to {}, but sample batch size is provided, using the \
-                latter.",
-                continous_flow_info.commitBatchSize
+                 latter.",
+                common_flow_info.max_commit_batch_size_hint()
             );
         }
         batch_size as usize
-    } else if continous_flow_info.commitBatchSize == 0 {
+    } else if common_flow_info.max_commit_batch_size_hint() == 0 {
         let batch_size = (sample_rate.numerator / (100 * sample_rate.denominator)) as usize;
         warn!(
             "Writer batch size not available, using fallback value of {}.",
             batch_size
         );
         batch_size
     } else {
-        continous_flow_info.commitBatchSize as usize
+        common_flow_info.max_commit_batch_size_hint() as usize
     };
     let mut read_head = reader.get_info()?.continuous_flow_info()?.headIndex;
     let mut read_head_valid_at = mxl_instance.get_time();

rust/mxl/examples/flow-writer.rs

@@ -86,17 +86,19 @@ pub fn write_grains(
         }
 
         let mut grain_writer_access = writer.open_grain(grain_index)?;
+        let total_slices = grain_writer_access.total_slices();
         let payload = grain_writer_access.payload_mut();
         let payload_len = payload.len();
         for (i, byte) in payload.iter_mut().enumerate() {
             *byte = ((i as u64 + grain_index) % 256) as u8;
         }
-        grain_writer_access.commit(payload_len as u32)?;
+        grain_writer_access.commit(total_slices)?;
 
         let timestamp = mxl_instance.index_to_timestamp(grain_index + 1, &grain_rate)?;
         let sleep_duration = mxl_instance.get_duration_until_index(grain_index + 1, &grain_rate)?;
         info!(
-            "Finished writing {payload_len} bytes into grain {grain_index}, will sleep for {:?} until timestamp {timestamp}.",
+            "Finished writing {payload_len} bytes ({total_slices} slices) into grain {grain_index}, will sleep \
+             for {:?} until timestamp {timestamp}.",
             sleep_duration
         );
         grain_index += 1;

rust/mxl/src/flow.rs

@@ -75,4 +75,8 @@ impl CommonFlowInfo<'_> {
     pub fn id(&self) -> Uuid {
         Uuid::from_bytes(self.0.id)
     }
+
+    pub fn max_commit_batch_size_hint(&self) -> u32 {
+        self.0.maxCommitBatchSizeHint
+    }
 }

rust/mxl/src/grain/reader.rs

@@ -49,7 +49,7 @@ impl GrainReader {
                     &mut payload_ptr,
                 ))?;
             }
-            if grain_info.commitedSize != grain_info.grainSize {
+            if grain_info.validSlices != grain_info.totalSlices {
                 // We don't need partial grains. Wait for the grain to be complete.
                 continue;
             }

rust/mxl/src/grain/write_access.rs

@@ -51,20 +51,20 @@ impl<'a> GrainWriteAccess<'a> {
         self.grain_info.grainSize
     }
 
-    pub fn committed_size(&self) -> u32 {
-        self.grain_info.commitedSize
+    pub fn total_slices(&self) -> u16 {
+        self.grain_info.totalSlices
     }
 
-    pub fn commit(mut self, commited_size: u32) -> Result<()> {
+    pub fn commit(mut self, valid_slices: u16) -> Result<()> {
         self.committed_or_canceled = true;
 
-        if commited_size > self.grain_info.grainSize {
+        if valid_slices > self.grain_info.totalSlices {
             return Err(Error::Other(format!(
-                "Commited size {} cannot exceed grain size {}.",
-                commited_size, self.grain_info.grainSize
+                "Valid slices {} cannot exceed total slices {}.",
+                valid_slices, self.grain_info.totalSlices
             )));
         }
-        self.grain_info.commitedSize = commited_size;
+        self.grain_info.validSlices = valid_slices;
 
         unsafe {
             Error::from_status(

rust/mxl/tests/basic_tests.rs

@@ -74,8 +74,8 @@ fn basic_mxl_grain_writing_reading() {
     let rate = flow_info.discrete_flow_info().unwrap().grainRate;
     let current_index = mxl_instance.get_current_index(&rate);
     let grain_write_access = grain_writer.open_grain(current_index).unwrap();
-    let grain_size = grain_write_access.max_size();
-    grain_write_access.commit(grain_size).unwrap();
+    let total_slices = grain_write_access.total_slices();
+    grain_write_access.commit(total_slices).unwrap();
     let grain_data = grain_reader
         .get_complete_grain(current_index, Duration::from_secs(5))
         .unwrap();