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

WIP

Browse Source
This commit is contained in:
Dominik Werder
2023-02-10 12:37:39 +01:00
parent 4d9a33b77f
commit b453d61250
10 changed files with 120 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

89
items_2/src/channelevents.rs
View File

@@ -85,7 +85,7 @@ impl ChannelStatusEvent {
#[derive(Debug)]
pub enum ChannelEvents {
Events(Box<dyn Events>),
Status(ConnStatusEvent),
Status(Option<ConnStatusEvent>),
}
impl FrameTypeInnerStatic for ChannelEvents {
@@ -342,7 +342,7 @@ mod serde_channel_events {
Ok(Self::Value::Events(x.0))
}
VarId::Status => {
let x: ConnStatusEvent = var.newtype_variant()?;
let x: Option<ConnStatusEvent> = var.newtype_variant()?;
Ok(Self::Value::Status(x))
}
}
@@ -440,7 +440,7 @@ mod test_channel_events_serde {
datetime: SystemTime::UNIX_EPOCH,
status: crate::channelevents::ConnStatus::Connect,
};
let item = ChannelEvents::Status(status);
let item = ChannelEvents::Status(Some(status));
let opts = bincode_opts();
let mut out = Vec::new();
let mut ser = bincode::Serializer::new(&mut out, opts);
@@ -453,7 +453,11 @@ mod test_channel_events_serde {
} else {
panic!()
};
assert_eq!(item.ts, 567);
if let Some(item) = item {
assert_eq!(item.ts, 567);
} else {
panic!()
}
}
}
@@ -472,7 +476,10 @@ impl MergeableCev for ChannelEvents {
use ChannelEvents::*;
match self {
Events(k) => k.ts_min(),
Status(k) => Some(k.ts),
Status(k) => match k {
Some(k) => Some(k.ts),
None => None,
},
}
}
@@ -486,40 +493,29 @@ impl crate::merger::Mergeable for ChannelEvents {
fn len(&self) -> usize {
match self {
ChannelEvents::Events(k) => k.len(),
ChannelEvents::Status(_) => 1,
ChannelEvents::Status(k) => match k {
Some(_) => 1,
None => 0,
},
}
}
fn ts_min(&self) -> Option<u64> {
match self {
ChannelEvents::Events(k) => k.ts_min(),
ChannelEvents::Status(k) => Some(k.ts),
ChannelEvents::Status(k) => match k {
Some(k) => Some(k.ts),
None => None,
},
}
}
fn ts_max(&self) -> Option<u64> {
match self {
ChannelEvents::Events(k) => k.ts_max(),
ChannelEvents::Status(k) => Some(k.ts),
}
}
fn move_into_fresh(&mut self, ts_end: u64) -> Self {
match self {
ChannelEvents::Events(k) => ChannelEvents::Events(k.move_into_fresh(ts_end)),
ChannelEvents::Status(k) => ChannelEvents::Status(k.clone()),
}
}
fn move_into_existing(&mut self, tgt: &mut Self, ts_end: u64) -> Result<(), merger::MergeError> {
match self {
ChannelEvents::Events(k) => match tgt {
ChannelEvents::Events(tgt) => k.move_into_existing(tgt, ts_end),
ChannelEvents::Status(_) => Err(merger::MergeError::NotCompatible),
},
ChannelEvents::Status(_) => match tgt {
ChannelEvents::Events(_) => Err(merger::MergeError::NotCompatible),
ChannelEvents::Status(_) => Err(merger::MergeError::Full),
ChannelEvents::Status(k) => match k {
Some(k) => Some(k.ts),
None => None,
},
}
}
@@ -539,11 +535,13 @@ impl crate::merger::Mergeable for ChannelEvents {
},
ChannelEvents::Status(k) => match dst {
ChannelEvents::Events(_) => Err(merger::MergeError::NotCompatible),
ChannelEvents::Status(j) => {
// TODO must have some empty-value for the status container.
*j = k.clone();
Ok(())
}
ChannelEvents::Status(j) => match j {
Some(_) => Err(merger::MergeError::Full),
None => {
*j = k.take();
Ok(())
}
},
},
}
}
@@ -552,8 +550,12 @@ impl crate::merger::Mergeable for ChannelEvents {
match self {
ChannelEvents::Events(k) => k.find_lowest_index_gt(ts),
ChannelEvents::Status(k) => {
if k.ts > ts {
Some(0)
if let Some(k) = k {
if k.ts > ts {
Some(0)
} else {
None
}
} else {
None
}
@@ -565,8 +567,12 @@ impl crate::merger::Mergeable for ChannelEvents {
match self {
ChannelEvents::Events(k) => k.find_lowest_index_ge(ts),
ChannelEvents::Status(k) => {
if k.ts >= ts {
Some(0)
if let Some(k) = k {
if k.ts >= ts {
Some(0)
} else {
None
}
} else {
None
}
@@ -578,8 +584,12 @@ impl crate::merger::Mergeable for ChannelEvents {
match self {
ChannelEvents::Events(k) => k.find_highest_index_lt(ts),
ChannelEvents::Status(k) => {
if k.ts < ts {
Some(0)
if let Some(k) = k {
if k.ts < ts {
Some(0)
} else {
None
}
} else {
None
}
@@ -686,9 +696,10 @@ impl crate::timebin::TimeBinnable for ChannelEvents {
type TimeBinner = ChannelEventsTimeBinner;
fn time_binner_new(&self, edges: Vec<u64>, do_time_weight: bool) -> Self::TimeBinner {
// TODO probably wrong?
let (binner, status) = match self {
ChannelEvents::Events(_events) => (None, ConnStatus::Connect),
ChannelEvents::Status(status) => (None, status.status.clone()),
ChannelEvents::Status(_status) => (None, ConnStatus::Connect),
};
ChannelEventsTimeBinner {
edges,

26
items_2/src/eventsdim0.rs
View File

@@ -778,32 +778,6 @@ impl<NTY: ScalarOps> Events for EventsDim0<NTY> {
Box::new(ret)
}
fn move_into_fresh(&mut self, ts_end: u64) -> Box<dyn Events> {
// TODO improve the search
let n1 = self.tss.iter().take_while(|&&x| x <= ts_end).count();
let tss = self.tss.drain(..n1).collect();
let pulses = self.pulses.drain(..n1).collect();
let values = self.values.drain(..n1).collect();
let ret = Self { tss, pulses, values };
Box::new(ret)
}
fn move_into_existing(&mut self, tgt: &mut Box<dyn Events>, ts_end: u64) -> Result<(), ()> {
// TODO as_any and as_any_mut are declared on unrealted traits. Simplify.
if let Some(tgt) = tgt.as_mut().as_any_mut().downcast_mut::<Self>() {
// TODO improve the search
let n1 = self.tss.iter().take_while(|&&x| x <= ts_end).count();
// TODO make it harder to forget new members when the struct may get modified in the future
tgt.tss.extend(self.tss.drain(..n1));
tgt.pulses.extend(self.pulses.drain(..n1));
tgt.values.extend(self.values.drain(..n1));
Ok(())
} else {
eprintln!("downcast to EventsDim0 FAILED");
Err(())
}
}
fn new_empty(&self) -> Box<dyn Events> {
Box::new(Self::empty())
}

26
items_2/src/eventsdim1.rs
View File

@@ -730,32 +730,6 @@ impl<NTY: ScalarOps> Events for EventsDim1<NTY> {
Box::new(ret)
}
fn move_into_fresh(&mut self, ts_end: u64) -> Box<dyn Events> {
// TODO improve the search
let n1 = self.tss.iter().take_while(|&&x| x <= ts_end).count();
let tss = self.tss.drain(..n1).collect();
let pulses = self.pulses.drain(..n1).collect();
let values = self.values.drain(..n1).collect();
let ret = Self { tss, pulses, values };
Box::new(ret)
}
fn move_into_existing(&mut self, tgt: &mut Box<dyn Events>, ts_end: u64) -> Result<(), ()> {
// TODO as_any and as_any_mut are declared on unrealted traits. Simplify.
if let Some(tgt) = tgt.as_mut().as_any_mut().downcast_mut::<Self>() {
// TODO improve the search
let n1 = self.tss.iter().take_while(|&&x| x <= ts_end).count();
// TODO make it harder to forget new members when the struct may get modified in the future
tgt.tss.extend(self.tss.drain(..n1));
tgt.pulses.extend(self.pulses.drain(..n1));
tgt.values.extend(self.values.drain(..n1));
Ok(())
} else {
eprintln!("downcast to EventsDim0 FAILED");
Err(())
}
}
fn new_empty(&self) -> Box<dyn Events> {
Box::new(Self::empty())
}

10
items_2/src/items_2.rs
View File

@@ -182,16 +182,6 @@ impl crate::merger::Mergeable for Box<dyn Events> {
self.as_ref().ts_max()
}
fn move_into_fresh(&mut self, ts_end: u64) -> Self {
self.as_mut().move_into_fresh(ts_end)
}
fn move_into_existing(&mut self, tgt: &mut Self, ts_end: u64) -> Result<(), merger::MergeError> {
self.as_mut()
.move_into_existing(tgt, ts_end)
.map_err(|()| merger::MergeError::NotCompatible)
}
fn new_empty(&self) -> Self {
self.as_ref().new_empty()
}

18
items_2/src/merger.rs
View File

@@ -1,13 +1,17 @@
use crate::Error;
use futures_util::{Stream, StreamExt};
use futures_util::Stream;
use futures_util::StreamExt;
use items::sitem_data;
use items::{RangeCompletableItem, Sitemty, StreamItem};
use items::RangeCompletableItem;
use items::Sitemty;
use items::StreamItem;
use netpod::log::*;
use std::collections::VecDeque;
use std::fmt;
use std::ops::{ControlFlow, RangeBounds};
use std::ops::ControlFlow;
use std::pin::Pin;
use std::task::{Context, Poll};
use std::task::Context;
use std::task::Poll;
#[allow(unused)]
macro_rules! trace2 {
@@ -43,12 +47,6 @@ pub trait Mergeable<Rhs = Self>: fmt::Debug + Unpin {
fn len(&self) -> usize;
fn ts_min(&self) -> Option<u64>;
fn ts_max(&self) -> Option<u64>;
// TODO remove, superseded.
fn move_into_fresh(&mut self, ts_end: u64) -> Rhs;
fn move_into_existing(&mut self, tgt: &mut Rhs, ts_end: u64) -> Result<(), MergeError>;
// TODO: split the logic into: make fresh container, and a single drain_into method. Or is there any advantage in having both?
fn new_empty(&self) -> Self;
fn drain_into(&mut self, dst: &mut Self, range: (usize, usize)) -> Result<(), MergeError>;
fn find_lowest_index_gt(&self, ts: u64) -> Option<usize>;

64
items_2/src/test.rs
View File

@@ -1,18 +1,33 @@
use crate::binned_collected;
use crate::binsdim0::BinsDim0CollectedResult;
use crate::channelevents::{ConnStatus, ConnStatusEvent};
use crate::channelevents::ConnStatus;
use crate::channelevents::ConnStatusEvent;
use crate::eventsdim0::EventsDim0;
use crate::merger::{Mergeable, Merger};
use crate::merger::Mergeable;
use crate::merger::Merger;
use crate::merger_cev::ChannelEventsMerger;
use crate::runfut;
use crate::testgen::make_some_boxed_d0_f32;
use crate::ChannelEvents;
use crate::Error;
use crate::{binned_collected, runfut, ChannelEvents, Events, IsoDateTime};
use chrono::{TimeZone, Utc};
use futures_util::{stream, StreamExt};
use items::{sitem_data, RangeCompletableItem, Sitemty, StreamItem};
use crate::Events;
use crate::IsoDateTime;
use chrono::TimeZone;
use chrono::Utc;
use futures_util::stream;
use futures_util::StreamExt;
use items::sitem_data;
use items::RangeCompletableItem;
use items::Sitemty;
use items::StreamItem;
use items_0::Empty;
use netpod::log::*;
use netpod::timeunits::*;
use netpod::{AggKind, BinnedRange, NanoRange, ScalarType, Shape};
use netpod::AggKind;
use netpod::BinnedRange;
use netpod::NanoRange;
use netpod::ScalarType;
use netpod::Shape;
use std::time::Duration;
#[test]
@@ -22,10 +37,25 @@ fn items_move_events() {
let mut v1 = v0.clone();
eprintln!("{v1:?}");
eprintln!("{}", v1.len());
let mut v2 = v1.move_into_fresh(4);
let mut v2 = v1.new_empty();
match v1.find_lowest_index_gt(4) {
Some(ilgt) => {
v1.drain_into(&mut v2, (0, ilgt)).unwrap();
}
None => {
v1.drain_into(&mut v2, (0, v1.len())).unwrap();
}
}
eprintln!("{}", v1.len());
eprintln!("{}", v2.len());
v1.move_into_existing(&mut v2, u64::MAX).unwrap();
match v1.find_lowest_index_gt(u64::MAX) {
Some(ilgt) => {
v1.drain_into(&mut v2, (0, ilgt)).unwrap();
}
None => {
v1.drain_into(&mut v2, (0, v1.len())).unwrap();
}
}
eprintln!("{}", v1.len());
eprintln!("{}", v2.len());
eprintln!("{v1:?}");
@@ -62,9 +92,9 @@ fn items_merge_01() {
let evs1 = make_some_boxed_d0_f32(10, SEC * 2, SEC * 2, 0, 828764893);
let v0 = ChannelEvents::Events(evs0);
let v1 = ChannelEvents::Events(evs1);
let v2 = ChannelEvents::Status(ConnStatusEvent::new(MS * 100, ConnStatus::Connect));
let v3 = ChannelEvents::Status(ConnStatusEvent::new(MS * 2300, ConnStatus::Disconnect));
let v4 = ChannelEvents::Status(ConnStatusEvent::new(MS * 2800, ConnStatus::Connect));
let v2 = ChannelEvents::Status(Some(ConnStatusEvent::new(MS * 100, ConnStatus::Connect)));
let v3 = ChannelEvents::Status(Some(ConnStatusEvent::new(MS * 2300, ConnStatus::Disconnect)));
let v4 = ChannelEvents::Status(Some(ConnStatusEvent::new(MS * 2800, ConnStatus::Connect)));
let stream0 = Box::pin(stream::iter(vec![sitem_data(v0)]));
let stream1 = Box::pin(stream::iter(vec![sitem_data(v1)]));
let stream2 = Box::pin(stream::iter(vec![sitem_data(v2), sitem_data(v3), sitem_data(v4)]));
@@ -97,9 +127,9 @@ fn items_merge_02() {
let evs1 = make_some_boxed_d0_f32(100, SEC * 2, SEC * 2, 0, 828764893);
let v0 = ChannelEvents::Events(evs0);
let v1 = ChannelEvents::Events(evs1);
let v2 = ChannelEvents::Status(ConnStatusEvent::new(MS * 100, ConnStatus::Connect));
let v3 = ChannelEvents::Status(ConnStatusEvent::new(MS * 2300, ConnStatus::Disconnect));
let v4 = ChannelEvents::Status(ConnStatusEvent::new(MS * 2800, ConnStatus::Connect));
let v2 = ChannelEvents::Status(Some(ConnStatusEvent::new(MS * 100, ConnStatus::Connect)));
let v3 = ChannelEvents::Status(Some(ConnStatusEvent::new(MS * 2300, ConnStatus::Disconnect)));
let v4 = ChannelEvents::Status(Some(ConnStatusEvent::new(MS * 2800, ConnStatus::Connect)));
let stream0 = Box::pin(stream::iter(vec![sitem_data(v0)]));
let stream1 = Box::pin(stream::iter(vec![sitem_data(v1)]));
let stream2 = Box::pin(stream::iter(vec![sitem_data(v2), sitem_data(v3), sitem_data(v4)]));
@@ -241,7 +271,7 @@ fn merge03() {
status: ConnStatus::Disconnect,
};
let item: Sitemty<ChannelEvents> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(
ChannelEvents::Status(ev),
ChannelEvents::Status(Some(ev)),
)));
vec![item]
};
@@ -253,7 +283,7 @@ fn merge03() {
status: ConnStatus::Disconnect,
};
let item: Sitemty<ChannelEvents> = Ok(StreamItem::DataItem(RangeCompletableItem::Data(
ChannelEvents::Status(ev),
ChannelEvents::Status(Some(ev)),
)));
vec![item]
};