Refactor parsing to use slice::chunks_exact

This avoids doing manual offset handling and for loops, and instead
iterates on a chunked view of the data, which is easier to maintain.

Author: boivie

src/packet/forward_tsn_chunk.rs

@@ -62,16 +62,15 @@ impl TryFrom<RawChunk<'_>> for ForwardTsnChunk {
         ensure!(raw.value.len() >= 4 && (raw.value.len() % 4) == 0, ChunkParseError::InvalidLength);
 
         let new_cumulative_tsn = Tsn(read_u32_be!(&raw.value[0..4]));
-        let num_skipped = (raw.value.len() - 4) / 4;
 
-        let mut skipped_streams = Vec::<SkippedStream>::with_capacity(num_skipped);
-        let mut offset = 4;
-        for _ in 0..num_skipped {
-            let stream_id = StreamId(read_u16_be!(&raw.value[offset..offset + 2]));
-            let ssn = Ssn(read_u16_be!(&raw.value[offset + 2..offset + 4]));
-            skipped_streams.push(SkippedStream::ForwardTsn(stream_id, ssn));
-            offset += 4;
-        }
+        let skipped_streams = raw.value[4..]
+            .chunks_exact(4)
+            .map(|c| {
+                let stream_id = StreamId(read_u16_be!(&c[0..2]));
+                let ssn = Ssn(read_u16_be!(&c[2..4]));
+                SkippedStream::ForwardTsn(stream_id, ssn)
+            })
+            .collect();
 
         Ok(Self { new_cumulative_tsn, skipped_streams })
     }

src/packet/iforward_tsn_chunk.rs

@@ -70,18 +70,16 @@ impl TryFrom<RawChunk<'_>> for IForwardTsnChunk {
         );
 
         let new_cumulative_tsn = Tsn(read_u32_be!(&raw.value[0..4]));
-        let num_skipped = (raw.value.len() - 4) / 8;
 
-        let mut skipped_streams = Vec::<SkippedStream>::with_capacity(num_skipped);
-        let mut offset = 4;
-        for _ in 0..num_skipped {
-            let stream_id = StreamId(read_u16_be!(&raw.value[offset..offset + 2]));
-            let is_unordered = (raw.value[offset + 3] & 1) != 0;
-            let mid = Mid(read_u32_be!(&raw.value[offset + 4..offset + 8]));
-            skipped_streams
-                .push(SkippedStream::IForwardTsn(StreamKey::from(is_unordered, stream_id), mid));
-            offset += 8;
-        }
+        let skipped_streams = raw.value[4..]
+            .chunks_exact(8)
+            .map(|c| {
+                let stream_id = StreamId(read_u16_be!(&c[0..2]));
+                let is_unordered = (c[3] & 1) != 0;
+                let mid = Mid(read_u32_be!(&c[4..8]));
+                SkippedStream::IForwardTsn(StreamKey::from(is_unordered, stream_id), mid)
+            })
+            .collect();
 
         Ok(Self { new_cumulative_tsn, skipped_streams })
     }

src/packet/incoming_ssn_reset_request_parameter.rs

@@ -58,9 +58,7 @@ impl TryFrom<RawParameter<'_>> for IncomingSsnResetRequestParameter {
         ensure!(raw.value.len() >= 4 && (raw.value.len() % 2) == 0, ChunkParseError::InvalidLength);
 
         let request_seq_nbr = read_u32_be!(&raw.value[0..4]);
-        let streams = (0..(raw.value.len() - 4) / 2)
-            .map(|i| StreamId(read_u16_be!(&raw.value[4 + i * 2..4 + i * 2 + 2])))
-            .collect();
+        let streams = raw.value[4..].chunks_exact(2).map(|c| StreamId(read_u16_be!(c))).collect();
 
         Ok(Self { request_seq_nbr, streams })
     }

src/packet/outgoing_ssn_reset_request_parameter.rs

@@ -67,9 +67,7 @@ impl TryFrom<RawParameter<'_>> for OutgoingSsnResetRequestParameter {
             ChunkParseError::InvalidLength
         );
 
-        let streams = (0..(raw.value.len() - 12) / 2)
-            .map(|i| StreamId(read_u16_be!(&raw.value[12 + i * 2..12 + i * 2 + 2])))
-            .collect();
+        let streams = raw.value[12..].chunks_exact(2).map(|c| StreamId(read_u16_be!(c))).collect();
 
         Ok(Self {
             request_seq_nbr: read_u32_be!(&raw.value[0..4]),

src/packet/sack_chunk.rs

@@ -95,20 +95,21 @@ impl TryFrom<RawChunk<'_>> for SackChunk {
             ChunkParseError::InvalidLength
         );
 
-        let mut gap_ack_blocks = Vec::<GapAckBlock>::with_capacity(nbr_of_gap_blocks);
-        let mut offset = 12;
-        for _ in 0..nbr_of_gap_blocks {
-            let start = read_u16_be!(&raw.value[offset..offset + 2]);
-            let end = read_u16_be!(&raw.value[offset + 2..offset + 4]);
-            gap_ack_blocks.push(GapAckBlock { start, end });
-            offset += 4;
-        }
-
-        let mut duplicate_tsns = Vec::<Tsn>::with_capacity(nbr_of_dup_tsns);
-        for _ in 0..nbr_of_dup_tsns {
-            duplicate_tsns.push(Tsn(read_u32_be!(&raw.value[offset..offset + 4])));
-            offset += 4;
-        }
+        let gap_blocks_end = 12 + nbr_of_gap_blocks * 4;
+        let gap_ack_blocks_data = &raw.value[12..gap_blocks_end];
+        let duplicate_tsns_data = &raw.value[gap_blocks_end..];
+
+        let gap_ack_blocks = gap_ack_blocks_data
+            .chunks_exact(4)
+            .map(|c| {
+                let start = read_u16_be!(&c[0..2]);
+                let end = read_u16_be!(&c[2..4]);
+                GapAckBlock { start, end }
+            })
+            .collect();
+
+        let duplicate_tsns =
+            duplicate_tsns_data.chunks_exact(4).map(|c| Tsn(read_u32_be!(c))).collect();
 
         Ok(Self { cumulative_tsn_ack, a_rwnd, gap_ack_blocks, duplicate_tsns })
     }