WIP checks

items_0/src/collect_s.rs

@@ -1,7 +1,7 @@
+use crate::timebin::TimeBinned;
 use crate::AsAnyMut;
 use crate::AsAnyRef;
 use crate::Events;
-use crate::TimeBinned;
 use crate::TypeName;
 use crate::WithLen;
 use err::Error;
@@ -92,11 +92,11 @@ where
 {
     fn ingest(&mut self, src: &mut dyn Collectable) {
         if let Some(src) = src.as_any_mut().downcast_mut::<<T as CollectorType>::Input>() {
-            info!("sees incoming &mut ref");
+            trace!("sees incoming &mut ref");
             T::ingest(self, src)
         } else {
             if let Some(src) = src.as_any_mut().downcast_mut::<Box<<T as CollectorType>::Input>>() {
-                info!("sees incoming &mut Box");
+                trace!("sees incoming &mut Box");
                 T::ingest(self, src)
             } else {
                 error!(

items_0/src/items_0.rs

@@ -5,6 +5,7 @@ pub mod isodate;
 pub mod scalar_ops;
 pub mod streamitem;
 pub mod subfr;
+pub mod timebin;
 pub mod transform;
 
 pub mod bincode {
@@ -12,25 +13,17 @@ pub mod bincode {
 }
 
 use collect_s::Collectable;
-use collect_s::ToJsonResult;
 use container::ByteEstimate;
 use netpod::range::evrange::SeriesRange;
-use netpod::BinnedRangeEnum;
 use std::any::Any;
 use std::collections::VecDeque;
 use std::fmt;
+use timebin::TimeBinnable;
 
 pub trait WithLen {
     fn len(&self) -> usize;
 }
 
-// TODO can probably be removed.
-pub trait TimeBins {
-    fn ts_min(&self) -> Option<u64>;
-    fn ts_max(&self) -> Option<u64>;
-    fn ts_min_max(&self) -> Option<(u64, u64)>;
-}
-
 pub trait RangeOverlapInfo {
     fn ends_before(&self, range: &SeriesRange) -> bool;
     fn ends_after(&self, range: &SeriesRange) -> bool;
@@ -79,48 +72,6 @@ where
     }
 }
 
-/// Data in time-binned form.
-pub trait TimeBinned: Any + TypeName + TimeBinnable + Collectable + erased_serde::Serialize {
-    fn as_time_binnable_dyn(&self) -> &dyn TimeBinnable;
-    fn as_collectable_mut(&mut self) -> &mut dyn Collectable;
-    fn edges_slice(&self) -> (&[u64], &[u64]);
-    fn counts(&self) -> &[u64];
-    fn mins(&self) -> Vec<f32>;
-    fn maxs(&self) -> Vec<f32>;
-    fn avgs(&self) -> Vec<f32>;
-    fn validate(&self) -> Result<(), String>;
-}
-
-pub trait TimeBinner: Send {
-    fn ingest(&mut self, item: &dyn TimeBinnable);
-    fn bins_ready_count(&self) -> usize;
-    fn bins_ready(&mut self) -> Option<Box<dyn TimeBinned>>;
-
-    /// If there is a bin in progress with non-zero count, push it to the result set.
-    /// With push_empty == true, a bin in progress is pushed even if it contains no counts.
-    fn push_in_progress(&mut self, push_empty: bool);
-
-    /// Implies `Self::push_in_progress` but in addition, pushes a zero-count bin if the call
-    /// to `push_in_progress` did not change the result count, as long as edges are left.
-    /// The next call to `Self::bins_ready_count` must return one higher count than before.
-    fn cycle(&mut self);
-
-    fn set_range_complete(&mut self);
-
-    fn empty(&self) -> Box<dyn TimeBinned>;
-}
-
-// TODO remove the Any bound. Factor out into custom AsAny trait.
-
-/// Provides a time-binned representation of the implementing type.
-/// In contrast to `TimeBinnableType` this is meant for trait objects.
-pub trait TimeBinnable: fmt::Debug + WithLen + RangeOverlapInfo + Any + AsAnyRef + AsAnyMut + Send {
-    // TODO implementors may fail if edges contain not at least 2 entries.
-    fn time_binner_new(&self, binrange: BinnedRangeEnum, do_time_weight: bool) -> Box<dyn TimeBinner>;
-    // TODO just a helper for the empty result.
-    fn to_box_to_json_result(&self) -> Box<dyn ToJsonResult>;
-}
-
 #[derive(Debug)]
 pub enum MergeError {
     NotCompatible,
@@ -158,11 +109,11 @@ pub trait Events:
     fn ts_max(&self) -> Option<u64>;
     // TODO is this used?
     fn take_new_events_until_ts(&mut self, ts_end: u64) -> Box<dyn Events>;
-    fn new_empty(&self) -> Box<dyn Events>;
-    fn drain_into(&mut self, dst: &mut Box<dyn Events>, range: (usize, usize)) -> Result<(), MergeError>;
-    fn find_lowest_index_gt(&self, ts: u64) -> Option<usize>;
-    fn find_lowest_index_ge(&self, ts: u64) -> Option<usize>;
-    fn find_highest_index_lt(&self, ts: u64) -> Option<usize>;
+    fn new_empty_evs(&self) -> Box<dyn Events>;
+    fn drain_into_evs(&mut self, dst: &mut Box<dyn Events>, range: (usize, usize)) -> Result<(), MergeError>;
+    fn find_lowest_index_gt_evs(&self, ts: u64) -> Option<usize>;
+    fn find_lowest_index_ge_evs(&self, ts: u64) -> Option<usize>;
+    fn find_highest_index_lt_evs(&self, ts: u64) -> Option<usize>;
     fn clone_dyn(&self) -> Box<dyn Events>;
     fn partial_eq_dyn(&self, other: &dyn Events) -> bool;
     fn serde_id(&self) -> &'static str;

items_0/src/streamitem.rs

@@ -1,4 +1,4 @@
-use crate::TimeBinned;
+use crate::timebin::TimeBinned;
 use err::Error;
 use netpod::log::Level;
 use netpod::DiskStats;
@@ -81,7 +81,7 @@ macro_rules! on_sitemty_range_complete {
 }
 
 #[macro_export]
-macro_rules! on_sitemty_data {
+macro_rules! on_sitemty_data_old {
     ($item:expr, $ex:expr) => {
         if let Ok($crate::streamitem::StreamItem::DataItem($crate::streamitem::RangeCompletableItem::Data(item))) =
             $item
@@ -93,6 +93,27 @@ macro_rules! on_sitemty_data {
     };
 }
 
+#[macro_export]
+macro_rules! on_sitemty_data {
+    ($item:expr, $ex:expr) => {{
+        use $crate::streamitem::RangeCompletableItem;
+        use $crate::streamitem::StreamItem;
+        match $item {
+            Ok(x) => match x {
+                StreamItem::DataItem(x) => match x {
+                    RangeCompletableItem::Data(x) => $ex(x),
+                    RangeCompletableItem::RangeComplete => {
+                        Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete))
+                    }
+                },
+                StreamItem::Log(x) => Ok(StreamItem::Log(x)),
+                StreamItem::Stats(x) => Ok(StreamItem::Stats(x)),
+            },
+            Err(x) => Err(x),
+        }
+    }};
+}
+
 pub fn sitem_data<X>(x: X) -> Sitemty<X> {
     Ok(StreamItem::DataItem(RangeCompletableItem::Data(x)))
 }

items_0/src/timebin.rs

@@ -0,0 +1,133 @@
+use crate::collect_s::Collectable;
+use crate::collect_s::ToJsonResult;
+use crate::AsAnyMut;
+use crate::AsAnyRef;
+use crate::RangeOverlapInfo;
+use crate::TypeName;
+use crate::WithLen;
+use netpod::BinnedRangeEnum;
+use std::any::Any;
+use std::fmt;
+
+// TODO can probably be removed.
+pub trait TimeBins {
+    fn ts_min(&self) -> Option<u64>;
+    fn ts_max(&self) -> Option<u64>;
+    fn ts_min_max(&self) -> Option<(u64, u64)>;
+}
+
+pub trait TimeBinnerTy: fmt::Debug + Unpin {
+    type Input: fmt::Debug;
+    type Output: fmt::Debug;
+
+    fn ingest(&mut self, item: &mut Self::Input);
+
+    fn set_range_complete(&mut self);
+
+    fn bins_ready_count(&self) -> usize;
+
+    fn bins_ready(&mut self) -> Option<Self::Output>;
+
+    /// If there is a bin in progress with non-zero count, push it to the result set.
+    /// With push_empty == true, a bin in progress is pushed even if it contains no counts.
+    fn push_in_progress(&mut self, push_empty: bool);
+
+    /// Implies `Self::push_in_progress` but in addition, pushes a zero-count bin if the call
+    /// to `push_in_progress` did not change the result count, as long as edges are left.
+    /// The next call to `Self::bins_ready_count` must return one higher count than before.
+    fn cycle(&mut self);
+
+    fn empty(&self) -> Option<Self::Output>;
+}
+
+pub trait TimeBinnableTy: fmt::Debug + Sized {
+    type TimeBinner: TimeBinnerTy<Input = Self>;
+
+    fn time_binner_new(&self, binrange: BinnedRangeEnum, do_time_weight: bool) -> Self::TimeBinner;
+}
+
+/// Data in time-binned form.
+pub trait TimeBinned: Any + TypeName + TimeBinnable + Collectable + erased_serde::Serialize {
+    fn as_time_binnable_dyn(&self) -> &dyn TimeBinnable;
+    fn as_collectable_mut(&mut self) -> &mut dyn Collectable;
+    fn edges_slice(&self) -> (&[u64], &[u64]);
+    fn counts(&self) -> &[u64];
+    fn mins(&self) -> Vec<f32>;
+    fn maxs(&self) -> Vec<f32>;
+    fn avgs(&self) -> Vec<f32>;
+    fn validate(&self) -> Result<(), String>;
+}
+
+pub trait TimeBinner: Send {
+    fn ingest(&mut self, item: &dyn TimeBinnable);
+    fn bins_ready_count(&self) -> usize;
+    fn bins_ready(&mut self) -> Option<Box<dyn TimeBinned>>;
+
+    /// If there is a bin in progress with non-zero count, push it to the result set.
+    /// With push_empty == true, a bin in progress is pushed even if it contains no counts.
+    fn push_in_progress(&mut self, push_empty: bool);
+
+    /// Implies `Self::push_in_progress` but in addition, pushes a zero-count bin if the call
+    /// to `push_in_progress` did not change the result count, as long as edges are left.
+    /// The next call to `Self::bins_ready_count` must return one higher count than before.
+    fn cycle(&mut self);
+
+    fn set_range_complete(&mut self);
+
+    fn empty(&self) -> Box<dyn TimeBinned>;
+}
+
+// TODO remove the Any bound. Factor out into custom AsAny trait.
+
+/// Provides a time-binned representation of the implementing type.
+/// In contrast to `TimeBinnableType` this is meant for trait objects.
+pub trait TimeBinnable: fmt::Debug + WithLen + RangeOverlapInfo + Any + AsAnyRef + AsAnyMut + Send {
+    // TODO implementors may fail if edges contain not at least 2 entries.
+    fn time_binner_new(&self, binrange: BinnedRangeEnum, do_time_weight: bool) -> Box<dyn TimeBinner>;
+    // TODO just a helper for the empty result.
+    fn to_box_to_json_result(&self) -> Box<dyn ToJsonResult>;
+}
+
+#[derive(Debug)]
+pub struct TimeBinnerDyn {}
+
+impl TimeBinnerTy for TimeBinnerDyn {
+    type Input = Box<dyn TimeBinnable>;
+    type Output = Box<dyn TimeBinned>;
+
+    fn ingest(&mut self, item: &mut Self::Input) {
+        todo!()
+    }
+
+    fn set_range_complete(&mut self) {
+        todo!()
+    }
+
+    fn bins_ready_count(&self) -> usize {
+        todo!()
+    }
+
+    fn bins_ready(&mut self) -> Option<Self::Output> {
+        todo!()
+    }
+
+    fn push_in_progress(&mut self, push_empty: bool) {
+        todo!()
+    }
+
+    fn cycle(&mut self) {
+        todo!()
+    }
+
+    fn empty(&self) -> Option<Self::Output> {
+        todo!()
+    }
+}
+
+impl TimeBinnableTy for Box<dyn TimeBinnable> {
+    type TimeBinner = TimeBinnerDyn;
+
+    fn time_binner_new(&self, binrange: BinnedRangeEnum, do_time_weight: bool) -> Self::TimeBinner {
+        todo!()
+    }
+}

items_0/src/transform.rs

@@ -1,6 +1,5 @@
-use std::pin;
-
 use crate::Events;
+use std::pin::Pin;
 
 pub struct TransformProperties {
     pub needs_one_before_range: bool,
@@ -25,7 +24,7 @@ where
     }
 }
 
-impl<T> EventTransform for pin::Pin<Box<T>>
+impl<T> EventTransform for Pin<Box<T>>
 where
     T: EventTransform,
 {