Limit response size in a somewhat improved way

crates/items_2/src/binsdim0.rs

@@ -14,6 +14,7 @@ use items_0::collect_s::CollectableType;
 use items_0::collect_s::Collected;
 use items_0::collect_s::CollectorType;
 use items_0::collect_s::ToJsonResult;
+use items_0::container::ByteEstimate;
 use items_0::overlap::HasTimestampDeque;
 use items_0::scalar_ops::AsPrimF32;
 use items_0::scalar_ops::ScalarOps;
@@ -187,6 +188,24 @@ impl<STY> WithLen for BinsDim0<STY> {
     }
 }
 
+impl<STY: ScalarOps> ByteEstimate for BinsDim0<STY> {
+    fn byte_estimate(&self) -> u64 {
+        // TODO
+        // Should use a better estimate for waveform and string types,
+        // or keep some aggregated byte count on push.
+        let n = self.len();
+        if n == 0 {
+            0
+        } else {
+            // TODO use the actual size of one/some of the elements.
+            let i = n * 2 / 3;
+            let w1 = self.mins[i].byte_estimate();
+            let w2 = self.maxs[i].byte_estimate();
+            (n as u64 * (8 + 8 + 8 + 4 + w1 + w2)) as u64
+        }
+    }
+}
+
 impl<STY> Resettable for BinsDim0<STY> {
     fn reset(&mut self) {
         self.ts1s.clear();
@@ -414,7 +433,13 @@ impl<NTY> BinsDim0Collector<NTY> {
 
 impl<NTY> WithLen for BinsDim0Collector<NTY> {
     fn len(&self) -> usize {
-        self.vals.as_ref().map_or(0, |x| x.ts1s.len())
+        self.vals.as_ref().map_or(0, WithLen::len)
+    }
+}
+
+impl<STY: ScalarOps> ByteEstimate for BinsDim0Collector<STY> {
+    fn byte_estimate(&self) -> u64 {
+        self.vals.as_ref().map_or(0, ByteEstimate::byte_estimate)
     }
 }
 

crates/items_2/src/binsxbindim0.rs

@@ -11,6 +11,7 @@ use items_0::collect_s::CollectableType;
 use items_0::collect_s::Collected;
 use items_0::collect_s::CollectorType;
 use items_0::collect_s::ToJsonResult;
+use items_0::container::ByteEstimate;
 use items_0::scalar_ops::AsPrimF32;
 use items_0::scalar_ops::ScalarOps;
 use items_0::timebin::TimeBinnable;
@@ -205,6 +206,24 @@ impl<STY> WithLen for BinsXbinDim0<STY> {
     }
 }
 
+impl<STY: ScalarOps> ByteEstimate for BinsXbinDim0<STY> {
+    fn byte_estimate(&self) -> u64 {
+        // TODO
+        // Should use a better estimate for waveform and string types,
+        // or keep some aggregated byte count on push.
+        let n = self.len();
+        if n == 0 {
+            0
+        } else {
+            // TODO use the actual size of one/some of the elements.
+            let i = n * 2 / 3;
+            let w1 = self.mins[i].byte_estimate();
+            let w2 = self.maxs[i].byte_estimate();
+            (n as u64 * (8 + 8 + 8 + 4 + w1 + w2)) as u64
+        }
+    }
+}
+
 impl<STY> Resettable for BinsXbinDim0<STY> {
     fn reset(&mut self) {
         self.ts1s.clear();
@@ -401,7 +420,13 @@ impl<NTY> BinsXbinDim0Collector<NTY> {
 
 impl<NTY> WithLen for BinsXbinDim0Collector<NTY> {
     fn len(&self) -> usize {
-        self.vals.ts1s.len()
+        self.vals.len()
+    }
+}
+
+impl<STY: ScalarOps> ByteEstimate for BinsXbinDim0Collector<STY> {
+    fn byte_estimate(&self) -> u64 {
+        self.vals.byte_estimate()
     }
 }
 

crates/items_2/src/channelevents.rs

@@ -1159,6 +1159,12 @@ impl WithLen for ChannelEventsCollector {
     }
 }
 
+impl ByteEstimate for ChannelEventsCollector {
+    fn byte_estimate(&self) -> u64 {
+        self.coll.as_ref().map_or(0, |x| x.byte_estimate())
+    }
+}
+
 impl Collector for ChannelEventsCollector {
     fn ingest(&mut self, item: &mut dyn Collectable) {
         if let Some(item) = item.as_any_mut().downcast_mut::<ChannelEvents>() {

crates/items_2/src/eventsdim0.rs

@@ -164,10 +164,20 @@ impl<STY> WithLen for EventsDim0<STY> {
     }
 }
 
-impl<STY> ByteEstimate for EventsDim0<STY> {
+impl<STY: ScalarOps> ByteEstimate for EventsDim0<STY> {
     fn byte_estimate(&self) -> u64 {
-        let stylen = mem::size_of::<STY>();
-        (self.len() * (8 + 8 + stylen)) as u64
+        // TODO
+        // Should use a better estimate for waveform and string types,
+        // or keep some aggregated byte count on push.
+        let n = self.len();
+        if n == 0 {
+            0
+        } else {
+            // TODO use the actual size of one/some of the elements.
+            let i = n * 2 / 3;
+            let sty_bytes = self.values[i].byte_estimate();
+            (n as u64 * (8 + 8 + sty_bytes)) as u64
+        }
     }
 }
 
@@ -262,7 +272,13 @@ impl<STY> EventsDim0Collector<STY> {
 
 impl<STY> WithLen for EventsDim0Collector<STY> {
     fn len(&self) -> usize {
-        self.vals.tss.len()
+        WithLen::len(&self.vals)
+    }
+}
+
+impl<STY: ScalarOps> ByteEstimate for EventsDim0Collector<STY> {
+    fn byte_estimate(&self) -> u64 {
+        ByteEstimate::byte_estimate(&self.vals)
     }
 }
 
@@ -426,7 +442,7 @@ impl<STY: ScalarOps> CollectorType for EventsDim0Collector<STY> {
                 if let Some(range) = &range {
                     match range {
                         SeriesRange::TimeRange(x) => Some(IsoDateTime::from_u64(x.beg + SEC)),
-                        SeriesRange::PulseRange(x) => {
+                        SeriesRange::PulseRange(_) => {
                             error!("TODO emit create continueAt for pulse range");
                             Some(IsoDateTime::from_u64(0))
                         }

crates/items_2/src/eventsdim1.rs

@@ -220,7 +220,13 @@ impl<STY> EventsDim1Collector<STY> {
 
 impl<STY> WithLen for EventsDim1Collector<STY> {
     fn len(&self) -> usize {
-        self.vals.tss.len()
+        WithLen::len(&self.vals)
+    }
+}
+
+impl<STY> ByteEstimate for EventsDim1Collector<STY> {
+    fn byte_estimate(&self) -> u64 {
+        ByteEstimate::byte_estimate(&self.vals)
     }
 }
 

crates/items_2/src/eventsxbindim0.rs

@@ -962,7 +962,13 @@ impl<NTY> EventsXbinDim0Collector<NTY> {
 
 impl<NTY> WithLen for EventsXbinDim0Collector<NTY> {
     fn len(&self) -> usize {
-        self.vals.tss.len()
+        WithLen::len(&self.vals)
+    }
+}
+
+impl<STY> ByteEstimate for EventsXbinDim0Collector<STY> {
+    fn byte_estimate(&self) -> u64 {
+        ByteEstimate::byte_estimate(&self.vals)
     }
 }