Refactor

items_0/src/framable.rs

@@ -0,0 +1,19 @@
+// Required for any inner type of Sitemty.
+pub trait FrameTypeInnerStatic {
+    const FRAME_TYPE_ID: u32;
+}
+
+// To be implemented by the T of Sitemty<T>, e.g. ScalarEvents.
+pub trait FrameTypeInnerDyn {
+    // TODO check actual usage of this
+    fn frame_type_id(&self) -> u32;
+}
+
+impl<T> FrameTypeInnerDyn for T
+where
+    T: FrameTypeInnerStatic,
+{
+    fn frame_type_id(&self) -> u32 {
+        <Self as FrameTypeInnerStatic>::FRAME_TYPE_ID
+    }
+}

items_0/src/isodate.rs

@@ -0,0 +1,24 @@
+use chrono::DateTime;
+use chrono::TimeZone;
+use chrono::Utc;
+use serde::Deserialize;
+use serde::Serialize;
+use serde::Serializer;
+
+#[derive(Clone, Debug, Deserialize)]
+pub struct IsoDateTime(DateTime<Utc>);
+
+impl Serialize for IsoDateTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_str(&self.0.format("%Y-%m-%dT%H:%M:%S.%3fZ").to_string())
+    }
+}
+
+pub fn make_iso_ts(tss: &[u64]) -> Vec<IsoDateTime> {
+    tss.iter()
+        .map(|&k| IsoDateTime(Utc.timestamp_nanos(k as i64)))
+        .collect()
+}

items_0/src/items_0.rs

@@ -1,6 +1,9 @@
 pub mod collect_c;
 pub mod collect_s;
+pub mod framable;
+pub mod isodate;
 pub mod scalar_ops;
+pub mod streamitem;
 pub mod subfr;
 
 pub mod bincode {
@@ -91,7 +94,7 @@ where
 }
 
 /// Data in time-binned form.
-pub trait TimeBinned: Any + TimeBinnable + crate::collect_c::Collectable {
+pub trait TimeBinned: Any + TimeBinnable + crate::collect_c::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]);

items_0/src/streamitem.rs

