daqbuf/daqbuffer
0
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

WIP typechecks and basic run

Browse Source
This commit is contained in:
Dominik Werder
2024-10-24 16:12:29 +02:00
parent e6ece07137
commit 130dabce40
20 changed files with 418 additions and 215 deletions
Download Patch File Download Diff File Expand all files Collapse all files

144
crates/items_0/src/collect_s.rs
View File

@@ -1,4 +1,5 @@
use crate::container::ByteEstimate;
use crate::timebin::BinningggContainerBinsDyn;
use crate::timebin::TimeBinned;
use crate::AsAnyMut;
use crate::AsAnyRef;
@@ -19,13 +20,10 @@ pub trait ToJsonBytes {
fn to_json_bytes(&self) -> Result<Vec<u8>, Error>;
}
// TODO check usage of this trait
pub trait ToJsonResult: erased_serde::Serialize + fmt::Debug + AsAnyRef + AsAnyMut + Send {
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error>;
pub trait ToJsonResult: fmt::Debug + AsAnyRef + AsAnyMut + Send {
fn to_json_value(&self) -> Result<serde_json::Value, Error>;
}
erased_serde::serialize_trait_object!(ToJsonResult);
impl AsAnyRef for serde_json::Value {
fn as_any_ref(&self) -> &dyn Any {
self
@@ -39,8 +37,8 @@ impl AsAnyMut for serde_json::Value {
}
impl ToJsonResult for serde_json::Value {
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error> {
Ok(Box::new(self.clone()))
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
Ok(self.clone())
}
}
@@ -50,34 +48,31 @@ impl ToJsonBytes for serde_json::Value {
}
}
pub trait Collected: fmt::Debug + TypeName + Send + AsAnyRef + WithLen + ToJsonResult {}
pub trait CollectedDyn: fmt::Debug + TypeName + Send + AsAnyRef + WithLen + ToJsonResult {}
erased_serde::serialize_trait_object!(Collected);
impl ToJsonResult for Box<dyn Collected> {
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error> {
self.as_ref().to_json_result()
impl ToJsonResult for Box<dyn CollectedDyn> {
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
ToJsonResult::to_json_value(self.as_ref())
}
}
impl WithLen for Box<dyn Collected> {
impl WithLen for Box<dyn CollectedDyn> {
fn len(&self) -> usize {
self.as_ref().len()
}
}
impl TypeName for Box<dyn Collected> {
impl TypeName for Box<dyn CollectedDyn> {
fn type_name(&self) -> String {
self.as_ref().type_name()
}
}
impl Collected for Box<dyn Collected> {}
impl CollectedDyn for Box<dyn CollectedDyn> {}
// TODO rename to `Typed`
pub trait CollectorType: fmt::Debug + Send + Unpin + WithLen + ByteEstimate {
type Input: Collectable;
type Output: Collected + ToJsonResult + Serialize;
pub trait CollectorTy: fmt::Debug + Send + Unpin + WithLen + ByteEstimate {
type Input: CollectableDyn;
type Output: CollectedDyn + ToJsonResult + Serialize;
fn ingest(&mut self, src: &mut Self::Input);
fn set_range_complete(&mut self);
@@ -88,8 +83,8 @@ pub trait CollectorType: fmt::Debug + Send + Unpin + WithLen + ByteEstimate {
fn result(&mut self, range: Option<SeriesRange>, binrange: Option<BinnedRangeEnum>) -> Result<Self::Output, Error>;
}
pub trait Collector: fmt::Debug + Send + WithLen + ByteEstimate {
fn ingest(&mut self, src: &mut dyn Collectable);
pub trait CollectorDyn: fmt::Debug + Send + WithLen + ByteEstimate {
fn ingest(&mut self, src: &mut dyn CollectableDyn);
fn set_range_complete(&mut self);
fn set_timed_out(&mut self);
fn set_continue_at_here(&mut self);
@@ -98,26 +93,26 @@ pub trait Collector: fmt::Debug + Send + WithLen + ByteEstimate {
&mut self,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
) -> Result<Box<dyn Collected>, Error>;
) -> Result<Box<dyn CollectedDyn>, Error>;
}
impl<T> Collector for T
impl<T> CollectorDyn for T
where
T: fmt::Debug + CollectorType + 'static,
T: fmt::Debug + CollectorTy + 'static,
{
fn ingest(&mut self, src: &mut dyn Collectable) {
if let Some(src) = src.as_any_mut().downcast_mut::<<T as CollectorType>::Input>() {
fn ingest(&mut self, src: &mut dyn CollectableDyn) {
if let Some(src) = src.as_any_mut().downcast_mut::<<T as CollectorTy>::Input>() {
trace!("sees incoming &mut ref");
T::ingest(self, src)
} else {
if let Some(src) = src.as_any_mut().downcast_mut::<Box<<T as CollectorType>::Input>>() {
if let Some(src) = src.as_any_mut().downcast_mut::<Box<<T as CollectorTy>::Input>>() {
trace!("sees incoming &mut Box");
T::ingest(self, src)
} else {
error!(
"No idea what this is. Expect: {} input {} got: {} {:?}",
any::type_name::<T>(),
any::type_name::<<T as CollectorType>::Input>(),
any::type_name::<<T as CollectorTy>::Input>(),
src.type_name(),
src
);
@@ -141,7 +136,7 @@ where
&mut self,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
) -> Result<Box<dyn Collected>, Error> {
) -> Result<Box<dyn CollectedDyn>, Error> {
let ret = T::result(self, range, binrange)?;
Ok(Box::new(ret))
}
@@ -149,12 +144,73 @@ where
// TODO rename to `Typed`
pub trait CollectableType: fmt::Debug + WithLen + AsAnyRef + AsAnyMut + TypeName + Send {
type Collector: CollectorType<Input = Self>;
type Collector: CollectorTy<Input = Self>;
fn new_collector() -> Self::Collector;
}
pub trait Collectable: fmt::Debug + WithLen + AsAnyRef + AsAnyMut + TypeName + Send {
fn new_collector(&self) -> Box<dyn Collector>;
#[derive(Debug)]
pub struct CollectorForDyn {
inner: Box<dyn CollectorDyn>,
}
impl WithLen for CollectorForDyn {
fn len(&self) -> usize {
todo!()
}
}
impl ByteEstimate for CollectorForDyn {
fn byte_estimate(&self) -> u64 {
todo!()
}
}
impl CollectorDyn for CollectorForDyn {
fn ingest(&mut self, src: &mut dyn CollectableDyn) {
todo!()
}
fn set_range_complete(&mut self) {
todo!()
}
fn set_timed_out(&mut self) {
todo!()
}
fn set_continue_at_here(&mut self) {
todo!()
}
fn result(
&mut self,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
) -> Result<Box<dyn crate::collect_s::CollectedDyn>, Error> {
todo!()
}
}
pub trait CollectableDyn: fmt::Debug + WithLen + AsAnyRef + AsAnyMut + TypeName + Send {
fn new_collector(&self) -> Box<dyn CollectorDyn>;
}
impl TypeName for Box<dyn BinningggContainerBinsDyn> {
fn type_name(&self) -> String {
BinningggContainerBinsDyn::type_name(self.as_ref()).into()
}
}
impl WithLen for Box<dyn BinningggContainerBinsDyn> {
fn len(&self) -> usize {
WithLen::len(self.as_ref())
}
}
impl CollectableDyn for Box<dyn BinningggContainerBinsDyn> {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
self.as_ref().new_collector()
}
}
impl TypeName for Box<dyn Events> {
@@ -163,38 +219,38 @@ impl TypeName for Box<dyn Events> {
}
}
impl Collectable for Box<dyn Events> {
fn new_collector(&self) -> Box<dyn Collector> {
impl CollectableDyn for Box<dyn Events> {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
self.as_ref().new_collector()
}
}
impl<T> Collectable for T
impl<T> CollectableDyn for T
where
T: CollectableType + 'static,
{
fn new_collector(&self) -> Box<dyn Collector> {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
Box::new(T::new_collector())
}
}
impl TypeName for Box<dyn Collectable> {
impl TypeName for Box<dyn CollectableDyn> {
fn type_name(&self) -> String {
self.as_ref().type_name()
}
}
// TODO do this with some blanket impl:
impl WithLen for Box<dyn Collectable> {
impl WithLen for Box<dyn CollectableDyn> {
fn len(&self) -> usize {
WithLen::len(self.as_ref())
}
}
// TODO do this with some blanket impl:
impl Collectable for Box<dyn Collectable> {
fn new_collector(&self) -> Box<dyn Collector> {
Collectable::new_collector(self.as_ref())
impl CollectableDyn for Box<dyn CollectableDyn> {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
CollectableDyn::new_collector(self.as_ref())
}
}
@@ -210,8 +266,8 @@ impl TypeName for Box<dyn TimeBinned> {
}
}
impl Collectable for Box<dyn TimeBinned> {
fn new_collector(&self) -> Box<dyn Collector> {
impl CollectableDyn for Box<dyn TimeBinned> {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
self.as_ref().new_collector()
}
}

16
crates/items_0/src/items_0.rs
View File

@@ -17,7 +17,7 @@ pub mod bincode {
pub use futures_util;
use collect_s::Collectable;
use collect_s::CollectableDyn;
use container::ByteEstimate;
use std::any::Any;
use std::collections::VecDeque;
@@ -122,7 +122,7 @@ pub trait Events:
fmt::Debug
+ TypeName
+ Any
+ Collectable
+ CollectableDyn
+ TimeBinnable
+ WithLen
+ ByteEstimate
@@ -134,9 +134,9 @@ pub trait Events:
fn as_time_binnable_mut(&mut self) -> &mut dyn TimeBinnable;
fn verify(&self) -> bool;
fn output_info(&self) -> String;
fn as_collectable_mut(&mut self) -> &mut dyn Collectable;
fn as_collectable_with_default_ref(&self) -> &dyn Collectable;
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable;
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn;
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn;
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn;
fn ts_min(&self) -> Option<u64>;
fn ts_max(&self) -> Option<u64>;
// TODO is this used?
@@ -204,15 +204,15 @@ impl Events for Box<dyn Events> {
Events::output_info(self.as_ref())
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
Events::as_collectable_mut(self.as_mut())
}
fn as_collectable_with_default_ref(&self) -> &dyn Collectable {
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn {
Events::as_collectable_with_default_ref(self.as_ref())
}
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn {
Events::as_collectable_with_default_mut(self.as_mut())
}

17
crates/items_0/src/timebin.rs
View File

@@ -1,8 +1,9 @@
pub mod timebinimpl;
use crate::collect_s::Collectable;
use crate::collect_s::Collector;
use crate::collect_s::CollectableDyn;
use crate::collect_s::CollectorDyn;
use crate::collect_s::ToJsonResult;
use crate::container::ByteEstimate;
use crate::overlap::RangeOverlapInfo;
use crate::vecpreview::PreviewRange;
use crate::AsAnyMut;
@@ -103,7 +104,7 @@ pub trait BinningggContainerEventsDyn: fmt::Debug + Send {
fn to_anybox(&mut self) -> Box<dyn std::any::Any>;
}
pub trait BinningggContainerBinsDyn: fmt::Debug + Send + fmt::Display + WithLen + AsAnyMut + Collectable {
pub trait BinningggContainerBinsDyn: fmt::Debug + Send + fmt::Display + WithLen + AsAnyMut + CollectableDyn {
fn type_name(&self) -> &'static str;
fn empty(&self) -> BinsBoxed;
fn clone(&self) -> BinsBoxed;
@@ -147,11 +148,11 @@ pub trait BinnedEventsTimeweightTrait: fmt::Debug + Send {
}
/// Data in time-binned form.
pub trait TimeBinned: Any + TypeName + TimeBinnable + Resettable + Collectable + erased_serde::Serialize {
pub trait TimeBinned: Any + TypeName + TimeBinnable + Resettable + CollectableDyn + erased_serde::Serialize {
fn clone_box_time_binned(&self) -> Box<dyn TimeBinned>;
fn as_time_binnable_ref(&self) -> &dyn TimeBinnable;
fn as_time_binnable_mut(&mut self) -> &mut dyn TimeBinnable;
fn as_collectable_mut(&mut self) -> &mut dyn Collectable;
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn;
fn edges_slice(&self) -> (&[u64], &[u64]);
fn counts(&self) -> &[u64];
fn mins(&self) -> Vec<f32>;
@@ -230,7 +231,7 @@ pub trait TimeBinner: fmt::Debug + Send {
/// Provides a time-binned representation of the implementing type.
/// In contrast to `TimeBinnableType` this is meant for trait objects.
pub trait TimeBinnable:
fmt::Debug + WithLen + RangeOverlapInfo + Collectable + Any + AsAnyRef + AsAnyMut + Send
fmt::Debug + WithLen + RangeOverlapInfo + CollectableDyn + Any + AsAnyRef + AsAnyMut + Send
{
// TODO implementors may fail if edges contain not at least 2 entries.
fn time_binner_new(
@@ -324,8 +325,8 @@ impl TypeName for Box<dyn TimeBinnable> {
}
}
impl Collectable for Box<dyn TimeBinnable> {
fn new_collector(&self) -> Box<dyn Collector> {
impl CollectableDyn for Box<dyn TimeBinnable> {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
self.as_ref().new_collector()
}
}

10
crates/items_0/src/transform.rs
View File

@@ -1,5 +1,5 @@
use crate::collect_s::Collectable;
use crate::collect_s::Collected;
use crate::collect_s::CollectableDyn;
use crate::collect_s::CollectedDyn;
use crate::streamitem::RangeCompletableItem;
use crate::streamitem::Sitemty;
use crate::streamitem::StreamItem;
@@ -22,7 +22,7 @@ pub trait TimeBinnableStreamTrait:
}
pub trait CollectableStreamTrait:
Stream<Item = Sitemty<Box<dyn Collectable>>> + WithTransformProperties + Send
Stream<Item = Sitemty<Box<dyn CollectableDyn>>> + WithTransformProperties + Send
{
}
@@ -158,7 +158,7 @@ impl TimeBinnableStreamTrait for TimeBinnableStreamBox {}
pub struct CollectableStreamBox(pub Pin<Box<dyn CollectableStreamTrait>>);
impl Stream for CollectableStreamBox {
type Item = Sitemty<Box<dyn Collectable>>;
type Item = Sitemty<Box<dyn CollectableDyn>>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
self.0.poll_next_unpin(cx)
@@ -182,7 +182,7 @@ impl<T> WithTransformProperties for stream::Empty<T> {
impl<T> CollectableStreamTrait for stream::Empty<T>
where
T: Send,
stream::Empty<T>: Stream<Item = Sitemty<Box<dyn Collectable>>>,
stream::Empty<T>: Stream<Item = Sitemty<Box<dyn CollectableDyn>>>,
{
}

10
crates/items_2/src/binnedcollected.rs
View File

@@ -5,8 +5,8 @@ use crate::Error;
use futures_util::Future;
use futures_util::Stream;
use futures_util::StreamExt;
use items_0::collect_s::Collected;
use items_0::collect_s::Collector;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorDyn;
use items_0::collect_s::ToJsonResult;
use items_0::streamitem::RangeCompletableItem;
use items_0::streamitem::Sitemty;
@@ -27,7 +27,7 @@ use std::time::Instant;
fn flush_binned(
binner: &mut Box<dyn TimeBinner>,
coll: &mut Option<Box<dyn Collector>>,
coll: &mut Option<Box<dyn CollectorDyn>>,
force: bool,
) -> Result<(), Error> {
trace!("flush_binned bins_ready_count: {}", binner.bins_ready_count());
@@ -62,7 +62,7 @@ fn flush_binned(
pub struct BinnedCollectedResult {
pub range_final: bool,
pub did_timeout: bool,
pub result: Box<dyn Collected>,
pub result: Box<dyn CollectedDyn>,
}
fn _old_binned_collected(
@@ -102,7 +102,7 @@ pub struct BinnedCollected {
emit_empty_bins: bool,
did_timeout: bool,
range_final: bool,
coll: Option<Box<dyn Collector>>,
coll: Option<Box<dyn CollectorDyn>>,
binner: Option<Box<dyn TimeBinner>>,
inp: Pin<Box<dyn ChannelEventsInput>>,
}

167
crates/items_2/src/binning/container_bins.rs
View File

@@ -2,10 +2,14 @@ use super::aggregator::AggregatorNumeric;
use super::aggregator::AggregatorTimeWeight;
use super::container_events::EventValueType;
use super::___;
use crate::ts_offs_from_abs;
use crate::ts_offs_from_abs_with_anchor;
use core::fmt;
use err::thiserror;
use err::ThisError;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::ToJsonResult;
use items_0::timebin::BinningggContainerBinsDyn;
use items_0::timebin::BinsBoxed;
use items_0::vecpreview::VecPreview;
@@ -13,12 +17,14 @@ use items_0::AsAnyMut;
use items_0::AsAnyRef;
use items_0::TypeName;
use items_0::WithLen;
use netpod::log::*;
use netpod::EnumVariant;
use netpod::TsNano;
use serde::Deserialize;
use serde::Serialize;
use std::any;
use std::collections::VecDeque;
use std::mem;
#[allow(unused)]
macro_rules! trace_init { ($($arg:tt)*) => ( if true { trace!($($arg)*); }) }
@@ -361,12 +367,126 @@ where
}
}
#[derive(Debug)]
pub struct ContainerBinsCollectorOutput<EVT>
where
EVT: EventValueType,
{
bins: ContainerBins<EVT>,
}
impl<EVT> TypeName for ContainerBinsCollectorOutput<EVT>
where
EVT: EventValueType,
{
fn type_name(&self) -> String {
any::type_name::<Self>().into()
}
}
impl<EVT> AsAnyRef for ContainerBinsCollectorOutput<EVT>
where
EVT: EventValueType,
{
fn as_any_ref(&self) -> &dyn any::Any {
self
}
}
impl<EVT> AsAnyMut for ContainerBinsCollectorOutput<EVT>
where
EVT: EventValueType,
{
fn as_any_mut(&mut self) -> &mut dyn any::Any {
self
}
}
impl<EVT> WithLen for ContainerBinsCollectorOutput<EVT>
where
EVT: EventValueType,
{
fn len(&self) -> usize {
self.bins.len()
}
}
#[derive(Debug, Serialize)]
struct ContainerBinsCollectorOutputUser<EVT>
where
EVT: EventValueType,
{
#[serde(rename = "tsAnchor")]
ts_anchor_sec: u64,
#[serde(rename = "ts1Ms")]
ts1_off_ms: VecDeque<u64>,
#[serde(rename = "ts2Ms")]
ts2_off_ms: VecDeque<u64>,
#[serde(rename = "ts1Ns")]
ts1_off_ns: VecDeque<u64>,
#[serde(rename = "ts2Ns")]
ts2_off_ns: VecDeque<u64>,
#[serde(rename = "counts")]
counts: VecDeque<u64>,
#[serde(rename = "mins")]
mins: VecDeque<EVT>,
#[serde(rename = "maxs")]
maxs: VecDeque<EVT>,
#[serde(rename = "avgs")]
avgs: VecDeque<EVT::AggTimeWeightOutputAvg>,
// #[serde(rename = "rangeFinal", default, skip_serializing_if = "is_false")]
// range_final: bool,
// #[serde(rename = "timedOut", default, skip_serializing_if = "is_false")]
// timed_out: bool,
// #[serde(rename = "missingBins", default, skip_serializing_if = "CmpZero::is_zero")]
// missing_bins: u32,
// #[serde(rename = "continueAt", default, skip_serializing_if = "Option::is_none")]
// continue_at: Option<IsoDateTime>,
// #[serde(rename = "finishedAt", default, skip_serializing_if = "Option::is_none")]
// finished_at: Option<IsoDateTime>,
}
impl<EVT> ToJsonResult for ContainerBinsCollectorOutput<EVT>
where
EVT: EventValueType,
{
fn to_json_value(&self) -> Result<serde_json::Value, err::Error> {
let bins = &self.bins;
let ts1sns: Vec<_> = bins.ts1s.iter().map(|x| x.ns()).collect();
let ts2sns: Vec<_> = bins.ts2s.iter().map(|x| x.ns()).collect();
let (ts_anch, ts1ms, ts1ns) = ts_offs_from_abs(&ts1sns);
let (ts2ms, ts2ns) = ts_offs_from_abs_with_anchor(ts_anch, &ts2sns);
let counts = bins.cnts.clone();
let mins = bins.mins.clone();
let maxs = bins.maxs.clone();
let avgs = bins.avgs.clone();
let val = ContainerBinsCollectorOutputUser::<EVT> {
ts_anchor_sec: ts_anch,
ts1_off_ms: ts1ms,
ts2_off_ms: ts2ms,
ts1_off_ns: ts1ns,
ts2_off_ns: ts2ns,
counts,
mins,
maxs,
avgs,
};
let ret = serde_json::to_value(&val).map_err(err::Error::from_string);
info!("VALUE: {:?}", ret);
ret
}
}
impl<EVT> CollectedDyn for ContainerBinsCollectorOutput<EVT> where EVT: EventValueType {}
#[derive(Debug)]
pub struct ContainerBinsCollector<EVT>
where
EVT: EventValueType,
{
bins: ContainerBins<EVT>,
timed_out: bool,
range_final: bool,
}
impl<EVT> ContainerBinsCollector<EVT> where EVT: EventValueType {}
@@ -390,41 +510,57 @@ where
}
}
impl<EVT> items_0::collect_s::Collector for ContainerBinsCollector<EVT>
impl<EVT> items_0::collect_s::CollectorDyn for ContainerBinsCollector<EVT>
where
EVT: EventValueType,
{
fn ingest(&mut self, src: &mut dyn Collectable) {
todo!()
fn ingest(&mut self, src: &mut dyn CollectableDyn) {
if let Some(src) = src.as_any_mut().downcast_mut::<ContainerBins<EVT>>() {
src.drain_into(&mut self.bins, 0..src.len());
} else {
let srcn = src.type_name();
panic!("wrong src type {srcn}");
}
}
fn set_range_complete(&mut self) {
todo!()
self.range_final = true;
}
fn set_timed_out(&mut self) {
todo!()
self.timed_out = true;
}
fn set_continue_at_here(&mut self) {
todo!()
debug!("TODO remember the continue at");
}
fn result(
&mut self,
range: Option<netpod::range::evrange::SeriesRange>,
binrange: Option<netpod::BinnedRangeEnum>,
) -> Result<Box<dyn items_0::collect_s::Collected>, err::Error> {
todo!()
) -> Result<Box<dyn items_0::collect_s::CollectedDyn>, err::Error> {
info!(
"----------- ContainerBinsCollector result called len {}",
self.len()
);
let bins = mem::replace(&mut self.bins, ContainerBins::new());
let ret = ContainerBinsCollectorOutput { bins };
Ok(Box::new(ret))
}
}
impl<EVT> Collectable for ContainerBins<EVT>
impl<EVT> CollectableDyn for ContainerBins<EVT>
where
EVT: EventValueType,
{
fn new_collector(&self) -> Box<dyn items_0::collect_s::Collector> {
todo!()
fn new_collector(&self) -> Box<dyn items_0::collect_s::CollectorDyn> {
let ret = ContainerBinsCollector::<EVT> {
bins: ContainerBins::new(),
timed_out: false,
range_final: false,
};
Box::new(ret)
}
}
@@ -469,6 +605,13 @@ where
let obj = dst.as_any_mut();
if let Some(dst) = obj.downcast_mut::<Self>() {
dst.ts1s.extend(self.ts1s.drain(range.clone()));
dst.ts2s.extend(self.ts2s.drain(range.clone()));
dst.cnts.extend(self.cnts.drain(range.clone()));
dst.mins.extend(self.mins.drain(range.clone()));
dst.maxs.extend(self.maxs.drain(range.clone()));
dst.avgs.extend(self.avgs.drain(range.clone()));
dst.lsts.extend(self.lsts.drain(range.clone()));
dst.fnls.extend(self.fnls.drain(range.clone()));
} else {
let styn = any::type_name::<EVT>();
panic!("unexpected drain EVT {} dst {}", styn, Self::type_name());

2
crates/items_2/src/binning/container_events.rs
View File

@@ -31,7 +31,7 @@ pub trait Container<EVT>: fmt::Debug + Send + Clone + PreviewRange + Serialize +
fn pop_front(&mut self) -> Option<EVT>;
}
pub trait EventValueType: fmt::Debug + Clone + PartialOrd + Send + 'static {
pub trait EventValueType: fmt::Debug + Clone + PartialOrd + Send + 'static + Serialize {
type Container: Container<Self>;
type AggregatorTimeWeight: AggregatorTimeWeight<Self>;
type AggTimeWeightOutputAvg: AggTimeWeightOutputAvg;

19
crates/items_2/src/binsdim0.rs
View File

@@ -9,10 +9,10 @@ use crate::TimeBinnableTypeAggregator;
use chrono::TimeZone;
use chrono::Utc;
use err::Error;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectableType;
use items_0::collect_s::Collected;
use items_0::collect_s::CollectorType;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorTy;
use items_0::collect_s::ToJsonResult;
use items_0::container::ByteEstimate;
use items_0::overlap::HasTimestampDeque;
@@ -632,7 +632,7 @@ impl<STY> BinsDim0CollectedResult<STY>
where
STY: ScalarOps,
{
pub fn boxed_collected_with_enum_fix(&self) -> Box<dyn Collected> {
pub fn boxed_collected_with_enum_fix(&self) -> Box<dyn CollectedDyn> {
if let Some(bins) = self
.as_any_ref()
.downcast_ref::<BinsDim0CollectedResult<netpod::EnumVariant>>()
@@ -709,7 +709,7 @@ impl<NTY: ScalarOps> WithLen for BinsDim0CollectedResult<NTY> {
}
}
impl<NTY: ScalarOps> Collected for BinsDim0CollectedResult<NTY> {}
impl<NTY: ScalarOps> CollectedDyn for BinsDim0CollectedResult<NTY> {}
impl<NTY> BinsDim0CollectedResult<NTY> {
pub fn ts_anchor_sec(&self) -> u64 {
@@ -758,9 +758,8 @@ impl<NTY> BinsDim0CollectedResult<NTY> {
}
impl<NTY: ScalarOps> ToJsonResult for BinsDim0CollectedResult<NTY> {
fn to_json_result(&self) -> Result<Box<dyn items_0::collect_s::ToJsonBytes>, Error> {
let k = serde_json::to_value(self)?;
Ok(Box::new(k))
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
serde_json::to_value(self).map_err(Error::from_string)
}
}
@@ -797,7 +796,7 @@ impl<STY: ScalarOps> ByteEstimate for BinsDim0Collector<STY> {
}
}
impl<NTY: ScalarOps> CollectorType for BinsDim0Collector<NTY> {
impl<NTY: ScalarOps> CollectorTy for BinsDim0Collector<NTY> {
type Input = BinsDim0<NTY>;
type Output = BinsDim0CollectedResult<NTY>;
@@ -1425,7 +1424,7 @@ impl<NTY: ScalarOps> TimeBinned for BinsDim0<NTY> {
}
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
self
}

17
crates/items_2/src/binsxbindim0.rs
View File

@@ -6,10 +6,10 @@ use crate::TimeBinnableType;
use crate::TimeBinnableTypeAggregator;
use chrono::{TimeZone, Utc};
use err::Error;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectableType;
use items_0::collect_s::Collected;
use items_0::collect_s::CollectorType;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorTy;
use items_0::collect_s::ToJsonResult;
use items_0::container::ByteEstimate;
use items_0::scalar_ops::AsPrimF32;
@@ -356,7 +356,7 @@ impl<NTY: ScalarOps> WithLen for BinsXbinDim0CollectedResult<NTY> {
}
}
impl<NTY: ScalarOps> Collected for BinsXbinDim0CollectedResult<NTY> {}
impl<NTY: ScalarOps> CollectedDyn for BinsXbinDim0CollectedResult<NTY> {}
impl<NTY> BinsXbinDim0CollectedResult<NTY> {
pub fn ts_anchor_sec(&self) -> u64 {
@@ -397,9 +397,8 @@ impl<NTY> BinsXbinDim0CollectedResult<NTY> {
}
impl<NTY: ScalarOps> ToJsonResult for BinsXbinDim0CollectedResult<NTY> {
fn to_json_result(&self) -> Result<Box<dyn items_0::collect_s::ToJsonBytes>, Error> {
let k = serde_json::to_value(self)?;
Ok(Box::new(k))
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
serde_json::to_value(self).map_err(Error::from_string)
}
}
@@ -436,7 +435,7 @@ impl<STY: ScalarOps> ByteEstimate for BinsXbinDim0Collector<STY> {
}
}
impl<NTY: ScalarOps> CollectorType for BinsXbinDim0Collector<NTY> {
impl<NTY: ScalarOps> CollectorTy for BinsXbinDim0Collector<NTY> {
type Input = BinsXbinDim0<NTY>;
type Output = BinsXbinDim0CollectedResult<NTY>;
@@ -877,7 +876,7 @@ impl<NTY: ScalarOps> TimeBinned for BinsXbinDim0<NTY> {
}
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
self
}

30
crates/items_2/src/channelevents.rs
View File

@@ -1,9 +1,9 @@
use crate::framable::FrameType;
use crate::merger::Mergeable;
use crate::Events;
use items_0::collect_s::Collectable;
use items_0::collect_s::Collected;
use items_0::collect_s::Collector;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorDyn;
use items_0::container::ByteEstimate;
use items_0::framable::FrameTypeInnerStatic;
use items_0::isodate::IsoDateTime;
@@ -884,15 +884,15 @@ impl Events for ChannelEvents {
todo!()
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
todo!()
}
fn as_collectable_with_default_ref(&self) -> &dyn Collectable {
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn {
todo!()
}
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn {
todo!()
}
@@ -1033,8 +1033,8 @@ impl Events for ChannelEvents {
}
}
impl Collectable for ChannelEvents {
fn new_collector(&self) -> Box<dyn Collector> {
impl CollectableDyn for ChannelEvents {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
Box::new(ChannelEventsCollector::new())
}
}
@@ -1237,16 +1237,16 @@ impl WithLen for ChannelEventsCollectorOutput {
}
impl items_0::collect_s::ToJsonResult for ChannelEventsCollectorOutput {
fn to_json_result(&self) -> Result<Box<dyn items_0::collect_s::ToJsonBytes>, err::Error> {
todo!()
fn to_json_value(&self) -> Result<serde_json::Value, ::err::Error> {
serde_json::to_value(self).map_err(::err::Error::from_string)
}
}
impl Collected for ChannelEventsCollectorOutput {}
impl CollectedDyn for ChannelEventsCollectorOutput {}
#[derive(Debug)]
pub struct ChannelEventsCollector {
coll: Option<Box<dyn Collector>>,
coll: Option<Box<dyn CollectorDyn>>,
range_complete: bool,
timed_out: bool,
needs_continue_at: bool,
@@ -1283,8 +1283,8 @@ impl ByteEstimate for ChannelEventsCollector {
}
}
impl Collector for ChannelEventsCollector {
fn ingest(&mut self, item: &mut dyn Collectable) {
impl CollectorDyn for ChannelEventsCollector {
fn ingest(&mut self, item: &mut dyn CollectableDyn) {
if let Some(item) = item.as_any_mut().downcast_mut::<ChannelEvents>() {
match item {
ChannelEvents::Events(item) => {
@@ -1325,7 +1325,7 @@ impl Collector for ChannelEventsCollector {
&mut self,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
) -> Result<Box<dyn Collected>, err::Error> {
) -> Result<Box<dyn CollectedDyn>, err::Error> {
match self.coll.as_mut() {
Some(coll) => {
if self.needs_continue_at {

23
crates/items_2/src/eventsdim0.rs
View File

@@ -12,10 +12,10 @@ use crate::RangeOverlapInfo;
use crate::TimeBinnableType;
use crate::TimeBinnableTypeAggregator;
use err::Error;
use items_0::collect_s::Collectable;
use items_0::collect_s::Collected;
use items_0::collect_s::Collector;
use items_0::collect_s::CollectorType;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorDyn;
use items_0::collect_s::CollectorTy;
use items_0::collect_s::ToJsonBytes;
use items_0::collect_s::ToJsonResult;
use items_0::container::ByteEstimate;
@@ -425,15 +425,14 @@ impl<STY: ScalarOps> WithLen for EventsDim0CollectorOutput<STY> {
}
impl<STY: ScalarOps> ToJsonResult for EventsDim0CollectorOutput<STY> {
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error> {
let k = serde_json::to_value(self)?;
Ok(Box::new(k))
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
serde_json::to_value(self).map_err(Error::from_string)
}
}
impl<STY: ScalarOps> Collected for EventsDim0CollectorOutput<STY> {}
impl<STY: ScalarOps> CollectedDyn for EventsDim0CollectorOutput<STY> {}
impl<STY: ScalarOps> CollectorType for EventsDim0Collector<STY> {
impl<STY: ScalarOps> CollectorTy for EventsDim0Collector<STY> {
type Input = EventsDim0<STY>;
type Output = EventsDim0CollectorOutput<STY>;
@@ -941,15 +940,15 @@ impl<STY: ScalarOps> Events for EventsDim0<STY> {
)
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
self
}
fn as_collectable_with_default_ref(&self) -> &dyn Collectable {
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn {
self
}
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn {
self
}

24
crates/items_2/src/eventsdim0enum.rs
View File

@@ -1,8 +1,8 @@
use err::Error;
use items_0::collect_s::Collectable;
use items_0::collect_s::Collected;
use items_0::collect_s::Collector;
use items_0::collect_s::CollectorType;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorDyn;
use items_0::collect_s::CollectorTy;
use items_0::collect_s::ToJsonBytes;
use items_0::collect_s::ToJsonResult;
use items_0::container::ByteEstimate;
@@ -122,14 +122,14 @@ impl TypeName for EventsDim0EnumCollectorOutput {
}
impl ToJsonResult for EventsDim0EnumCollectorOutput {
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error> {
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
todo!()
}
}
impl Collected for EventsDim0EnumCollectorOutput {}
impl CollectedDyn for EventsDim0EnumCollectorOutput {}
impl CollectorType for EventsDim0EnumCollector {
impl CollectorTy for EventsDim0EnumCollector {
type Input = EventsDim0Enum;
type Output = EventsDim0EnumCollectorOutput;
@@ -264,8 +264,8 @@ impl WithLen for EventsDim0Enum {
}
}
impl Collectable for EventsDim0Enum {
fn new_collector(&self) -> Box<dyn Collector> {
impl CollectableDyn for EventsDim0Enum {
fn new_collector(&self) -> Box<dyn CollectorDyn> {
Box::new(EventsDim0EnumCollector::new())
}
}
@@ -398,15 +398,15 @@ impl Events for EventsDim0Enum {
todo!()
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
todo!()
}
fn as_collectable_with_default_ref(&self) -> &dyn Collectable {
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn {
todo!()
}
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn {
todo!()
}

21
crates/items_2/src/eventsdim1.rs
View File

@@ -7,10 +7,10 @@ use crate::RangeOverlapInfo;
use crate::TimeBinnableType;
use crate::TimeBinnableTypeAggregator;
use err::Error;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectableType;
use items_0::collect_s::Collected;
use items_0::collect_s::CollectorType;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorTy;
use items_0::collect_s::ToJsonBytes;
use items_0::collect_s::ToJsonResult;
use items_0::container::ByteEstimate;
@@ -362,15 +362,14 @@ impl<STY: ScalarOps> WithLen for EventsDim1CollectorOutput<STY> {
}
impl<STY: ScalarOps> ToJsonResult for EventsDim1CollectorOutput<STY> {
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error> {
let k = serde_json::to_value(self)?;
Ok(Box::new(k))
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
serde_json::to_value(self).map_err(Error::from_string)
}
}
impl<STY: ScalarOps> Collected for EventsDim1CollectorOutput<STY> {}
impl<STY: ScalarOps> CollectedDyn for EventsDim1CollectorOutput<STY> {}
impl<STY: ScalarOps> CollectorType for EventsDim1Collector<STY> {
impl<STY: ScalarOps> CollectorTy for EventsDim1Collector<STY> {
type Input = EventsDim1<STY>;
type Output = EventsDim1CollectorOutput<STY>;
@@ -821,15 +820,15 @@ impl<STY: ScalarOps> Events for EventsDim1<STY> {
)
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
self
}
fn as_collectable_with_default_ref(&self) -> &dyn Collectable {
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn {
self
}
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn {
self
}

21
crates/items_2/src/eventsxbindim0.rs
View File

@@ -4,10 +4,10 @@ use crate::RangeOverlapInfo;
use crate::TimeBinnableType;
use crate::TimeBinnableTypeAggregator;
use err::Error;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectableType;
use items_0::collect_s::Collected;
use items_0::collect_s::CollectorType;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorTy;
use items_0::collect_s::ToJsonBytes;
use items_0::collect_s::ToJsonResult;
use items_0::container::ByteEstimate;
@@ -227,15 +227,15 @@ impl<STY: ScalarOps> Events for EventsXbinDim0<STY> {
)
}
fn as_collectable_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_mut(&mut self) -> &mut dyn CollectableDyn {
self
}
fn as_collectable_with_default_ref(&self) -> &dyn Collectable {
fn as_collectable_with_default_ref(&self) -> &dyn CollectableDyn {
self
}
fn as_collectable_with_default_mut(&mut self) -> &mut dyn Collectable {
fn as_collectable_with_default_mut(&mut self) -> &mut dyn CollectableDyn {
self
}
@@ -953,13 +953,12 @@ impl<NTY> ToJsonResult for EventsXbinDim0CollectorOutput<NTY>
where
NTY: ScalarOps,
{
fn to_json_result(&self) -> Result<Box<dyn ToJsonBytes>, Error> {
let k = serde_json::to_value(self)?;
Ok(Box::new(k))
fn to_json_value(&self) -> Result<serde_json::Value, Error> {
serde_json::to_value(self).map_err(Error::from_string)
}
}
impl<NTY> Collected for EventsXbinDim0CollectorOutput<NTY> where NTY: ScalarOps {}
impl<NTY> CollectedDyn for EventsXbinDim0CollectorOutput<NTY> where NTY: ScalarOps {}
#[derive(Debug)]
pub struct EventsXbinDim0Collector<NTY> {
@@ -996,7 +995,7 @@ impl<STY> ByteEstimate for EventsXbinDim0Collector<STY> {
}
}
impl<NTY> CollectorType for EventsXbinDim0Collector<NTY>
impl<NTY> CollectorTy for EventsXbinDim0Collector<NTY>
where
NTY: ScalarOps,
{

2
crates/items_2/src/streams.rs
View File

@@ -2,7 +2,7 @@ use futures_util::Future;
use futures_util::FutureExt;
use futures_util::Stream;
use futures_util::StreamExt;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::streamitem::RangeCompletableItem;
use items_0::streamitem::Sitemty;
use items_0::streamitem::StreamItem;

26
crates/streams/src/collect.rs
View File

@@ -3,9 +3,9 @@ use futures_util::Future;
use futures_util::FutureExt;
use futures_util::Stream;
use futures_util::StreamExt;
use items_0::collect_s::Collectable;
use items_0::collect_s::Collected;
use items_0::collect_s::Collector;
use items_0::collect_s::CollectableDyn;
use items_0::collect_s::CollectedDyn;
use items_0::collect_s::CollectorDyn;
use items_0::streamitem::RangeCompletableItem;
use items_0::streamitem::Sitemty;
use items_0::streamitem::StatsItem;
@@ -47,12 +47,12 @@ pub enum CollectResult<T> {
}
pub struct Collect {
inp: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn Collectable>>> + Send>>,
inp: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn CollectableDyn>>> + Send>>,
events_max: u64,
bytes_max: u64,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
collector: Option<Box<dyn Collector>>,
collector: Option<Box<dyn CollectorDyn>>,
range_final: bool,
timeout: bool,
timer: Pin<Box<dyn Future<Output = ()> + Send>>,
@@ -61,7 +61,7 @@ pub struct Collect {
impl Collect {
pub fn new(
inp: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn Collectable>>> + Send>>,
inp: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn CollectableDyn>>> + Send>>,
deadline: Instant,
events_max: u64,
bytes_max: u64,
@@ -83,7 +83,7 @@ impl Collect {
}
}
fn handle_item(&mut self, item: Sitemty<Box<dyn Collectable>>) -> Result<(), Error> {
fn handle_item(&mut self, item: Sitemty<Box<dyn CollectableDyn>>) -> Result<(), Error> {
match item {
Ok(item) => match item {
StreamItem::DataItem(item) => match item {
@@ -161,7 +161,7 @@ impl Collect {
}
impl Future for Collect {
type Output = Result<CollectResult<Box<dyn Collected>>, Error>;
type Output = Result<CollectResult<Box<dyn CollectedDyn>>, Error>;
fn poll(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Self::Output> {
use Poll::*;
@@ -226,13 +226,13 @@ async fn collect_in_span<T, S>(
events_max: u64,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
) -> Result<Box<dyn Collected>, Error>
) -> Result<Box<dyn CollectedDyn>, Error>
where
S: Stream<Item = Sitemty<T>> + Unpin,
T: Collectable,
T: CollectableDyn,
{
info!("collect events_max {events_max} deadline {deadline:?}");
let mut collector: Option<Box<dyn Collector>> = None;
let mut collector: Option<Box<dyn CollectorDyn>> = None;
let mut stream = stream;
let deadline = deadline.into();
let mut range_complete = false;
@@ -329,10 +329,10 @@ pub async fn collect<T, S>(
events_max: u64,
range: Option<SeriesRange>,
binrange: Option<BinnedRangeEnum>,
) -> Result<Box<dyn Collected>, Error>
) -> Result<Box<dyn CollectedDyn>, Error>
where
S: Stream<Item = Sitemty<T>> + Unpin,
T: Collectable + WithLen + fmt::Debug,
T: CollectableDyn + WithLen + fmt::Debug,
{
let span = span!(Level::INFO, "collect");
collect_in_span(stream, deadline, events_max, range, binrange)

13
crates/streams/src/plaineventsjson.rs
View File

@@ -9,7 +9,7 @@ use crate::tcprawclient::OpenBoxedBytesStreamsBox;
use err::thiserror;
use err::ThisError;
use futures_util::StreamExt;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::on_sitemty_data;
use netpod::log::*;
use netpod::ChannelTypeConfigGen;
@@ -27,6 +27,7 @@ pub enum Error {
Stream(#[from] crate::plaineventsstream::Error),
Collect(err::Error),
Json(#[from] serde_json::Error),
Err(err::Error),
}
pub async fn plain_events_json(
@@ -56,23 +57,23 @@ pub async fn plain_events_json(
for (&ts, val) in g.tss.iter().zip(g.values.iter()) {
out.push_back(ts, val.ix(), val.name_string());
}
let k: Box<dyn Collectable> = Box::new(out);
let k: Box<dyn CollectableDyn> = Box::new(out);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
} else {
trace!("consider container channel events other events {}", k.type_name());
let k: Box<dyn Collectable> = Box::new(k);
let k: Box<dyn CollectableDyn> = Box::new(k);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
}
}
items_2::channelevents::ChannelEvents::Status(_) => {
trace!("consider container channel events status {}", k.type_name());
let k: Box<dyn Collectable> = Box::new(k);
let k: Box<dyn CollectableDyn> = Box::new(k);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
}
}
} else {
trace!("consider container else {}", k.type_name());
let k: Box<dyn Collectable> = Box::new(k);
let k: Box<dyn CollectableDyn> = Box::new(k);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(k)))
}
})
@@ -95,7 +96,7 @@ pub async fn plain_events_json(
.map_err(Error::Collect)?;
debug!("plain_events_json collected");
if let CollectResult::Some(x) = collected {
let jsval = serde_json::to_value(&x)?;
let jsval = x.to_json_value().map_err(|e| Error::Err(e))?;
debug!("plain_events_json json serialized");
Ok(CollectResult::Some(jsval))
} else {

4
crates/streams/src/test/timebin.rs
View File

@@ -220,7 +220,9 @@ fn time_bin_02() -> Result<(), Error> {
} else {
let res = collect(binned_stream, deadline, 200, None, Some(binned_range)).await?;
assert_eq!(res.len(), expected_bin_count);
let d = res.to_json_result()?.to_json_bytes()?;
// use crate::json_stream::JsonBytes;
let v = res.to_json_value()?;
let d = serde_json::to_vec(&v)?;
let s = String::from_utf8_lossy(&d);
eprintln!("{s}");
let jsval: JsValue = serde_json::from_slice(&d)?;

32
crates/streams/src/timebinnedjson.rs
View File

@@ -17,7 +17,7 @@ use futures_util::Future;
use futures_util::FutureExt;
use futures_util::Stream;
use futures_util::StreamExt;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::on_sitemty_data;
use items_0::streamitem::RangeCompletableItem;
use items_0::streamitem::Sitemty;
@@ -374,7 +374,7 @@ async fn timebinned_stream(
open_bytes: OpenBoxedBytesStreamsBox,
cache_read_provider: Arc<dyn CacheReadProvider>,
events_read_provider: Arc<dyn EventsReadProvider>,
) -> Result<Pin<Box<dyn Stream<Item = Sitemty<Box<dyn Collectable>>> + Send>>, Error> {
) -> Result<Pin<Box<dyn Stream<Item = Sitemty<Box<dyn CollectableDyn>>> + Send>>, Error> {
use netpod::query::CacheUsage;
let cache_usage = query.cache_usage().unwrap_or(CacheUsage::V0NoCache);
match cache_usage.clone() {
@@ -407,19 +407,21 @@ async fn timebinned_stream(
events_read_provider,
)
.map_err(Error::from_string)?;
// let stream = stream.map(|item| {
// on_sitemty_data!(item, |k: items_0::timebin::BinsBoxed| {
// let ret = k.to_old_time_binned();
// Ok(StreamItem::DataItem(RangeCompletableItem::Data(ret)))
// })
// });
let stream = stream.map(|item| {
on_sitemty_data!(item, |k: items_0::timebin::BinsBoxed| {
let ret = k.to_old_time_binned();
use items_0::timebin::BinningggContainerBinsDyn;
on_sitemty_data!(item, |x: Box<dyn BinningggContainerBinsDyn>| {
let g = x.new_collector();
let ret = Box::new(x) as Box<dyn CollectableDyn>;
// let ret = x as Box<dyn CollectableDyn>;
Ok(StreamItem::DataItem(RangeCompletableItem::Data(ret)))
})
});
let stream = stream.map(|item| {
on_sitemty_data!(item, |x| {
let ret = Box::new(x) as Box<dyn Collectable>;
Ok(StreamItem::DataItem(RangeCompletableItem::Data(ret)))
})
});
// let stream: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn TimeBinned>>> + Send>> = Box::pin(stream);
let stream = Box::pin(stream);
Ok(stream)
}
@@ -452,7 +454,7 @@ async fn timebinned_stream(
}
let stream = stream.map(|x| {
on_sitemty_data!(x, |x| {
let ret = Box::new(x) as Box<dyn Collectable>;
let ret = Box::new(x) as Box<dyn CollectableDyn>;
Ok(StreamItem::DataItem(RangeCompletableItem::Data(ret)))
})
});
@@ -508,14 +510,14 @@ pub async fn timebinned_json(
debug!("timebinned_json collected type_name {:?}", collres.type_name());
collres
};
let jsval = serde_json::to_value(&collres)?;
let jsval = collres.to_json_value()?;
Ok(CollectResult::Some(jsval))
}
CollectResult::Timeout => Ok(CollectResult::Timeout),
}
}
fn take_collector_result(coll: &mut Box<dyn items_0::collect_s::Collector>) -> Option<serde_json::Value> {
fn take_collector_result(coll: &mut Box<dyn items_0::collect_s::CollectorDyn>) -> Option<serde_json::Value> {
match coll.result(None, None) {
Ok(collres) => {
let collres = if let Some(bins) = collres
@@ -528,7 +530,7 @@ fn take_collector_result(coll: &mut Box<dyn items_0::collect_s::Collector>) -> O
} else {
collres
};
match serde_json::to_value(&collres) {
match collres.to_json_value() {
Ok(val) => Some(val),
Err(e) => Some(serde_json::Value::String(format!("{e}"))),
}

35
crates/streams/src/transform.rs
View File

@@ -1,7 +1,7 @@
use err::Error;
use futures_util::Stream;
use futures_util::StreamExt;
use items_0::collect_s::Collectable;
use items_0::collect_s::CollectableDyn;
use items_0::streamitem::RangeCompletableItem;
use items_0::streamitem::Sitemty;
use items_0::streamitem::StreamItem;
@@ -109,7 +109,7 @@ impl TimeBinnableToCollectable {
}
impl Stream for TimeBinnableToCollectable {
type Item = Sitemty<Box<dyn Collectable>>;
type Item = Sitemty<Box<dyn CollectableDyn>>;
fn poll_next(mut self: Pin<&mut Self>, cx: &mut Context) -> Poll<Option<Self::Item>> {
use Poll::*;
@@ -163,21 +163,24 @@ pub fn build_full_transform_collectable(
// TODO this must return a Stream!
//let evs = build_event_transform(tr, inp)?;
let trtb = tr.get_tr_time_binning();
let a: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn Collectable>>> + Send>> = Box::pin(inp.0.map(|item| match item {
Ok(item) => match item {
StreamItem::DataItem(item) => match item {
RangeCompletableItem::Data(item) => {
let item: Box<dyn Collectable> = Box::new(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
RangeCompletableItem::RangeComplete => Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete)),
let a: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn CollectableDyn>>> + Send>> =
Box::pin(inp.0.map(|item| match item {
Ok(item) => match item {
StreamItem::DataItem(item) => match item {
RangeCompletableItem::Data(item) => {
let item: Box<dyn CollectableDyn> = Box::new(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
RangeCompletableItem::RangeComplete => {
Ok(StreamItem::DataItem(RangeCompletableItem::RangeComplete))
}
},
StreamItem::Log(item) => Ok(StreamItem::Log(item)),
StreamItem::Stats(item) => Ok(StreamItem::Stats(item)),
},
StreamItem::Log(item) => Ok(StreamItem::Log(item)),
StreamItem::Stats(item) => Ok(StreamItem::Stats(item)),
},
Err(e) => Err(e),
}));
let stream: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn Collectable>>> + Send>> =
Err(e) => Err(e),
}));
let stream: Pin<Box<dyn Stream<Item = Sitemty<Box<dyn CollectableDyn>>> + Send>> =
Box::pin(futures_util::stream::empty());
let stream = Box::pin(futures_util::stream::empty()) as _;
match trtb {