cache report

Author: brentp

src/column.rs

@@ -56,7 +56,7 @@ impl std::fmt::Display for ColumnError {
 impl std::error::Error for ColumnError {}
 
 /// A ColumnReporter tells bedder how to report a column in the output.
-pub trait ColumnReporter {
+pub trait ColumnReporter: std::fmt::Debug {
     /// report the name, e.g. `count` for the INFO field of the VCF
     fn name(&self) -> &str;
     /// report the type, for the INFO field of the VCF

src/intersection.rs

@@ -1,4 +1,6 @@
 use crate::chrom_ordering::Chromosome;
+use crate::report::Report;
+use crate::report_options::ReportOptions;
 use crate::string::String;
 use hashbrown::HashMap;
 use parking_lot::Mutex;
@@ -57,6 +59,9 @@ impl Clone for Intersection {
 pub struct Intersections {
     pub base_interval: Arc<Mutex<Position>>,
     pub overlapping: Vec<Intersection>,
+
+    // report cache, keyed by report_options. Use Arc Mutex for interior mutability.
+    pub(crate) cached_report: Arc<Mutex<Option<(ReportOptions, Arc<Report>)>>>,
 }
 
 struct ReverseOrderPosition {
@@ -200,6 +205,7 @@ impl<P: PositionedIterator> Iterator for IntersectionIterator<'_, P> {
         Some(Ok(Intersections {
             base_interval: Arc::clone(&base_interval),
             overlapping: overlapping_positions,
+            cached_report: Arc::new(Mutex::new(None)),
         }))
     }
 }

src/intersections.rs

@@ -32,7 +32,16 @@ fn inverse(base_interval: &Position, overlaps: &[Intersection]) -> Vec<Arc<Mutex
 impl Intersections {
     // TODO: brenth cache report with report options as this is expensive.
     // add a new field to Intersections to cache the report.
-    pub fn report(&self, report_options: &ReportOptions) -> Report {
+    pub fn report(&self, report_options: &ReportOptions) -> Arc<Report> {
+        let mut cached_report = self
+            .cached_report
+            .try_lock()
+            .expect("failed to lock cached report");
+        if let Some((ro, report)) = &*cached_report {
+            if ro == report_options {
+                return report.clone();
+            }
+        }
         // usually the result is [query, [[b1-part, b1-part2, ...], [b2-part, ...]]]],
         // in fact, usually, there's only a single b and a single interval from b, so it's:
         // [query, [[b1-part]]]
@@ -131,7 +140,9 @@ impl Intersections {
             );
         }
 
-        Report::new(result)
+        let report = Arc::new(Report::new(result));
+        *cached_report = Some((report_options.clone(), report.clone()));
+        report
     }
 
     fn satisfies_requirements(

src/main.rs

@@ -30,8 +30,7 @@ struct Args {
     #[arg(
         help = "columns to output (format: name:type:description:number:value_parser)",
         short = 'c',
-        long = "columns",
-        required = true
+        long = "columns"
     )]
     columns: Vec<String>,
 

src/py.rs

@@ -172,7 +172,7 @@ impl From<crate::report::ReportFragment> for PyReportFragment {
 #[pyclass]
 #[derive(Clone, Debug)]
 pub struct PyReport {
-    inner: crate::report::Report,
+    inner: Arc<crate::report::Report>,
 }
 
 #[pymethods]
@@ -181,14 +181,14 @@ impl PyReport {
     /// Create a new empty Report
     fn new() -> Self {
         PyReport {
-            inner: crate::report::Report::new(Vec::new()),
+            inner: Arc::new(crate::report::Report::new(Vec::new())),
         }
     }
 
     /// Add a report fragment to the collection
     fn add_fragment(&mut self, frag: PyReportFragment) -> PyResult<()> {
         let inner_frags = vec![frag.inner];
-        self.inner = crate::report::Report::new(inner_frags);
+        self.inner = Arc::new(crate::report::Report::new(inner_frags));
         Ok(())
     }
 
@@ -483,7 +483,7 @@ impl PyIntersections {
     }
 
     /// Report intersections based on specified modes and requirements
-    fn report(&self) -> PyResult<PyReport> {
+    fn report(&mut self) -> PyResult<PyReport> {
         Ok(PyReport {
             inner: self.inner.report(&self.report_options),
         })

src/py_test.rs

@@ -25,6 +25,7 @@ mod tests {
                 interval: Arc::new(Mutex::new(overlap_pos)),
                 id: 0,
             }],
+            cached_report: Arc::new(Mutex::new(None)),
         };
 
         PyIntersections::new(intersections, Arc::new(ReportOptions::default()))

src/report_options.rs

@@ -122,6 +122,8 @@ pub enum OverlapAmount {
     Fraction(f32),
 }
 
+impl Eq for OverlapAmount {}
+
 impl FromStr for OverlapAmount {
     type Err = ParseFloatError;
 
@@ -179,7 +181,7 @@ impl Default for &OverlapAmount {
 ///     .b_requirements(OverlapAmount::Fraction(0.5))
 ///     .build();
 /// ```
-#[derive(Debug, Clone, Default)]
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
 pub struct ReportOptions {
     pub a_mode: IntersectionMode,
     pub b_mode: IntersectionMode,

src/tests/parse_intersections.rs

@@ -72,6 +72,7 @@ pub(crate) fn parse_intersections(input: &str) -> Intersections {
     Intersections {
         base_interval: Arc::new(Mutex::new(Position::Interval(base_interval))),
         overlapping: intersections,
+        cached_report: Arc::new(Mutex::new(None)),
     }
 }
 

src/writer.rs

@@ -2,6 +2,7 @@ use crate::column::{ColumnReporter, Value};
 use crate::hts_format::{Compression, Format};
 use crate::intersection::Intersections;
 use crate::position::Position;
+use crate::report::Report;
 use crate::report_options::ReportOptions;
 use rust_htslib::bam;
 use rust_htslib::bcf::{self, header::HeaderView};
@@ -210,7 +211,7 @@ impl Writer {
         .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidData, e.to_string()))
     }
 
-    fn update<T: ColumnReporter>(
+    fn apply_report<T: ColumnReporter>(
         format: Format,
         intersections: &mut Intersections,
         report_options: Arc<ReportOptions>,
@@ -319,7 +320,7 @@ impl Writer {
                     }
                 };
 
-                Self::update(self.format, intersections, report_options, crs)?;
+                Self::apply_report(self.format, intersections, report_options, crs)?;
 
                 // Use the current value of the Arc without modifying it
                 if let Position::Bed(ref bed_record) = *intersections.base_interval.lock() {