WIP typechecks

crates/items_0/src/items_0.rs

@@ -9,6 +9,7 @@ pub mod subfr;
 pub mod test;
 pub mod timebin;
 pub mod transform;
+pub mod vecpreview;
 
 pub mod bincode {
     pub use bincode::*;
@@ -21,6 +22,7 @@ use container::ByteEstimate;
 use std::any::Any;
 use std::collections::VecDeque;
 use std::fmt;
+use timebin::BinningggContainerEventsDyn;
 use timebin::TimeBinnable;
 
 pub trait WithLen {
@@ -158,6 +160,7 @@ pub trait Events:
     fn clear(&mut self);
     // TODO: can not name EventsDim0 from here, so use trait object for now. Anyway is a workaround.
     fn to_dim0_f32_for_binning(&self) -> Box<dyn Events>;
+    fn to_container_events(&self) -> Box<dyn BinningggContainerEventsDyn>;
 }
 
 impl WithLen for Box<dyn Events> {
@@ -296,4 +299,8 @@ impl Events for Box<dyn Events> {
     fn to_dim0_f32_for_binning(&self) -> Box<dyn Events> {
         Events::to_dim0_f32_for_binning(self.as_ref())
     }
+
+    fn to_container_events(&self) -> Box<dyn BinningggContainerEventsDyn> {
+        Events::to_container_events(self.as_ref())
+    }
 }

crates/items_0/src/timebin.rs

@@ -4,18 +4,24 @@ use crate::collect_s::Collectable;
 use crate::collect_s::Collector;
 use crate::collect_s::ToJsonResult;
 use crate::overlap::RangeOverlapInfo;
+use crate::vecpreview::PreviewRange;
 use crate::AsAnyMut;
 use crate::AsAnyRef;
+use crate::Empty;
 use crate::Events;
 use crate::Resettable;
 use crate::TypeName;
 use crate::WithLen;
+use err::thiserror;
 use err::Error;
+use err::ThisError;
 use netpod::log::*;
 use netpod::range::evrange::SeriesRange;
 use netpod::BinnedRange;
 use netpod::BinnedRangeEnum;
 use netpod::TsNano;
+use serde::Deserialize;
+use serde::Serialize;
 use std::any::Any;
 use std::fmt;
 use std::ops::Range;
@@ -64,10 +70,20 @@ pub trait TimeBinnableTy: fmt::Debug + WithLen + Send + Sized {
     ) -> Self::TimeBinner;
 }
 
+// #[derive(Debug, ThisError)]
+// #[cstm(name = "Binninggg")]
 pub enum BinningggError {
     Dyn(Box<dyn std::error::Error>),
 }
 
+impl fmt::Display for BinningggError {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match self {
+            BinningggError::Dyn(e) => write!(fmt, "{e}"),
+        }
+    }
+}
+
 impl<E> From<E> for BinningggError
 where
     E: std::error::Error + 'static,
@@ -77,11 +93,21 @@ where
     }
 }
 
-pub trait BinningggContainerEventsDyn: fmt::Debug {
+pub trait BinningggContainerEventsDyn: fmt::Debug + Send {
     fn binned_events_timeweight_traitobj(&self) -> Box<dyn BinnedEventsTimeweightTrait>;
 }
 
-pub trait BinningggContainerBinsDyn: fmt::Debug {}
+pub trait BinningggContainerBinsDyn: fmt::Debug + Send + fmt::Display + WithLen {
+    fn empty(&self) -> BinsBoxed;
+    fn clone(&self) -> BinsBoxed;
+    fn edges_iter(
+        &self,
+    ) -> std::iter::Zip<std::collections::vec_deque::Iter<TsNano>, std::collections::vec_deque::Iter<TsNano>>;
+    fn drain_into(&mut self, dst: &mut dyn BinningggContainerBinsDyn, range: Range<usize>);
+    fn to_old_time_binned(&self) -> Box<dyn TimeBinned>;
+}
+
+pub type BinsBoxed = Box<dyn BinningggContainerBinsDyn>;
 
 pub trait BinningggBinnerTy: fmt::Debug + Send {
     type Input: fmt::Debug;

crates/items_0/src/vecpreview.rs

@@ -0,0 +1,53 @@
+use core::fmt;
+use std::collections::VecDeque;
+
+pub struct PreviewCell<'a, T> {
+    pub a: Option<&'a T>,
+    pub b: Option<&'a T>,
+}
+
+impl<'a, T> fmt::Debug for PreviewCell<'a, T>
+where
+    T: fmt::Debug,
+{
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        match (self.a.as_ref(), self.b.as_ref()) {
+            (Some(a), Some(b)) => write!(fmt, "{:?} .. {:?}", a, b),
+            (Some(a), None) => write!(fmt, "{:?}", a),
+            _ => write!(fmt, "(empty)"),
+        }
+    }
+}
+
+pub trait PreviewRange {
+    fn preview<'a>(&'a self) -> Box<dyn fmt::Debug + 'a>;
+}
+
+impl<T> PreviewRange for VecDeque<T>
+where
+    T: fmt::Debug,
+{
+    fn preview<'a>(&'a self) -> Box<dyn fmt::Debug + 'a> {
+        let ret = PreviewCell {
+            a: self.front(),
+            b: if self.len() <= 1 { None } else { self.back() },
+        };
+        Box::new(ret)
+    }
+}
+
+pub struct VecPreview<'a> {
+    c: &'a dyn PreviewRange,
+}
+
+impl<'a> VecPreview<'a> {
+    pub fn new(c: &'a dyn PreviewRange) -> Self {
+        Self { c }
+    }
+}
+
+impl<'a> fmt::Debug for VecPreview<'a> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "{:?}", self.c.preview())
+    }
+}