WIP on StreamItem unified top-level type, at least it compiles

disk/src/binnedstream.rs

@@ -1,21 +1,24 @@
+use crate::agg::binnedt::IntoBinnedT;
 use crate::agg::scalarbinbatch::MinMaxAvgScalarBinBatchStreamItem;
+use crate::agg::streams::{StatsItem, StreamItem};
+use crate::binned::scalar::adapter_to_stream_item;
+use crate::binned::BinnedScalarStreamItem;
 use crate::cache::pbvfs::{PreBinnedItem, PreBinnedValueFetchedStream};
 use crate::cache::{CacheUsage, PreBinnedQuery};
 use err::Error;
 use futures_core::Stream;
 use futures_util::StreamExt;
-#[allow(unused_imports)]
 use netpod::log::*;
 use netpod::{AggKind, BinnedRange, ByteSize, Channel, NodeConfigCached, PreBinnedPatchIterator};
 use std::future::ready;
 use std::pin::Pin;
 use std::task::{Context, Poll};
 
-pub struct BinnedStreamFromPreBinnedPatches {
-    inp: Pin<Box<dyn Stream<Item = Result<MinMaxAvgScalarBinBatchStreamItem, Error>> + Send>>,
+pub struct BinnedScalarStreamFromPreBinnedPatches {
+    inp: Pin<Box<dyn Stream<Item = Result<StreamItem<BinnedScalarStreamItem>, Error>> + Send>>,
 }
 
-impl BinnedStreamFromPreBinnedPatches {
+impl BinnedScalarStreamFromPreBinnedPatches {
     pub fn new(
         patch_it: PreBinnedPatchIterator,
         channel: Channel,
@@ -27,12 +30,14 @@ impl BinnedStreamFromPreBinnedPatches {
     ) -> Result<Self, Error> {
         let patches: Vec<_> = patch_it.collect();
         let mut sp = String::new();
-        for (i, p) in patches.iter().enumerate() {
-            use std::fmt::Write;
-            write!(sp, "  • patch {:2}  {:?}\n", i, p)?;
+        if false {
+            // Convert this to a StreamLog message:
+            for (i, p) in patches.iter().enumerate() {
+                use std::fmt::Write;
+                write!(sp, "  • patch {:2}  {:?}\n", i, p)?;
+            }
+            info!("BinnedStream::new\n{}", sp);
         }
-        info!("BinnedStream::new\n{}", sp);
-        use super::agg::binnedt::IntoBinnedT;
         let inp = futures_util::stream::iter(patches.into_iter())
             .map({
                 let node_config = node_config.clone();
@@ -67,31 +72,44 @@ impl BinnedStreamFromPreBinnedPatches {
                                 Fits::Inside
                                 | Fits::PartlyGreater
                                 | Fits::PartlyLower
-                                | Fits::PartlyLowerAndGreater => Some(Ok(MinMaxAvgScalarBinBatchStreamItem::Values(k))),
+                                | Fits::PartlyLowerAndGreater => {
+                                    Some(Ok(StreamItem::DataItem(BinnedScalarStreamItem::Values(k))))
+                                }
                                 _ => None,
                             }
                         }
-                        Ok(PreBinnedItem::RangeComplete) => Some(Ok(MinMaxAvgScalarBinBatchStreamItem::RangeComplete)),
-                        Ok(PreBinnedItem::EventDataReadStats(stats)) => {
-                            Some(Ok(MinMaxAvgScalarBinBatchStreamItem::EventDataReadStats(stats)))
+                        Ok(PreBinnedItem::RangeComplete) => {
+                            Some(Ok(StreamItem::DataItem(BinnedScalarStreamItem::RangeComplete)))
                         }
-                        Ok(PreBinnedItem::Log(item)) => Some(Ok(MinMaxAvgScalarBinBatchStreamItem::Log(item))),
+                        Ok(PreBinnedItem::EventDataReadStats(item)) => {
+                            Some(Ok(StreamItem::Stats(StatsItem::EventDataReadStats(item))))
+                        }
+                        Ok(PreBinnedItem::Log(item)) => Some(Ok(StreamItem::Log(item))),
                         Err(e) => Some(Err(e)),
                     };
                     ready(g)
                 }
-            })
-            .into_binned_t(range);
+            });
+        //let inp: Box<dyn Stream<Item = Result<StreamItem<BinnedScalarStreamItem>, Error>> + Send + Unpin> =
+        //    Box::new(inp);
+        //let inp: &Stream<Item = Result<StreamItem<BinnedScalarStreamItem>, Error>> + Send + Unpin>> = &inp
+        //() == inp;
+        let inp = IntoBinnedT::into_binned_t(inp, range);
         Ok(Self { inp: Box::pin(inp) })
+        //err::todoval()
     }
 }
 
-impl Stream for BinnedStreamFromPreBinnedPatches {
-    // TODO make this generic over all possible things
-    type Item = Result<MinMaxAvgScalarBinBatchStreamItem, Error>;
+impl Stream for BinnedScalarStreamFromPreBinnedPatches {
+    type Item = Result<StreamItem<BinnedScalarStreamItem>, Error>;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
-        self.inp.poll_next_unpin(cx)
+        use Poll::*;
+        match self.inp.poll_next_unpin(cx) {
+            Ready(Some(item)) => Ready(Some(item)),
+            Ready(None) => Ready(None),
+            Pending => Pending,
+        }
     }
 }
 
@@ -100,14 +118,12 @@ pub struct BinnedStream<I> {
 }
 
 impl<I> BinnedStream<I> {
-    // Item was: Result<MinMaxAvgScalarBinBatchStreamItem, Error>
     pub fn new(inp: Pin<Box<dyn Stream<Item = I> + Send>>) -> Result<Self, Error> {
         Ok(Self { inp })
     }
 }
 
 impl<I> Stream for BinnedStream<I> {
-    //type Item = Result<MinMaxAvgScalarBinBatchStreamItem, Error>;
     type Item = I;
 
     fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {