initial import

.gitignore

@@ -0,0 +1 @@
+/target

Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "granges2"
+version = "0.1.0"
+edition = "2021"
+
+# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+
+[dependencies]
+coitrees = { version = "0.4.0", features = ["nosimd"] }
+genomap = "0.1.5"
+indexmap = "2.2.3"
+rand = "0.8.5"
+thiserror = "1.0.57"

src/error.rs

@@ -0,0 +1,13 @@
+use thiserror::Error;
+
+use crate::Position;
+
+#[derive(Debug, Error)]
+pub enum GRangesError {
+    #[error("Range invalid: start ({0}) must be greater than end ({1})")]
+    InvalidGenomicRange(Position, Position),
+
+    #[error("Range [{0}, {1}] is invalid for sequence of length {2}")]
+    InvalidGenomicRangeForSequence(Position, Position, Position),
+
+}

src/granges.rs

@@ -0,0 +1,96 @@
+use genomap::GenomeMap;
+
+use crate::{traits::RangeContainer, ranges::{vec::{VecRanges, VecRangesIndexed, VecRangesEmpty}, RangeIndexed, RangeEmpty}, Position};
+
+
+pub struct GRanges<C, T> {
+    ranges: GenomeMap<C>,
+    data: Option<T>,
+}
+
+
+impl<C, T> GRanges<C, T>
+where C: RangeContainer {
+
+    /// Get the total number of ranges.
+    pub fn len(&self) -> usize {
+        self.ranges.values().map(|ranges| ranges.len()).sum()
+    }
+
+    /// Return whether the [`GRanges`] object is empty (contains no ranges).
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<U> GRanges<VecRangesIndexed, Vec<U>> {
+
+    /// Create a new [`GRanges`] object, with vector storage for ranges and data.
+    ///
+    /// This combination of range and data containers is used when loading data into
+    /// a new [`GRanges`] object, and the size cannot be known beforehand. Rust's 
+    /// [`Vec`] will dynamically grow to accommodate new ranges; use [`GRanges.shrink()`] 
+    /// call the [`Vec`]'s shrink to size methods on the range and data containers
+    /// after data loading to shrink to the minimal necessary size (this can reduce
+    /// memory usage).
+    pub fn new_vec() -> Self {
+        let ranges = GenomeMap::new();
+        Self {
+            ranges,
+            data: None,
+        }
+    }
+
+
+    pub fn push_range_with_data(&mut self, seqname: &str, start: Position, end: Position, data: U) {
+        // push data to the vec data container, getting the index
+        let index: usize = {
+            let data_container = self.data.get_or_insert_with(Vec::new);
+            data_container.push(data);
+            data_container.len() - 1 // new data index
+        };
+        // push an indexed range
+        let range = RangeIndexed::new(start, end, index);
+        self.ranges.entry_or_default(seqname).ranges.push(range);
+    }
+}
+
+impl GRanges<VecRangesEmpty, ()> {
+
+    /// Create a new [`GRanges`] object, with vector storage for ranges and no data container.
+    pub fn new_vec_empty() -> Self {
+        let ranges = GenomeMap::new();
+        Self {
+            ranges,
+            data: None,
+        }
+    }
+
+    /// Push an empty range (no data) to the [`VecRangesEmpty`] range container.
+    pub fn push_range_only(&mut self, seqname: &str, start: Position, end: Position) {
+        // push an unindexed (empty) range
+        let range = RangeEmpty::new(start, end);
+        self.ranges.entry_or_default(seqname).ranges.push(range);
+    }
+}
+
+
+
+#[cfg(test)]
+mod tests {
+    use crate::{prelude::*, test_utilities::random_vecranges};
+
+    #[test]
+    fn test_new_vec() {
+        let mut gr = GRanges::new_vec();
+        gr.push_range_with_data("chr1", 0, 10, 1.1);
+        assert_eq!(gr.len(), 1);
+    }
+
+    #[test]
+    fn test_random_vecranges() {
+        let vr = random_vecranges(100);
+        assert_eq!(vr.len(), 100)
+    }
+
+}

src/join.rs

@@ -0,0 +1,2 @@
+
+

src/lib.rs

@@ -0,0 +1,13 @@
+
+pub mod traits;
+pub mod ranges;
+pub mod granges;
+pub mod error;
+pub mod test_utilities;
+
+pub type Position = u32;
+
+pub mod prelude {
+    pub use crate::granges::GRanges;
+    pub use crate::error::GRangesError;
+}

src/ranges/coitrees.rs

@@ -0,0 +1,74 @@
+use coitrees::{Interval, BasicCOITree, IntervalTree, IntervalNode, GenericInterval};
+
+use crate::{Position, traits::RangeContainer, error::GRangesError};
+
+use super::{vec::VecRanges, RangeIndexed, validate_range};
+
+type COITreeIntervalIndexed = Interval<usize>;
+
+impl GenericInterval<usize> for RangeIndexed {
+    fn first(&self) -> i32 {
+        self.start().try_into().unwrap()
+    }
+    fn last(&self) -> i32 {
+        self.end().try_into().unwrap()
+    }
+    fn metadata(&self) -> &usize {
+       self.index()
+    }
+}
+
+/// A [`coitrees::BasicCOITree`] interval tree for a single sequence's ranges.
+///
+/// This is generic over the interval type, to handle the case where one 
+/// may want to do overlap operations on ranges without associated data in 
+/// a data container (e.g. ranges that just define megabase windwows).
+pub struct COITreeRangeContainer<R: Clone> {
+    ranges: BasicCOITree<R, usize>,
+    /// The sequence length, used to validate new ranges.
+    length: Position,
+}
+
+impl<R: Clone> COITreeRangeContainer<R> {
+    pub fn validate_range(&self, start: Position, end: Position) -> Result<(), GRangesError> {
+        let range = start..end;
+        validate_range(&range, self.length)
+    }
+
+    pub fn query<F>(&self, start: Position, end: Position, visit: F) 
+    where F: FnMut(&IntervalNode<R, usize>) {
+        // Note the terminology change to match coitrees (and uses i32s)
+        let first = start.try_into().expect("could not covert");
+        let end: i32  = end.try_into().expect("could not covert");
+        // internally coitrees uses 0-indexed, right-inclusive "last"
+        self.ranges.query(first, end - 1, visit)
+    }
+
+    /// Return the number of ranges in this [`COITreeRangeContainer`] container.
+    pub fn len(&self) -> usize {
+        self.ranges.len()
+    }
+
+    /// Return whether the [`COITreeRangeContainer`] object is empty (contains no ranges).
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+}
+
+impl<R: Clone + GenericInterval<R>> From<VecRanges<R>> for COITreeRangeContainer<R> {
+    fn from(value: VecRanges<R>) -> Self {
+        let ranges = BasicCOITree::new(&value.ranges);
+        let length = value.length;
+        Self {
+            ranges,
+            length
+        }
+    }
+}
+
+impl<R: Clone> RangeContainer for COITreeRangeContainer<R> {
+    fn len(&self) -> usize {
+        self.ranges.len()
+    }
+}

src/ranges/mod.rs

@@ -0,0 +1,104 @@
+use std::ops::Range;
+
+use crate::{Position, error::GRangesError};
+
+pub mod coitrees;
+pub mod vec;
+
+
+#[derive(Clone, Default)]
+pub struct RangeEmpty {
+    range: Range<Position>,
+}
+
+impl RangeEmpty {
+    /// Create a new 0-indexed right-exclusive range.
+    pub fn new(start: Position, end: Position) -> Self {
+        let start = start.try_into().unwrap();
+        let end = end.try_into().unwrap();
+        Self {
+            range: start..end,
+        }
+    }
+
+    pub fn start(&self) -> Position {
+        self.range.start
+    }
+
+    pub fn end(&self) -> Position {
+        self.range.end
+    }
+}
+
+#[derive(Clone, Debug, Default)]
+pub struct RangeIndexed {
+    range: Range<Position>,
+    index: usize,
+}
+
+impl RangeIndexed {
+    /// Create a new 0-indexed right-exclusive range.
+    pub fn new(start: Position, end: Position, index: usize) -> Self {
+        let start = start.try_into().unwrap();
+        let end = end.try_into().unwrap();
+        Self {
+            range: start..end,
+            index
+        }
+    }
+
+    pub fn start(&self) -> Position {
+        self.range.start
+    }
+
+    pub fn end(&self) -> Position {
+        self.range.end
+    }
+
+    // Note: this returning a reference is required to 
+    // implement coitrees's GenericInterval trait.
+    pub fn index(&self) -> &usize {
+        &self.index
+    }
+}
+
+/// Validates whether a given range is valid for accessing a sequence of a given `length`.
+///
+/// # Arguments
+///
+/// * `range` - The range to validate.
+/// * `length` - The length of the sequence.
+///
+/// # Returns
+///
+/// * `bool` - `true` if the range is valid for the sequence; otherwise, `false`.
+pub fn validate_range(range: &std::ops::Range<Position>, length: Position) -> 
+Result<(), GRangesError> {
+    let start = range.start;
+    let end = range.start;
+    dbg!(&start);
+    dbg!(&end);
+    if start > end {
+        GRangesError::InvalidGenomicRange(start, end);
+    }
+
+    if end >= length {
+        GRangesError::InvalidGenomicRangeForSequence(start, end, length);
+    }
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::prelude::*;
+    use super::validate_range;
+
+    #[test]
+    fn test_invalid_range_start_end() {
+        let range = 10..1;
+        let result = validate_range(&range, 10);
+        dbg!(&range);
+        assert!(matches!(result, Err(GRangesError::InvalidGenomicRange(10, 0))));
+
+    }
+}

src/ranges/vec.rs

@@ -0,0 +1,47 @@
+use crate::{traits::RangeContainer, Position, error::GRangesError};
+
+use super::{RangeIndexed, validate_range, RangeEmpty};
+pub type VecRangesIndexed = VecRanges<RangeIndexed>;
+pub type VecRangesEmpty = VecRanges<RangeEmpty>;
+
+#[derive(Clone, Default)]
+pub struct VecRanges<R: Clone> {
+    pub (crate) ranges: Vec<R>,
+    pub length: Position,
+}
+
+impl<R: Clone> VecRanges<R> {
+    pub fn validate_range(&self, start: Position, end: Position) -> Result<(), GRangesError> {
+        let range = start..end;
+        validate_range(&range, self.length)
+    }
+
+    /// Create a new empty [`VecRanges`] container.
+    pub fn new(length: Position) -> Self {
+        Self {
+            ranges: Vec::new(),
+            length,
+        }
+    }
+
+    /// Add a new range to the [`VecRanges`] container.
+    pub fn push_range(&mut self, range: R) {
+        self.ranges.push(range)
+    }
+
+    /// Return the number of ranges in this [`VecRanges`] container.
+    pub fn len(&self) -> usize {
+        self.ranges.len()
+    }
+
+    /// Return whether the [`VecRanges`] object is empty (contains no ranges).
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+}
+
+impl<R: Clone> RangeContainer for VecRanges<R> {
+    fn len(&self) -> usize {
+        self.ranges.len()
+    }
+}