from and as RangeBounds

Author: Eh2406

src/range.rs

@@ -16,6 +16,7 @@
 
 use std::cmp::Ordering;
 use std::fmt;
+use std::ops::{Bound, RangeBounds};
 
 use crate::internal::small_vec::SmallVec;
 use crate::version::Version;
@@ -85,6 +86,31 @@ impl<V: Version> Range<V> {
             Self::none()
         }
     }
+
+    /// Construct a simple range from anything that impls `RangeBounds` like `v1..v2`
+    pub fn from_range_bounds<'a, R, IV: 'a>(bounds: &'a R) -> Self
+    where
+        R: RangeBounds<IV>,
+        &'a IV: Into<V>,
+    {
+        let start = match bounds.start_bound() {
+            Bound::Included(s) => s.into(),
+            Bound::Excluded(s) => s.into().bump(),
+            Bound::Unbounded => V::lowest(),
+        };
+        let end = match bounds.end_bound() {
+            Bound::Included(e) => Some(e.into().bump()),
+            Bound::Excluded(e) => Some(e.into()),
+            Bound::Unbounded => None,
+        };
+        if end.is_some() && end.as_ref() <= Some(&start) {
+            Self::none()
+        } else {
+            Self {
+                segments: SmallVec::one((start, end)),
+            }
+        }
+    }
 }
 
 // Set operations.
@@ -260,6 +286,23 @@ impl<V: Version> Range<V> {
     pub fn lowest_version(&self) -> Option<V> {
         self.segments.first().map(|(start, _)| start).cloned()
     }
+
+    /// Conver to somthing that can be used with BTreeMap::range
+    /// All versions contained in self, will be in the output,
+    /// but there may be versions in the output that are not contained in self.
+    /// returns None if the range is empty.
+    pub fn as_range_bounds(&self) -> Option<(Bound<&V>, Bound<&V>)> {
+        self.segments.first().map(|(start, _)| {
+            let end = {
+                self.segments
+                    .last()
+                    .and_then(|(_, l)| l.as_ref())
+                    .map(Bound::Excluded)
+                    .unwrap_or(Bound::Unbounded)
+            };
+            (Bound::Included(start), end)
+        })
+    }
 }
 
 // REPORT ######################################################################

src/version.rs

@@ -80,6 +80,14 @@ impl From<(u32, u32, u32)> for SemanticVersion {
     }
 }
 
+// Convert a &(major, minor, patch) into a version.
+impl From<&(u32, u32, u32)> for SemanticVersion {
+    fn from(tuple: &(u32, u32, u32)) -> Self {
+        let (major, minor, patch) = *tuple;
+        Self::new(major, minor, patch)
+    }
+}
+
 // Convert a version into a tuple (major, minor, patch).
 impl From<SemanticVersion> for (u32, u32, u32) {
     fn from(v: SemanticVersion) -> Self {
@@ -237,6 +245,13 @@ impl From<u32> for NumberVersion {
     }
 }
 
+// Convert an &usize into a version.
+impl From<&u32> for NumberVersion {
+    fn from(v: &u32) -> Self {
+        Self(*v)
+    }
+}
+
 // Convert a version into an usize.
 impl From<NumberVersion> for u32 {
     fn from(version: NumberVersion) -> Self {