WIP query options

items/src/eventfull.rs

@@ -20,16 +20,17 @@ use std::collections::VecDeque;
 pub struct EventFull {
     pub tss: VecDeque<u64>,
     pub pulses: VecDeque<u64>,
-    pub blobs: VecDeque<Vec<u8>>,
-    #[serde(with = "decomps_serde")]
+    pub blobs: VecDeque<Option<Vec<u8>>>,
+    //#[serde(with = "decomps_serde")]
     // TODO allow access to `decomps` via method which checks first if `blobs` is already the decomp.
-    pub decomps: VecDeque<Option<BytesMut>>,
+    pub decomps: VecDeque<Option<Vec<u8>>>,
     pub scalar_types: VecDeque<ScalarType>,
     pub be: VecDeque<bool>,
     pub shapes: VecDeque<Shape>,
     pub comps: VecDeque<Option<CompressionMethod>>,
 }
 
+#[allow(unused)]
 mod decomps_serde {
     use super::*;
 
@@ -85,8 +86,8 @@ impl EventFull {
         &mut self,
         ts: u64,
         pulse: u64,
-        blob: Vec<u8>,
-        decomp: Option<BytesMut>,
+        blob: Option<Vec<u8>>,
+        decomp: Option<Vec<u8>>,
         scalar_type: ScalarType,
         be: bool,
         shape: Shape,
@@ -102,11 +103,26 @@ impl EventFull {
         self.comps.push_back(comp);
     }
 
-    pub fn decomp(&self, i: usize) -> &[u8] {
-        match &self.decomps[i] {
-            Some(decomp) => &decomp,
-            None => &self.blobs[i],
+    pub fn truncate_ts(&mut self, end: u64) {
+        let mut nkeep = usize::MAX;
+        for (i, &ts) in self.tss.iter().enumerate() {
+            if ts >= end {
+                for (i, &ts) in self.tss.iter().enumerate() {
+                    eprintln!("{i:5} {ts:20}");
+                }
+                eprintln!("truncate to  i {i}  ts {ts}");
+                nkeep = i;
+                break;
+            }
         }
+        self.tss.truncate(nkeep);
+        self.pulses.truncate(nkeep);
+        self.blobs.truncate(nkeep);
+        self.decomps.truncate(nkeep);
+        self.scalar_types.truncate(nkeep);
+        self.be.truncate(nkeep);
+        self.shapes.truncate(nkeep);
+        self.comps.truncate(nkeep);
     }
 }
 
@@ -170,13 +186,13 @@ impl WithTimestamps for EventFull {
 
 impl ByteEstimate for EventFull {
     fn byte_estimate(&self) -> u64 {
-        if self.tss.len() == 0 {
+        if self.len() == 0 {
             0
         } else {
             // TODO that is clumsy... it assumes homogenous types.
             // TODO improve via a const fn on NTY
             let decomp_len = self.decomps[0].as_ref().map_or(0, |h| h.len());
-            self.tss.len() as u64 * (40 + self.blobs[0].len() as u64 + decomp_len as u64)
+            self.tss.len() as u64 * (40 + self.blobs[0].as_ref().map_or(0, |x| x.len()) as u64 + decomp_len as u64)
         }
     }
 }

items/src/items.rs

@@ -16,8 +16,6 @@ use items_0::AsAnyRef;
 use netpod::log::Level;
 #[allow(unused)]
 use netpod::log::*;
-use netpod::timeunits::MS;
-use netpod::timeunits::SEC;
 use netpod::DiskStats;
 use netpod::EventDataReadStats;
 use netpod::NanoRange;
@@ -657,24 +655,6 @@ where
     }
 }
 
-pub fn ts_offs_from_abs(tss: &[u64]) -> (u64, Vec<u64>, Vec<u64>) {
-    let ts_anchor_sec = tss.first().map_or(0, |&k| k) / SEC;
-    let ts_anchor_ns = ts_anchor_sec * SEC;
-    let ts_off_ms: Vec<_> = tss.iter().map(|&k| (k - ts_anchor_ns) / MS).collect();
-    let ts_off_ns = tss
-        .iter()
-        .zip(ts_off_ms.iter().map(|&k| k * MS))
-        .map(|(&j, k)| (j - ts_anchor_ns - k))
-        .collect();
-    (ts_anchor_sec, ts_off_ms, ts_off_ns)
-}
-
-pub fn pulse_offs_from_abs(pulse: &[u64]) -> (u64, Vec<u64>) {
-    let pulse_anchor = pulse.first().map_or(0, |k| *k);
-    let pulse_off: Vec<_> = pulse.iter().map(|k| *k - pulse_anchor).collect();
-    (pulse_anchor, pulse_off)
-}
-
 pub trait TimeBinnableTypeAggregator: Send {
     type Input: TimeBinnableType;
     type Output: TimeBinnableType;