Added ability to extract subsequences

Author: amigin

src/sorted_vec/sorted_vec.rs

@@ -141,6 +141,37 @@ impl<TKey: Ord, TValue: EntityWithKey<TKey>> SortedVec<TKey, TValue> {
         }
     }
 
+    pub fn sub_sequence(&self, range: std::ops::Range<TKey>) -> Self
+    where
+        TValue: Clone,
+    {
+        let items = self.range(range).to_vec();
+        Self {
+            items,
+            itm: std::marker::PhantomData,
+        }
+    }
+
+    pub fn sub_sequence_by_index(&self, range: std::ops::Range<usize>) -> Self
+    where
+        TValue: Clone,
+    {
+        if range.start >= self.items.len() {
+            return Self::new();
+        }
+
+        let end = range.end.min(self.items.len());
+        if range.start >= end {
+            return Self::new();
+        }
+
+        let items = self.items[range.start..end].to_vec();
+        Self {
+            items,
+            itm: std::marker::PhantomData,
+        }
+    }
+
     pub fn get_from_key_to_up(&self, key: &TKey) -> &[TValue] {
         let result = self.items.binary_search_by(|itm| itm.get_key().cmp(key));
 
@@ -403,6 +434,47 @@ mod tests {
         );
     }
 
+    #[test]
+    fn test_sub_sequence() {
+        let mut vec = super::SortedVec::new();
+
+        vec.insert_or_replace(TestEntity { key: 1, value: 1 });
+        vec.insert_or_replace(TestEntity { key: 3, value: 3 });
+        vec.insert_or_replace(TestEntity { key: 4, value: 4 });
+        vec.insert_or_replace(TestEntity { key: 6, value: 6 });
+        vec.insert_or_replace(TestEntity { key: 7, value: 7 });
+
+        let sub = vec.sub_sequence(2..7);
+
+        assert_eq!(4, sub.len());
+        assert_eq!(
+            vec![3u8, 4u8, 6u8, 7u8],
+            sub.iter().map(|itm| itm.value).collect::<Vec<u8>>()
+        );
+    }
+
+    #[test]
+    fn test_sub_sequence_by_index() {
+        let mut vec = super::SortedVec::new();
+
+        vec.insert_or_replace(TestEntity { key: 1, value: 1 });
+        vec.insert_or_replace(TestEntity { key: 3, value: 3 });
+        vec.insert_or_replace(TestEntity { key: 4, value: 4 });
+        vec.insert_or_replace(TestEntity { key: 6, value: 6 });
+        vec.insert_or_replace(TestEntity { key: 7, value: 7 });
+
+        let sub = vec.sub_sequence_by_index(1..4);
+
+        assert_eq!(3, sub.len());
+        assert_eq!(
+            vec![3u8, 4u8, 6u8],
+            sub.iter().map(|itm| itm.value).collect::<Vec<u8>>()
+        );
+
+        let empty = vec.sub_sequence_by_index(10..20);
+        assert_eq!(0, empty.len());
+    }
+
     #[test]
     fn test_get_highest_and_amount() {
         let mut vec = super::SortedVec::new();

src/sorted_vec/sorted_vec_of_arc.rs

@@ -153,6 +153,37 @@ impl<TKey: Ord, TValue: EntityWithKey<TKey>> SortedVecOfArc<TKey, TValue> {
         }
     }
 
+    pub fn sub_sequence(&self, range: std::ops::Range<TKey>) -> Self
+    where
+        TValue: Clone,
+    {
+        let items = self.range(range).to_vec();
+        Self {
+            items,
+            itm: std::marker::PhantomData,
+        }
+    }
+
+    pub fn sub_sequence_by_index(&self, range: std::ops::Range<usize>) -> Self
+    where
+        TValue: Clone,
+    {
+        if range.start >= self.items.len() {
+            return Self::new();
+        }
+
+        let end = range.end.min(self.items.len());
+        if range.start >= end {
+            return Self::new();
+        }
+
+        let items = self.items[range.start..end].to_vec();
+        Self {
+            items,
+            itm: std::marker::PhantomData,
+        }
+    }
+
     pub fn truncate_capacity(&mut self, capacity: usize) {
         self.items.truncate(capacity);
     }

src/sorted_vec/sorted_vec_of_arc_with_str_key.rs

@@ -180,6 +180,31 @@ impl<TValue: EntityWithStrKey> SortedVecOfArcWithStrKey<TValue> {
         self.items.is_empty()
     }
 
+    pub fn sub_sequence(&self, range: std::ops::Range<&str>) -> Self
+    where
+        TValue: Clone,
+    {
+        let items = self.range(range).to_vec();
+        Self { items }
+    }
+
+    pub fn sub_sequence_by_index(&self, range: std::ops::Range<usize>) -> Self
+    where
+        TValue: Clone,
+    {
+        if range.start >= self.items.len() {
+            return Self::new();
+        }
+
+        let end = range.end.min(self.items.len());
+        if range.start >= end {
+            return Self::new();
+        }
+
+        let items = self.items[range.start..end].to_vec();
+        Self { items }
+    }
+
     pub fn range(&self, range: std::ops::Range<&str>) -> &[Arc<TValue>] {
         let index_from = self
             .items

src/sorted_vec/sorted_vec_with_str_key.rs

@@ -143,6 +143,30 @@ impl<TValue: EntityWithStrKey> SortedVecWithStrKey<TValue> {
             Err(index) => &self.items[..index],
         }
     }
+    pub fn sub_sequence(&self, range: std::ops::Range<&str>) -> Self
+    where
+        TValue: Clone,
+    {
+        let items = self.range(range).to_vec();
+        Self { items }
+    }
+
+    pub fn sub_sequence_by_index(&self, range: std::ops::Range<usize>) -> Self
+    where
+        TValue: Clone,
+    {
+        if range.start >= self.items.len() {
+            return Self::new();
+        }
+
+        let end = range.end.min(self.items.len());
+        if range.start >= end {
+            return Self::new();
+        }
+
+        let items = self.items[range.start..end].to_vec();
+        Self { items }
+    }
 
     pub fn remove(&mut self, key: &str) -> Option<TValue> {
         let result = self.items.binary_search_by(|itm| itm.get_key().cmp(key));