Remove unused

items_2/src/binsdim0.rs

@@ -390,26 +390,27 @@ impl<NTY: ScalarOps> CollectorType for BinsDim0Collector<NTY> {
         let bin_count_exp = if let Some(r) = &binrange {
             r.bin_count() as u32
         } else {
+            eprintln!("no binrange given");
             0
         };
         let bin_count = self.vals.ts1s.len() as u32;
-        let (missing_bins, continue_at, finished_at) = if self.range_final {
-            if bin_count < bin_count_exp {
-                match self.vals.ts2s.back() {
-                    Some(&k) => {
-                        let missing_bins = bin_count_exp - bin_count;
-                        let continue_at = IsoDateTime(Utc.timestamp_nanos(k as i64));
-                        let u = k + (k - self.vals.ts1s.back().unwrap()) * missing_bins as u64;
-                        let finished_at = IsoDateTime(Utc.timestamp_nanos(u as i64));
-                        (missing_bins, Some(continue_at), Some(finished_at))
-                    }
-                    None => {
-                        warn!("can not determine continue-at parameters");
-                        (0, None, None)
-                    }
+        eprintln!(
+            "--------------  MAKE MISSING BINS  bin_count_exp {}  bin_count {}",
+            bin_count_exp, bin_count
+        );
+        let (missing_bins, continue_at, finished_at) = if bin_count < bin_count_exp {
+            match self.vals.ts2s.back() {
+                Some(&k) => {
+                    let missing_bins = bin_count_exp - bin_count;
+                    let continue_at = IsoDateTime(Utc.timestamp_nanos(k as i64));
+                    let u = k + (k - self.vals.ts1s.back().unwrap()) * missing_bins as u64;
+                    let finished_at = IsoDateTime(Utc.timestamp_nanos(u as i64));
+                    (missing_bins, Some(continue_at), Some(finished_at))
+                }
+                None => {
+                    warn!("can not determine continue-at parameters");
+                    (0, None, None)
                 }
-            } else {
-                (0, None, None)
             }
         } else {
             (0, None, None)

items_2/src/items_2.rs

@@ -33,6 +33,7 @@ use items_0::TimeBinner;
 use netpod::log::*;
 use netpod::timeunits::*;
 use netpod::AggKind;
+use netpod::BinnedRange;
 use netpod::NanoRange;
 use netpod::ScalarType;
 use netpod::Shape;
@@ -375,11 +376,12 @@ pub async fn binned_collected(
     scalar_type: ScalarType,
     shape: Shape,
     agg_kind: AggKind,
-    edges: Vec<u64>,
+    binrange: BinnedRange,
     timeout: Duration,
     inp: Pin<Box<dyn Stream<Item = Sitemty<ChannelEvents>> + Send>>,
 ) -> Result<Box<dyn ToJsonResult>, Error> {
     event!(Level::TRACE, "binned_collected");
+    let edges = binrange.edges();
     if edges.len() < 2 {
         return Err(format!("binned_collected  but edges.len() {}", edges.len()).into());
     }
@@ -476,7 +478,7 @@ pub async fn binned_collected(
     }
     match coll {
         Some(mut coll) => {
-            let res = coll.result(None, None).map_err(|e| format!("{e}"))?;
+            let res = coll.result(None, Some(binrange)).map_err(|e| format!("{e}"))?;
             tokio::time::sleep(Duration::from_millis(2000)).await;
             Ok(res)
         }

items_2/src/test.rs

@@ -444,22 +444,19 @@ fn bin02() {
         let inp1 = Box::pin(inp1);
         let inp2 = Box::pin(futures_util::stream::empty()) as _;
         let stream = ChannelEventsMerger::new(vec![inp1, inp2]);
-        if false {
-            // covering_range result is subject to adjustments, instead, manually choose bin edges
-            let range = NanoRange {
-                beg: TSBASE + SEC * 1,
-                end: TSBASE + SEC * 10,
-            };
-            let covering = BinnedRange::covering_range(range, 3).map_err(|e| format!("{e}"))?;
-            assert_eq!(covering.edges().len(), 6);
-        }
-        let edges = (0..10).into_iter().map(|x| TSBASE + SEC * 1 + SEC * x).collect();
+        // covering_range result is subject to adjustments, instead, manually choose bin edges
+        let range = NanoRange {
+            beg: TSBASE + SEC * 1,
+            end: TSBASE + SEC * 10,
+        };
+        let binrange = BinnedRange::covering_range(range, 9).map_err(|e| format!("{e}"))?;
+        assert_eq!(binrange.edges().len(), 10);
         let stream = Box::pin(stream);
         let collected = binned_collected(
             ScalarType::F32,
             Shape::Scalar,
             AggKind::TimeWeightedScalar,
-            edges,
+            binrange,
             Duration::from_millis(2000),
             stream,
         )
@@ -499,19 +496,27 @@ fn binned_timeout_01() {
             }
             k
         });
-        let edges = (0..10).into_iter().map(|x| TSBASE + SEC * (1 + x)).collect();
+        let edges: Vec<_> = (0..10).into_iter().map(|x| TSBASE + SEC * (1 + x)).collect();
+        let range = NanoRange {
+            beg: TSBASE + SEC * 1,
+            end: TSBASE + SEC * 10,
+        };
+        let binrange = BinnedRange::covering_range(range, 9)?;
+        eprintln!("edges1: {:?}", edges);
+        eprintln!("edges2: {:?}", binrange.edges());
         let inp1 = Box::pin(inp1) as _;
         let timeout = Duration::from_millis(400);
         let res = binned_collected(
             ScalarType::F32,
             Shape::Scalar,
             AggKind::TimeWeightedScalar,
-            edges,
+            binrange,
             timeout,
             inp1,
         )
         .await?;
         let r2: &BinsDim0CollectedResult<f32> = res.as_any_ref().downcast_ref().expect("res seems wrong type");
+        eprintln!("rs: {r2:?}");
         assert_eq!(SEC * r2.ts_anchor_sec(), TSBASE + SEC);
         assert_eq!(r2.counts(), &[10, 10, 10]);
         assert_eq!(r2.mins(), &[3.0, 2.0, 3.0]);