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

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;