Add an iterator over the segment groups

Dealing with the index based group ranges is not ergonomic. Therefore
this commits adds an iterator that returns all the groups as views of
segment slices. Also segments that are not part of any groups become
pseudo-groups of single segments. The splits component should be able to
build on top of this.

Author: CryZe

src/run/mod.rs

@@ -31,7 +31,7 @@ pub use attempt::Attempt;
 pub use editor::{Editor, RenameError};
 pub use run_metadata::RunMetadata;
 pub use segment::Segment;
-pub use segment_groups::{SegmentGroup, SegmentGroups};
+pub use segment_groups::{SegmentGroup, SegmentGroupView, SegmentGroups, SegmentGroupsIter};
 pub use segment_history::SegmentHistory;
 
 use crate::comparison::{default_generators, personal_best, ComparisonGenerator};
@@ -236,6 +236,11 @@ impl Run {
         &mut self.segment_groups
     }
 
+    #[inline]
+    pub fn segment_groups_iter(&self) -> SegmentGroupsIter<'_, '_> {
+        self.segment_groups.iter_with(&self.segments)
+    }
+
     /// Pushes the segment provided to the end of the list of segments of this Run.
     #[inline]
     pub fn push_segment(&mut self, segment: Segment) {

src/run/segment_groups.rs

@@ -1,3 +1,11 @@
+use {
+    crate::Segment,
+    std::{
+        iter::Peekable,
+        slice::{self, Iter},
+    },
+};
+
 #[derive(Debug, Clone, PartialEq)]
 pub struct SegmentGroup {
     start: usize,
@@ -36,4 +44,79 @@ impl SegmentGroups {
             Err(group)
         }
     }
+
+    pub fn iter_with<'groups, 'segments>(
+        &'groups self,
+        segments: &'segments [Segment],
+    ) -> SegmentGroupsIter<'groups, 'segments> {
+        SegmentGroupsIter {
+            iter: self.0.iter().peekable(),
+            segments,
+            index: 0,
+        }
+    }
+}
+
+pub struct SegmentGroupView<'group, 'segments> {
+    name: Option<&'group str>,
+    segments: &'segments [Segment],
+    ending_segment: &'segments Segment,
+}
+
+impl<'group, 'segments> SegmentGroupView<'group, 'segments> {
+    pub fn group_name(&self) -> Option<&'group str> {
+        self.name
+    }
+
+    pub fn group_name_or_default<'a>(&self) -> &'a str
+    where
+        'group: 'a,
+        'segments: 'a,
+    {
+        self.name.unwrap_or_else(|| self.ending_segment.name())
+    }
+
+    pub fn segments(&self) -> &'segments [Segment] {
+        self.segments
+    }
+
+    pub fn ending_segment(&self) -> &'segments Segment {
+        self.ending_segment
+    }
+
+    pub fn len(&self) -> usize {
+        self.segments.len()
+    }
+}
+
+pub struct SegmentGroupsIter<'groups, 'segments> {
+    iter: Peekable<Iter<'groups, SegmentGroup>>,
+    segments: &'segments [Segment],
+    index: usize,
+}
+
+impl<'groups, 'segments> Iterator for SegmentGroupsIter<'groups, 'segments> {
+    type Item = SegmentGroupView<'groups, 'segments>;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        let index = self.index;
+        if self.iter.peek().map_or(true, |group| group.start > index) {
+            self.index += 1;
+            let ending_segment = self.segments.get(index)?;
+            Some(SegmentGroupView {
+                name: None,
+                segments: slice::from_ref(ending_segment),
+                ending_segment,
+            })
+        } else {
+            let group = self.iter.next()?;
+            self.index = group.end;
+            let segments = self.segments.get(group.start..group.end)?;
+            Some(SegmentGroupView {
+                name: group.name.as_ref().map(String::as_str),
+                segments,
+                ending_segment: segments.last().unwrap(),
+            })
+        }
+    }
 }