Introduce EventAppendable

items/src/eventvalues.rs

@@ -2,8 +2,9 @@ use crate::minmaxavgbins::MinMaxAvgBins;
 use crate::numops::NumOps;
 use crate::streams::{Collectable, Collector};
 use crate::{
-    ts_offs_from_abs, Appendable, FilterFittingInside, Fits, FitsInside, PushableIndex, RangeOverlapInfo, ReadPbv,
-    ReadableFromFile, SitemtyFrameType, TimeBinnableType, TimeBinnableTypeAggregator, WithLen, WithTimestamps,
+    ts_offs_from_abs, Appendable, EventAppendable, FilterFittingInside, Fits, FitsInside, PushableIndex,
+    RangeOverlapInfo, ReadPbv, ReadableFromFile, SitemtyFrameType, TimeBinnableType, TimeBinnableTypeAggregator,
+    WithLen, WithTimestamps,
 };
 use err::Error;
 use netpod::NanoRange;
@@ -250,6 +251,7 @@ where
         Self::Collector::new()
     }
 }
+
 pub struct EventValuesAggregator<NTY> {
     range: NanoRange,
     count: u64,
@@ -339,3 +341,15 @@ where
         }
     }
 }
+
+impl<NTY> EventAppendable for EventValues<NTY>
+where
+    NTY: NumOps,
+{
+    type Value = NTY;
+
+    fn append_event(&mut self, ts: u64, value: Self::Value) {
+        self.tss.push(ts);
+        self.values.push(value);
+    }
+}

items/src/lib.rs

@@ -231,7 +231,7 @@ pub trait EventsNodeProcessor: Send + Unpin {
     type Input;
     type Output: Send + Unpin + DeserializeOwned + WithTimestamps + TimeBinnableType;
     fn create(shape: Shape, agg_kind: AggKind) -> Self;
-    fn process(&self, inp: EventValues<Self::Input>) -> Self::Output;
+    fn process(&self, inp: Self::Input) -> Self::Output;
 }
 
 #[derive(Clone, Debug, Deserialize)]
@@ -294,6 +294,11 @@ pub trait Appendable: WithLen {
     fn append(&mut self, src: &Self);
 }
 
+pub trait EventAppendable {
+    type Value;
+    fn append_event(&mut self, ts: u64, value: Self::Value);
+}
+
 pub trait TimeBins: Send + Unpin + WithLen + Appendable + FilterFittingInside {
     fn ts1s(&self) -> &Vec<u64>;
     fn ts2s(&self) -> &Vec<u64>;

items/src/waveevents.rs

@@ -4,8 +4,9 @@ use crate::numops::NumOps;
 use crate::xbinnedscalarevents::XBinnedScalarEvents;
 use crate::xbinnedwaveevents::XBinnedWaveEvents;
 use crate::{
-    Appendable, EventsNodeProcessor, FilterFittingInside, Fits, FitsInside, PushableIndex, RangeOverlapInfo, ReadPbv,
-    ReadableFromFile, SitemtyFrameType, SubFrId, TimeBinnableType, TimeBinnableTypeAggregator, WithLen, WithTimestamps,
+    Appendable, EventAppendable, EventsNodeProcessor, FilterFittingInside, Fits, FitsInside, PushableIndex,
+    RangeOverlapInfo, ReadPbv, ReadableFromFile, SitemtyFrameType, SubFrId, TimeBinnableType,
+    TimeBinnableTypeAggregator, WithLen, WithTimestamps,
 };
 use err::Error;
 use netpod::log::*;
@@ -267,6 +268,18 @@ where
     }
 }
 
+impl<NTY> EventAppendable for WaveEvents<NTY>
+where
+    NTY: NumOps,
+{
+    type Value = Vec<NTY>;
+
+    fn append_event(&mut self, ts: u64, value: Self::Value) {
+        self.tss.push(ts);
+        self.vals.push(value);
+    }
+}
+
 pub struct WaveXBinner<NTY> {
     _m1: PhantomData<NTY>,
 }
@@ -275,14 +288,14 @@ impl<NTY> EventsNodeProcessor for WaveXBinner<NTY>
 where
     NTY: NumOps,
 {
-    type Input = Vec<NTY>;
+    type Input = WaveEvents<NTY>;
     type Output = XBinnedScalarEvents<NTY>;
 
     fn create(_shape: Shape, _agg_kind: AggKind) -> Self {
         Self { _m1: PhantomData }
     }
 
-    fn process(&self, inp: EventValues<Self::Input>) -> Self::Output {
+    fn process(&self, inp: Self::Input) -> Self::Output {
         let nev = inp.tss.len();
         let mut ret = Self::Output {
             tss: inp.tss,
@@ -295,7 +308,7 @@ where
             let mut max = NTY::min_or_nan();
             let mut sum = 0f32;
             let mut sumc = 0;
-            let vals = &inp.values[i1];
+            let vals = &inp.vals[i1];
             for &v in vals {
                 if v < min || min.is_nan() {
                     min = v;
@@ -332,7 +345,7 @@ impl<NTY> EventsNodeProcessor for WaveNBinner<NTY>
 where
     NTY: NumOps,
 {
-    type Input = Vec<NTY>;
+    type Input = WaveEvents<NTY>;
     type Output = XBinnedWaveEvents<NTY>;
 
     fn create(shape: Shape, agg_kind: AggKind) -> Self {
@@ -348,7 +361,7 @@ where
         }
     }
 
-    fn process(&self, inp: EventValues<Self::Input>) -> Self::Output {
+    fn process(&self, inp: Self::Input) -> Self::Output {
         let nev = inp.tss.len();
         let mut ret = Self::Output {
             // TODO get rid of this clone:
@@ -362,7 +375,7 @@ where
             let mut max = vec![NTY::min_or_nan(); self.x_bin_count];
             let mut sum = vec![0f32; self.x_bin_count];
             let mut sumc = vec![0u64; self.x_bin_count];
-            for (i2, &v) in inp.values[i1].iter().enumerate() {
+            for (i2, &v) in inp.vals[i1].iter().enumerate() {
                 let i3 = i2 * self.x_bin_count / self.shape_bin_count;
                 if v < min[i3] || min[i3].is_nan() {
                     min[i3] = v;
@@ -401,25 +414,25 @@ impl<NTY> EventsNodeProcessor for WavePlainProc<NTY>
 where
     NTY: NumOps,
 {
-    type Input = Vec<NTY>;
+    type Input = WaveEvents<NTY>;
     type Output = WaveEvents<NTY>;
 
     fn create(_shape: Shape, _agg_kind: AggKind) -> Self {
         Self { _m1: PhantomData }
     }
 
-    fn process(&self, inp: EventValues<Self::Input>) -> Self::Output {
+    fn process(&self, inp: Self::Input) -> Self::Output {
         if false {
-            let n = if inp.values.len() > 0 { inp.values[0].len() } else { 0 };
+            let n = if inp.vals.len() > 0 { inp.vals[0].len() } else { 0 };
             let n = if n > 5 { 5 } else { n };
             WaveEvents {
                 tss: inp.tss,
-                vals: inp.values.iter().map(|k| k[..n].to_vec()).collect(),
+                vals: inp.vals.iter().map(|k| k[..n].to_vec()).collect(),
             }
         } else {
             WaveEvents {
                 tss: inp.tss,
-                vals: inp.values,
+                vals: inp.vals,
             }
         }
     }