628 lines
17 KiB
Rust
628 lines
17 KiB
Rust
pub mod timebinimpl;
|
|
|
|
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;
|
|
use crate::AsAnyRef;
|
|
use crate::Empty;
|
|
use crate::Events;
|
|
use crate::Resettable;
|
|
use crate::TypeName;
|
|
use crate::WithLen;
|
|
use err::thiserror;
|
|
use err::Error;
|
|
use err::ThisError;
|
|
use netpod::log::*;
|
|
use netpod::range::evrange::SeriesRange;
|
|
use netpod::BinnedRange;
|
|
use netpod::BinnedRangeEnum;
|
|
use netpod::TsNano;
|
|
use serde::Deserialize;
|
|
use serde::Serialize;
|
|
use std::any::Any;
|
|
use std::fmt;
|
|
use std::ops::Range;
|
|
|
|
// TODO can probably be removed.
|
|
pub trait TimeBins {
|
|
fn ts_min(&self) -> Option<u64>;
|
|
fn ts_max(&self) -> Option<u64>;
|
|
fn ts_min_max(&self) -> Option<(u64, u64)>;
|
|
}
|
|
|
|
pub trait TimeBinnerTy: fmt::Debug + Send + Unpin {
|
|
type Input: fmt::Debug;
|
|
type Output: fmt::Debug;
|
|
|
|
fn ingest(&mut self, item: &mut Self::Input);
|
|
|
|
fn set_range_complete(&mut self);
|
|
|
|
fn bins_ready_count(&self) -> usize;
|
|
|
|
fn bins_ready(&mut self) -> Option<Self::Output>;
|
|
|
|
/// If there is a bin in progress with non-zero count, push it to the result set.
|
|
/// With push_empty == true, a bin in progress is pushed even if it contains no counts.
|
|
fn push_in_progress(&mut self, push_empty: bool);
|
|
|
|
/// Implies `Self::push_in_progress` but in addition, pushes a zero-count bin if the call
|
|
/// to `push_in_progress` did not change the result count, as long as edges are left.
|
|
/// The next call to `Self::bins_ready_count` must return one higher count than before.
|
|
fn cycle(&mut self);
|
|
|
|
fn empty(&self) -> Option<Self::Output>;
|
|
|
|
fn append_empty_until_end(&mut self);
|
|
}
|
|
|
|
pub trait TimeBinnableTy: fmt::Debug + WithLen + Send + Sized {
|
|
type TimeBinner: TimeBinnerTy<Input = Self>;
|
|
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Self::TimeBinner;
|
|
}
|
|
|
|
// #[derive(Debug, ThisError)]
|
|
// #[cstm(name = "Binninggg")]
|
|
pub enum BinningggError {
|
|
Dyn(Box<dyn std::error::Error>),
|
|
TypeMismatch { have: String, expect: String },
|
|
}
|
|
|
|
impl fmt::Display for BinningggError {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
match self {
|
|
BinningggError::Dyn(e) => write!(fmt, "{e}"),
|
|
BinningggError::TypeMismatch { have, expect } => {
|
|
write!(fmt, "TypeMismatch(have: {have}, expect: {expect})")
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<E> From<E> for BinningggError
|
|
where
|
|
E: std::error::Error + 'static,
|
|
{
|
|
fn from(value: E) -> Self {
|
|
Self::Dyn(Box::new(value))
|
|
}
|
|
}
|
|
|
|
pub trait BinningggContainerEventsDyn: fmt::Debug + Send {
|
|
fn type_name(&self) -> &'static str;
|
|
fn binned_events_timeweight_traitobj(&self, range: BinnedRange<TsNano>) -> Box<dyn BinnedEventsTimeweightTrait>;
|
|
fn to_anybox(&mut self) -> Box<dyn std::any::Any>;
|
|
}
|
|
|
|
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;
|
|
fn edges_iter(
|
|
&self,
|
|
) -> std::iter::Zip<std::collections::vec_deque::Iter<TsNano>, std::collections::vec_deque::Iter<TsNano>>;
|
|
fn drain_into(&mut self, dst: &mut dyn BinningggContainerBinsDyn, range: Range<usize>);
|
|
fn to_old_time_binned(&self) -> Box<dyn TimeBinned>;
|
|
}
|
|
|
|
pub type BinsBoxed = Box<dyn BinningggContainerBinsDyn>;
|
|
|
|
pub type EventsBoxed = Box<dyn BinningggContainerEventsDyn>;
|
|
|
|
pub trait BinningggBinnerTy: fmt::Debug + Send {
|
|
type Input: fmt::Debug;
|
|
type Output: fmt::Debug;
|
|
|
|
fn ingest(&mut self, item: &mut Self::Input);
|
|
fn range_final(&mut self);
|
|
fn bins_ready_count(&self) -> usize;
|
|
fn bins_ready(&mut self) -> Option<Self::Output>;
|
|
}
|
|
|
|
pub trait BinningggBinnableTy: fmt::Debug + WithLen + Send {
|
|
type Binner: BinningggBinnerTy<Input = Self>;
|
|
|
|
fn binner_new(range: BinnedRange<TsNano>) -> Self::Binner;
|
|
}
|
|
|
|
pub trait BinningggBinnerDyn: fmt::Debug + Send {
|
|
fn input_done_range_final(&mut self) -> Result<(), BinningggError>;
|
|
fn input_done_range_open(&mut self) -> Result<(), BinningggError>;
|
|
}
|
|
|
|
pub trait BinnedEventsTimeweightTrait: fmt::Debug + Send {
|
|
fn ingest(&mut self, evs_all: EventsBoxed) -> Result<(), BinningggError>;
|
|
fn input_done_range_final(&mut self) -> Result<(), BinningggError>;
|
|
fn input_done_range_open(&mut self) -> Result<(), BinningggError>;
|
|
fn output(&mut self) -> Result<Option<BinsBoxed>, BinningggError>;
|
|
}
|
|
|
|
/// Data in time-binned form.
|
|
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 CollectableDyn;
|
|
fn edges_slice(&self) -> (&[u64], &[u64]);
|
|
fn counts(&self) -> &[u64];
|
|
fn mins(&self) -> Vec<f32>;
|
|
fn maxs(&self) -> Vec<f32>;
|
|
fn avgs(&self) -> Vec<f32>;
|
|
fn validate(&self) -> Result<(), String>;
|
|
fn empty_like_self_box_time_binned(&self) -> Box<dyn TimeBinned>;
|
|
fn to_simple_bins_f32(&mut self) -> Box<dyn TimeBinned>;
|
|
fn drain_into_tb(&mut self, dst: &mut dyn TimeBinned, range: Range<usize>) -> Result<(), Error>;
|
|
}
|
|
|
|
impl Clone for Box<dyn TimeBinned> {
|
|
fn clone(&self) -> Self {
|
|
self.clone_box_time_binned()
|
|
}
|
|
}
|
|
|
|
impl RangeOverlapInfo for Box<dyn TimeBinned> {
|
|
fn ends_before(&self, range: &SeriesRange) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn ends_after(&self, range: &SeriesRange) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn starts_after(&self, range: &SeriesRange) -> bool {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl TimeBinnable for Box<dyn TimeBinned> {
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Box<dyn TimeBinner> {
|
|
self.as_ref().time_binner_new(binrange, do_time_weight, emit_empty_bins)
|
|
}
|
|
|
|
fn to_box_to_json_result(&self) -> Box<dyn ToJsonResult> {
|
|
self.as_ref().to_box_to_json_result()
|
|
}
|
|
|
|
fn to_container_bins(&self) -> Box<dyn BinningggContainerBinsDyn> {
|
|
self.as_ref().to_container_bins()
|
|
}
|
|
}
|
|
|
|
pub trait TimeBinner: fmt::Debug + Send {
|
|
fn ingest(&mut self, item: &mut dyn TimeBinnable);
|
|
|
|
fn bins_ready_count(&self) -> usize;
|
|
|
|
fn bins_ready(&mut self) -> Option<Box<dyn TimeBinned>>;
|
|
|
|
/// If there is a bin in progress with non-zero count, push it to the result set.
|
|
/// With push_empty == true, a bin in progress is pushed even if it contains no counts.
|
|
fn push_in_progress(&mut self, push_empty: bool);
|
|
|
|
/// Implies `Self::push_in_progress` but in addition, pushes a zero-count bin if the call
|
|
/// to `push_in_progress` did not change the result count, as long as edges are left.
|
|
/// The next call to `Self::bins_ready_count` must return one higher count than before.
|
|
fn cycle(&mut self);
|
|
|
|
fn set_range_complete(&mut self);
|
|
|
|
fn empty(&self) -> Box<dyn TimeBinned>;
|
|
|
|
fn append_empty_until_end(&mut self);
|
|
}
|
|
|
|
// TODO remove the Any bound. Factor out into custom AsAny trait.
|
|
|
|
/// 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 + CollectableDyn + Any + AsAnyRef + AsAnyMut + Send
|
|
{
|
|
// TODO implementors may fail if edges contain not at least 2 entries.
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Box<dyn TimeBinner>;
|
|
// TODO just a helper for the empty result.
|
|
fn to_box_to_json_result(&self) -> Box<dyn ToJsonResult>;
|
|
// TODO temporary converter
|
|
fn to_container_bins(&self) -> Box<dyn BinningggContainerBinsDyn>;
|
|
}
|
|
|
|
impl WithLen for Box<dyn TimeBinnable> {
|
|
fn len(&self) -> usize {
|
|
WithLen::len(self.as_ref())
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
impl RangeOverlapInfo for Box<dyn TimeBinnable> {
|
|
fn ends_before(&self, range: &SeriesRange) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn ends_after(&self, range: &SeriesRange) -> bool {
|
|
todo!()
|
|
}
|
|
|
|
fn starts_after(&self, range: &SeriesRange) -> bool {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl TimeBinnable for Box<dyn TimeBinnable> {
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Box<dyn TimeBinner> {
|
|
self.as_ref().time_binner_new(binrange, do_time_weight, emit_empty_bins)
|
|
}
|
|
|
|
fn to_box_to_json_result(&self) -> Box<dyn ToJsonResult> {
|
|
todo!()
|
|
}
|
|
|
|
fn to_container_bins(&self) -> Box<dyn BinningggContainerBinsDyn> {
|
|
self.as_ref().to_container_bins()
|
|
}
|
|
}
|
|
|
|
impl RangeOverlapInfo for Box<dyn Events> {
|
|
fn ends_before(&self, range: &SeriesRange) -> bool {
|
|
RangeOverlapInfo::ends_before(self.as_ref(), range)
|
|
}
|
|
|
|
fn ends_after(&self, range: &SeriesRange) -> bool {
|
|
RangeOverlapInfo::ends_after(self.as_ref(), range)
|
|
}
|
|
|
|
fn starts_after(&self, range: &SeriesRange) -> bool {
|
|
RangeOverlapInfo::starts_after(self.as_ref(), range)
|
|
}
|
|
}
|
|
|
|
impl TimeBinnable for Box<dyn Events> {
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Box<dyn TimeBinner> {
|
|
TimeBinnable::time_binner_new(self.as_ref(), binrange, do_time_weight, emit_empty_bins)
|
|
}
|
|
|
|
fn to_box_to_json_result(&self) -> Box<dyn ToJsonResult> {
|
|
TimeBinnable::to_box_to_json_result(self.as_ref())
|
|
}
|
|
|
|
fn to_container_bins(&self) -> Box<dyn BinningggContainerBinsDyn> {
|
|
panic!("logic error this converter must not get used on events")
|
|
}
|
|
}
|
|
|
|
impl TypeName for Box<dyn TimeBinnable> {
|
|
fn type_name(&self) -> String {
|
|
format!("Box<dyn TimeBinnable> TODO TypeName for Box<dyn TimeBinnable>")
|
|
}
|
|
}
|
|
|
|
impl CollectableDyn for Box<dyn TimeBinnable> {
|
|
fn new_collector(&self) -> Box<dyn CollectorDyn> {
|
|
self.as_ref().new_collector()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct TimeBinnerDynStruct {
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
binner: Option<Box<dyn TimeBinner>>,
|
|
emit_empty_bins: bool,
|
|
}
|
|
|
|
impl TimeBinnerDynStruct {
|
|
pub fn type_name() -> &'static str {
|
|
std::any::type_name::<Self>()
|
|
}
|
|
|
|
pub fn new(
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
binner: Box<dyn TimeBinner>,
|
|
) -> Self {
|
|
Self {
|
|
binrange,
|
|
do_time_weight,
|
|
binner: Some(binner),
|
|
emit_empty_bins,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TimeBinnerTy for TimeBinnerDynStruct {
|
|
type Input = Box<dyn TimeBinnable>;
|
|
type Output = Box<dyn TimeBinned>;
|
|
|
|
fn ingest(&mut self, item: &mut Self::Input) {
|
|
trace!("{} INGEST {:?}", Self::type_name(), item);
|
|
if self.binner.is_none() {
|
|
self.binner = Some(Box::new(TimeBinnableTy::time_binner_new(
|
|
item,
|
|
self.binrange.clone(),
|
|
self.do_time_weight,
|
|
self.emit_empty_bins,
|
|
)));
|
|
}
|
|
self.binner.as_mut().unwrap().as_mut().ingest(item.as_mut())
|
|
}
|
|
|
|
fn set_range_complete(&mut self) {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.set_range_complete()
|
|
}
|
|
}
|
|
|
|
fn bins_ready_count(&self) -> usize {
|
|
if let Some(k) = self.binner.as_ref() {
|
|
k.bins_ready_count()
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
fn bins_ready(&mut self) -> Option<Self::Output> {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.bins_ready()
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn push_in_progress(&mut self, push_empty: bool) {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.push_in_progress(push_empty)
|
|
}
|
|
}
|
|
|
|
fn cycle(&mut self) {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.cycle()
|
|
}
|
|
}
|
|
|
|
fn empty(&self) -> Option<Self::Output> {
|
|
if let Some(k) = self.binner.as_ref() {
|
|
Some(k.empty())
|
|
} else {
|
|
warn!("TimeBinnerDynStruct::empty called with binner None");
|
|
None
|
|
}
|
|
}
|
|
|
|
fn append_empty_until_end(&mut self) {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl TimeBinner for TimeBinnerDynStruct {
|
|
fn ingest(&mut self, item: &mut dyn TimeBinnable) {
|
|
todo!()
|
|
}
|
|
|
|
fn bins_ready_count(&self) -> usize {
|
|
todo!()
|
|
}
|
|
|
|
fn bins_ready(&mut self) -> Option<Box<dyn TimeBinned>> {
|
|
todo!()
|
|
}
|
|
|
|
fn push_in_progress(&mut self, push_empty: bool) {
|
|
todo!()
|
|
}
|
|
|
|
fn cycle(&mut self) {
|
|
todo!()
|
|
}
|
|
|
|
fn set_range_complete(&mut self) {
|
|
todo!()
|
|
}
|
|
|
|
fn empty(&self) -> Box<dyn TimeBinned> {
|
|
todo!()
|
|
}
|
|
|
|
fn append_empty_until_end(&mut self) {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
#[derive(Debug)]
|
|
pub struct TimeBinnerDynStruct2 {
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
binner: Option<Box<dyn TimeBinner>>,
|
|
}
|
|
|
|
impl TimeBinnerDynStruct2 {
|
|
pub fn type_name() -> &'static str {
|
|
std::any::type_name::<Self>()
|
|
}
|
|
|
|
pub fn new(
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
binner: Box<dyn TimeBinner>,
|
|
) -> Self {
|
|
Self {
|
|
binrange,
|
|
do_time_weight,
|
|
emit_empty_bins,
|
|
binner: Some(binner),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl TimeBinnerTy for TimeBinnerDynStruct2 {
|
|
type Input = Box<dyn TimeBinned>;
|
|
type Output = Box<dyn TimeBinned>;
|
|
|
|
fn ingest(&mut self, item: &mut Self::Input) {
|
|
trace!("{} INGEST {:?}", Self::type_name(), item);
|
|
if self.binner.is_none() {
|
|
self.binner = Some(Box::new(TimeBinnableTy::time_binner_new(
|
|
item,
|
|
self.binrange.clone(),
|
|
self.do_time_weight,
|
|
self.emit_empty_bins,
|
|
)));
|
|
}
|
|
self.binner
|
|
.as_mut()
|
|
.unwrap()
|
|
.as_mut()
|
|
.ingest(item.as_time_binnable_mut())
|
|
}
|
|
|
|
fn set_range_complete(&mut self) {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.set_range_complete()
|
|
}
|
|
}
|
|
|
|
fn bins_ready_count(&self) -> usize {
|
|
if let Some(k) = self.binner.as_ref() {
|
|
k.bins_ready_count()
|
|
} else {
|
|
0
|
|
}
|
|
}
|
|
|
|
fn bins_ready(&mut self) -> Option<Self::Output> {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.bins_ready()
|
|
} else {
|
|
None
|
|
}
|
|
}
|
|
|
|
fn push_in_progress(&mut self, push_empty: bool) {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.push_in_progress(push_empty)
|
|
}
|
|
}
|
|
|
|
fn cycle(&mut self) {
|
|
if let Some(k) = self.binner.as_mut() {
|
|
k.cycle()
|
|
}
|
|
}
|
|
|
|
fn empty(&self) -> Option<Self::Output> {
|
|
if let Some(k) = self.binner.as_ref() {
|
|
Some(k.empty())
|
|
} else {
|
|
warn!("TimeBinnerDynStruct::empty called with binner None");
|
|
None
|
|
}
|
|
}
|
|
|
|
fn append_empty_until_end(&mut self) {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
#[allow(unused)]
|
|
impl TimeBinner for TimeBinnerDynStruct2 {
|
|
fn ingest(&mut self, item: &mut dyn TimeBinnable) {
|
|
todo!()
|
|
}
|
|
|
|
fn bins_ready_count(&self) -> usize {
|
|
todo!()
|
|
}
|
|
|
|
fn bins_ready(&mut self) -> Option<Box<dyn TimeBinned>> {
|
|
todo!()
|
|
}
|
|
|
|
fn push_in_progress(&mut self, push_empty: bool) {
|
|
todo!()
|
|
}
|
|
|
|
fn cycle(&mut self) {
|
|
todo!()
|
|
}
|
|
|
|
fn set_range_complete(&mut self) {
|
|
todo!()
|
|
}
|
|
|
|
fn empty(&self) -> Box<dyn TimeBinned> {
|
|
todo!()
|
|
}
|
|
|
|
fn append_empty_until_end(&mut self) {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl TimeBinnableTy for Box<dyn TimeBinnable> {
|
|
type TimeBinner = TimeBinnerDynStruct;
|
|
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Self::TimeBinner {
|
|
let binner = self
|
|
.as_ref()
|
|
.time_binner_new(binrange.clone(), do_time_weight, emit_empty_bins);
|
|
TimeBinnerDynStruct::new(binrange, do_time_weight, emit_empty_bins, binner)
|
|
}
|
|
}
|
|
|
|
impl TimeBinnableTy for Box<dyn TimeBinned> {
|
|
type TimeBinner = TimeBinnerDynStruct2;
|
|
|
|
fn time_binner_new(
|
|
&self,
|
|
binrange: BinnedRangeEnum,
|
|
do_time_weight: bool,
|
|
emit_empty_bins: bool,
|
|
) -> Self::TimeBinner {
|
|
let binner = self
|
|
.as_time_binnable_ref()
|
|
.time_binner_new(binrange.clone(), do_time_weight, emit_empty_bins);
|
|
TimeBinnerDynStruct2::new(binrange, do_time_weight, emit_empty_bins, binner)
|
|
}
|
|
}
|
|
|
|
pub trait TimeBinnerIngest: fmt::Debug + TypeName + Send {
|
|
fn ingest_inrange(&mut self, item: &mut dyn TimeBinnable) -> Result<(), Error>;
|
|
}
|