Refactor serializing to use chunks_exact_mut

This replaces the old offset handling and for loops with iterators
operating on a chunked view of the data.

Author: boivie

src/packet/forward_tsn_chunk.rs

@@ -81,16 +81,15 @@ impl SerializableTlv for ForwardTsnChunk {
         let value = write_chunk_header(CHUNK_TYPE, 0, self.value_size(), output);
         write_u32_be!(&mut value[0..4], self.new_cumulative_tsn.0);
 
-        let mut offset = 4;
-        for skipped in &self.skipped_streams {
+        let mut chunks = value[4..].chunks_exact_mut(4);
+        for (skipped, chunk) in self.skipped_streams.iter().zip(&mut chunks) {
             match skipped {
                 SkippedStream::ForwardTsn(stream_id, ssn) => {
-                    write_u16_be!(&mut value[offset..offset + 2], stream_id.0);
-                    write_u16_be!(&mut value[offset + 2..offset + 4], ssn.0);
+                    write_u16_be!(&mut chunk[0..2], stream_id.0);
+                    write_u16_be!(&mut chunk[2..4], ssn.0);
                 }
                 _ => panic!("Unsupported skipped stream"),
             }
-            offset += 4;
         }
     }
 

src/packet/iforward_tsn_chunk.rs

@@ -90,18 +90,17 @@ impl SerializableTlv for IForwardTsnChunk {
         let value = write_chunk_header(CHUNK_TYPE, 0, self.value_size(), output);
         write_u32_be!(&mut value[0..4], self.new_cumulative_tsn.0);
 
-        let mut offset = 4;
-        for skipped in &self.skipped_streams {
+        let mut chunks = value[4..].chunks_exact_mut(8);
+        for (skipped, chunk) in self.skipped_streams.iter().zip(&mut chunks) {
             match skipped {
                 SkippedStream::IForwardTsn(stream_key, mid) => {
-                    write_u16_be!(&mut value[offset..offset + 2], stream_key.id().0);
-                    value[offset + 2] = 0;
-                    value[offset + 3] = if stream_key.is_unordered() { 1 } else { 0 };
-                    write_u32_be!(&mut value[offset + 4..offset + 8], mid.0);
+                    write_u16_be!(&mut chunk[0..2], stream_key.id().0);
+                    chunk[2] = 0;
+                    chunk[3] = if stream_key.is_unordered() { 1 } else { 0 };
+                    write_u32_be!(&mut chunk[4..8], mid.0);
                 }
                 _ => panic!("Unsupported skipped stream"),
             }
-            offset += 8;
         }
     }
 

src/packet/incoming_ssn_reset_request_parameter.rs

@@ -68,8 +68,9 @@ impl SerializableTlv for IncomingSsnResetRequestParameter {
     fn serialize_to(&self, output: &mut [u8]) {
         let value = write_parameter_header(PARAMETER_TYPE, self.value_size(), output);
         write_u32_be!(&mut value[0..4], self.request_seq_nbr);
-        for (idx, stream_id) in self.streams.iter().enumerate() {
-            write_u16_be!(&mut value[4 + idx * 2..4 + idx * 2 + 2], stream_id.0);
+        let mut chunks = value[4..].chunks_exact_mut(2);
+        for (stream_id, chunk) in self.streams.iter().zip(&mut chunks) {
+            write_u16_be!(chunk, stream_id.0);
         }
     }
 

src/packet/outgoing_ssn_reset_request_parameter.rs

@@ -84,8 +84,9 @@ impl SerializableTlv for OutgoingSsnResetRequestParameter {
         write_u32_be!(&mut value[0..4], self.request_seq_nbr);
         write_u32_be!(&mut value[4..8], self.response_seq_nbr);
         write_u32_be!(&mut value[8..12], self.sender_last_assigned_tsn.0);
-        for (idx, stream_id) in self.streams.iter().enumerate() {
-            write_u16_be!(&mut value[12 + idx * 2..12 + idx * 2 + 2], stream_id.0);
+        let mut chunks = value[12..].chunks_exact_mut(2);
+        for (stream_id, chunk) in self.streams.iter().zip(&mut chunks) {
+            write_u16_be!(chunk, stream_id.0);
         }
     }
 

src/packet/sack_chunk.rs

@@ -123,16 +123,17 @@ impl SerializableTlv for SackChunk {
         write_u16_be!(&mut value[8..10], self.gap_ack_blocks.len() as u16);
         write_u16_be!(&mut value[10..12], self.duplicate_tsns.len() as u16);
 
-        let mut offset = 12;
-        for block in &self.gap_ack_blocks {
-            write_u16_be!(&mut value[offset..offset + 2], block.start);
-            write_u16_be!(&mut value[offset + 2..offset + 4], block.end);
-            offset += 4;
+        let gap_blocks_end = 12 + self.gap_ack_blocks.len() * 4;
+
+        let mut chunks = value[12..gap_blocks_end].chunks_exact_mut(4);
+        for (block, chunk) in self.gap_ack_blocks.iter().zip(&mut chunks) {
+            write_u16_be!(&mut chunk[0..2], block.start);
+            write_u16_be!(&mut chunk[2..4], block.end);
         }
 
-        for dup_tsn in &self.duplicate_tsns {
-            write_u32_be!(&mut value[offset..offset + 4], dup_tsn.0);
-            offset += 4;
+        let mut chunks = value[gap_blocks_end..].chunks_exact_mut(4);
+        for (dup_tsn, chunk) in self.duplicate_tsns.iter().zip(&mut chunks) {
+            write_u32_be!(chunk, dup_tsn.0);
         }
     }