@@ -0,0 +1,179 @@
+use crate::TimeBinned;
+use err::Error;
+use netpod::log::Level;
+use netpod::DiskStats;
+use netpod::EventDataReadStats;
+use netpod::RangeFilterStats;
+use serde::Deserialize;
+use serde::Serialize;
+
+pub const TERM_FRAME_TYPE_ID: u32 = 0xaa01;
+pub const ERROR_FRAME_TYPE_ID: u32 = 0xaa02;
+pub const SITEMTY_NONSPEC_FRAME_TYPE_ID: u32 = 0xaa04;
+pub const EVENT_QUERY_JSON_STRING_FRAME: u32 = 0x100;
+pub const EVENTS_0D_FRAME_TYPE_ID: u32 = 0x500;
+pub const MIN_MAX_AVG_DIM_0_BINS_FRAME_TYPE_ID: u32 = 0x700;
+pub const MIN_MAX_AVG_DIM_1_BINS_FRAME_TYPE_ID: u32 = 0x800;
+pub const MIN_MAX_AVG_WAVE_BINS: u32 = 0xa00;
+pub const WAVE_EVENTS_FRAME_TYPE_ID: u32 = 0xb00;
+pub const LOG_FRAME_TYPE_ID: u32 = 0xc00;
+pub const STATS_FRAME_TYPE_ID: u32 = 0xd00;
+pub const RANGE_COMPLETE_FRAME_TYPE_ID: u32 = 0xe00;
+pub const EVENT_FULL_FRAME_TYPE_ID: u32 = 0x2200;
+pub const EVENTS_ITEM_FRAME_TYPE_ID: u32 = 0x2300;
+pub const STATS_EVENTS_FRAME_TYPE_ID: u32 = 0x2400;
+pub const ITEMS_2_CHANNEL_EVENTS_FRAME_TYPE_ID: u32 = 0x2500;
+pub const X_BINNED_SCALAR_EVENTS_FRAME_TYPE_ID: u32 = 0x8800;
+pub const X_BINNED_WAVE_EVENTS_FRAME_TYPE_ID: u32 = 0x8900;
+pub const DATABUFFER_EVENT_BLOB_FRAME_TYPE_ID: u32 = 0x8a00;
+
+pub fn bool_is_false(j: &bool) -> bool {
+    *j == false
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum RangeCompletableItem<T> {
+    RangeComplete,
+    Data(T),
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum StatsItem {
+    EventDataReadStats(EventDataReadStats),
+    RangeFilterStats(RangeFilterStats),
+    DiskStats(DiskStats),
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub enum StreamItem<T> {
+    DataItem(T),
+    Log(LogItem),
+    Stats(StatsItem),
+}
+
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
+pub struct LogItem {
+    pub node_ix: u32,
+    #[serde(with = "levelserde")]
+    pub level: Level,
+    pub msg: String,
+}
+
+impl LogItem {
+    pub fn quick(level: Level, msg: String) -> Self {
+        Self {
+            level,
+            msg,
+            node_ix: 42,
+        }
+    }
+}
+
+pub type Sitemty<T> = Result<StreamItem<RangeCompletableItem<T>>, Error>;
+
+#[macro_export]
+macro_rules! on_sitemty_range_complete {
+    ($item:expr, $ex:expr) => {
+        if let Ok($crate::StreamItem::DataItem($crate::RangeCompletableItem::RangeComplete)) = $item {
+            $ex
+        }
+    };
+}
+
+pub fn sitem_data<X>(x: X) -> Sitemty<X> {
+    Ok(StreamItem::DataItem(RangeCompletableItem::Data(x)))
+}
+
+mod levelserde {
+    use super::Level;
+    use serde::de::{self, Visitor};
+    use serde::{Deserializer, Serializer};
+    use std::fmt;
+
+    pub fn serialize<S>(t: &Level, se: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        let g = match *t {
+            Level::ERROR => 1,
+            Level::WARN => 2,
+            Level::INFO => 3,
+            Level::DEBUG => 4,
+            Level::TRACE => 5,
+        };
+        se.serialize_u32(g)
+    }
+
+    struct VisitLevel;
+
+    impl VisitLevel {
+        fn from_u32(x: u32) -> Level {
+            match x {
+                1 => Level::ERROR,
+                2 => Level::WARN,
+                3 => Level::INFO,
+                4 => Level::DEBUG,
+                5 => Level::TRACE,
+                _ => Level::TRACE,
+            }
+        }
+    }
+
+    impl<'de> Visitor<'de> for VisitLevel {
+        type Value = Level;
+
+        fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+            write!(fmt, "expect Level code")
+        }
+
+        fn visit_u64<E>(self, val: u64) -> Result<Self::Value, E>
+        where
+            E: de::Error,
+        {
+            Ok(VisitLevel::from_u32(val as _))
+        }
+    }
+
+    pub fn deserialize<'de, D>(de: D) -> Result<Level, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        de.deserialize_u32(VisitLevel)
+    }
+}
+
+pub trait ContainsError {
+    fn is_err(&self) -> bool;
+    fn err(&self) -> Option<&::err::Error>;
+}
+
+impl<T> ContainsError for Box<T>
+where
+    T: ContainsError,
+{
+    fn is_err(&self) -> bool {
+        self.as_ref().is_err()
+    }
+
+    fn err(&self) -> Option<&::err::Error> {
+        self.as_ref().err()
+    }
+}
+
+impl<T> ContainsError for Sitemty<T> {
+    fn is_err(&self) -> bool {
+        match self {
+            Ok(_) => false,
+            Err(_) => true,
+        }
+    }
+
+    fn err(&self) -> Option<&::err::Error> {
+        match self {
+            Ok(_) => None,
+            Err(e) => Some(e),
+        }
+    }
+}
+
+erased_serde::serialize_trait_object!(TimeBinned);