WIP

items_2/src/items_2.rs

@@ -15,6 +15,7 @@ pub mod streams;
 #[cfg(test)]
 pub mod test;
 pub mod testgen;
+pub mod transform;
 
 use channelevents::ChannelEvents;
 use chrono::DateTime;

items_2/src/merger.rs

@@ -9,6 +9,7 @@ use items_0::streamitem::Sitemty;
 use items_0::streamitem::StreamItem;
 use items_0::transform::EventTransform;
 use items_0::transform::TransformProperties;
+use items_0::transform::WithTransformProperties;
 use items_0::MergeError;
 use items_0::WithLen;
 use netpod::log::*;
@@ -444,11 +445,13 @@ where
     }
 }
 
-impl<T> EventTransform for Merger<T> {
+impl<T> WithTransformProperties for Merger<T> {
     fn query_transform_properties(&self) -> TransformProperties {
         todo!()
     }
+}
 
+impl<T> EventTransform for Merger<T> {
     fn transform(&mut self, src: Box<dyn items_0::Events>) -> Box<dyn items_0::Events> {
         todo!()
     }

items_2/src/streams.rs

@@ -4,6 +4,7 @@ use futures_util::Stream;
 use futures_util::StreamExt;
 use items_0::transform::EventTransform;
 use items_0::transform::TransformProperties;
+use items_0::transform::WithTransformProperties;
 use std::collections::VecDeque;
 use std::pin::Pin;
 use std::task::Context;
@@ -43,11 +44,19 @@ where
     }
 }
 
-impl<T> EventTransform for Enumerate2<T> {
+impl<T> WithTransformProperties for Enumerate2<T>
+where
+    T: WithTransformProperties,
+{
     fn query_transform_properties(&self) -> TransformProperties {
-        todo!()
+        self.inp.query_transform_properties()
     }
+}
 
+impl<T> EventTransform for Enumerate2<T>
+where
+    T: WithTransformProperties,
+{
     fn transform(&mut self, src: Box<dyn items_0::Events>) -> Box<dyn items_0::Events> {
         todo!()
     }
@@ -64,7 +73,10 @@ where
     T: Stream,
     F: Fn(<T as Stream>::Item) -> Fut,
 {
-    pub fn new(inp: T, f: F) -> Self {
+    pub fn new(inp: T, f: F) -> Self
+    where
+        T: EventTransform,
+    {
         Self {
             inp: Box::pin(inp),
             f: Box::pin(f),
@@ -118,11 +130,19 @@ where
     }
 }
 
-impl<T, F, Fut> EventTransform for Then2<T, F, Fut> {
+impl<T, F, Fut> WithTransformProperties for Then2<T, F, Fut>
+where
+    T: EventTransform,
+{
     fn query_transform_properties(&self) -> TransformProperties {
-        todo!()
+        self.inp.query_transform_properties()
     }
+}
 
+impl<T, F, Fut> EventTransform for Then2<T, F, Fut>
+where
+    T: EventTransform,
+{
     fn transform(&mut self, src: Box<dyn items_0::Events>) -> Box<dyn items_0::Events> {
         todo!()
     }
@@ -186,11 +206,13 @@ where
     }
 }
 
-impl<T> EventTransform for VecStream<T> {
+impl<T> WithTransformProperties for VecStream<T> {
     fn query_transform_properties(&self) -> TransformProperties {
         todo!()
     }
+}
 
+impl<T> EventTransform for VecStream<T> {
     fn transform(&mut self, src: Box<dyn items_0::Events>) -> Box<dyn items_0::Events> {
         todo!()
     }

items_2/src/transform.rs

@@ -0,0 +1,97 @@
+//! Helper functions to create transforms which act locally on a batch of events.
+//! Tailored to the usage pattern given by `TransformQuery`.
+
+use crate::channelevents::ChannelEvents;
+use crate::eventsdim0::EventsDim0;
+use items_0::transform::EventStream;
+use items_0::transform::EventTransform;
+use items_0::transform::TransformEvent;
+use items_0::transform::TransformProperties;
+use items_0::transform::WithTransformProperties;
+use items_0::Appendable;
+use items_0::AsAnyMut;
+use items_0::Empty;
+use items_0::Events;
+use items_0::EventsNonObj;
+use netpod::log::*;
+use std::mem;
+
+struct TransformEventIdentity {}
+
+impl WithTransformProperties for TransformEventIdentity {
+    fn query_transform_properties(&self) -> TransformProperties {
+        todo!()
+    }
+}
+
+impl EventTransform for TransformEventIdentity {
+    fn transform(&mut self, src: Box<dyn Events>) -> Box<dyn Events> {
+        todo!()
+    }
+}
+
+pub fn make_transform_identity() -> TransformEvent {
+    TransformEvent(Box::new(TransformEventIdentity {}))
+}
+
+struct TransformEventMinMaxAvg {}
+
+impl WithTransformProperties for TransformEventMinMaxAvg {
+    fn query_transform_properties(&self) -> TransformProperties {
+        todo!()
+    }
+}
+
+impl EventTransform for TransformEventMinMaxAvg {
+    fn transform(&mut self, src: Box<dyn Events>) -> Box<dyn Events> {
+        todo!()
+    }
+}
+
+pub fn make_transform_min_max_avg() -> TransformEvent {
+    TransformEvent(Box::new(TransformEventMinMaxAvg {}))
+}
+
+struct TransformEventPulseIdDiff {}
+
+impl WithTransformProperties for TransformEventPulseIdDiff {
+    fn query_transform_properties(&self) -> TransformProperties {
+        todo!()
+    }
+}
+
+impl EventTransform for TransformEventPulseIdDiff {
+    fn transform(&mut self, src: Box<dyn Events>) -> Box<dyn Events> {
+        let mut src = src;
+        if let Some(chevs) = src.as_any_mut().downcast_mut::<ChannelEvents>() {
+            let chevs2 = chevs;
+            let chevs = mem::replace(chevs2, ChannelEvents::Status(None));
+            let mut pulse_last = None;
+            match chevs {
+                ChannelEvents::Events(item) => {
+                    let (tss, pulses) = EventsNonObj::into_tss_pulses(item);
+                    let mut item = EventsDim0::empty();
+                    for (ts, pulse) in tss.into_iter().zip(pulses) {
+                        let value = if let Some(last) = pulse_last {
+                            pulse as i64 - last as i64
+                        } else {
+                            0
+                        };
+                        item.push(ts, pulse, value);
+                        pulse_last = Some(pulse);
+                    }
+                    *chevs2 = ChannelEvents::Events(Box::new(item));
+                }
+                ChannelEvents::Status(_) => {}
+            }
+            src
+        } else {
+            warn!("make_transform_pulse_id_diff item is not ChannelEvents");
+            src
+        }
+    }
+}
+
+pub fn make_transform_pulse_id_diff() -> TransformEvent {
+    TransformEvent(Box::new(TransformEventPulseIdDiff {}))
+}