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

Refactor for easier channel conversion tool

Browse Source
This commit is contained in:
Dominik Werder
2021-12-15 22:54:42 +01:00
parent 11229bd514
commit 7053af83b7
12 changed files with 1126 additions and 764 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
archapp/src/archeng/datablock.rs
View File

@@ -451,21 +451,21 @@ pub async fn read_data2(
return Err(Error::with_msg_no_trace(format!("unexpected dbrcount {}", dbrcount)));
}
let res = match &dbrt {
DbrType::DbrTimeChar => read_msg!(i8, ex_s_i8, ex_v_i8, Byte, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeShort => read_msg!(i16, ex_s_i16, ex_v_i16, Short, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeLong => read_msg!(i32, ex_s_i32, ex_v_i32, Int, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeFloat => read_msg!(f32, ex_s_f32, ex_v_f32, Float, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeDouble => read_msg!(f64, ex_s_f64, ex_v_f64, Double, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeChar => read_msg!(i8, ex_s_i8, ex_v_i8, I8, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeShort => read_msg!(i16, ex_s_i16, ex_v_i16, I16, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeLong => read_msg!(i32, ex_s_i32, ex_v_i32, I32, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeFloat => read_msg!(f32, ex_s_f32, ex_v_f32, F32, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeDouble => read_msg!(f64, ex_s_f64, ex_v_f64, F64, rb, msg_len, numsamples, dbrt, dbrcount),
DbrType::DbrTimeString => {
if dbrcount == 1 {
// TODO
let evs = ScalarPlainEvents::Byte(EventValues::empty());
let evs = ScalarPlainEvents::I8(EventValues::empty());
let plain = PlainEvents::Scalar(evs);
let item = EventsItem::Plain(plain);
item
} else {
// TODO
let evs = WavePlainEvents::Double(WaveEvents::empty());
let evs = WavePlainEvents::F64(WaveEvents::empty());
let plain = PlainEvents::Wave(evs);
let item = EventsItem::Plain(plain);
item
@@ -526,7 +526,7 @@ pub async fn read_data_1(
}
}
debug!("parsed block with {} / {} events", ntot, evs.tss.len());
let evs = ScalarPlainEvents::Double(evs);
let evs = ScalarPlainEvents::F64(evs);
let plain = PlainEvents::Scalar(evs);
let item = EventsItem::Plain(plain);
item

40
archapp/src/archeng/pipe.rs
View File

@@ -105,47 +105,47 @@ pub async fn make_event_pipe(
PlainEvents::Wave(j) => {
trace!("EventsItem::Plain Wave for {:?} {:?}", cfgshape, q_agg_kind);
match j {
WavePlainEvents::Byte(j) => {
WavePlainEvents::I8(j) => {
let binner =
WaveXBinner::<i8>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = SingleBinWaveEvents::Byte(out);
let item = SingleBinWaveEvents::I8(out);
let item = XBinnedEvents::SingleBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Short(j) => {
WavePlainEvents::I16(j) => {
let binner =
WaveXBinner::<i16>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = SingleBinWaveEvents::Short(out);
let item = SingleBinWaveEvents::I16(out);
let item = XBinnedEvents::SingleBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Int(j) => {
WavePlainEvents::I32(j) => {
let binner =
WaveXBinner::<i32>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = SingleBinWaveEvents::Int(out);
let item = SingleBinWaveEvents::I32(out);
let item = XBinnedEvents::SingleBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Float(j) => {
WavePlainEvents::F32(j) => {
let binner =
WaveXBinner::<f32>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = SingleBinWaveEvents::Float(out);
let item = SingleBinWaveEvents::F32(out);
let item = XBinnedEvents::SingleBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Double(j) => {
WavePlainEvents::F64(j) => {
let binner =
WaveXBinner::<f64>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = SingleBinWaveEvents::Double(out);
let item = SingleBinWaveEvents::F64(out);
let item = XBinnedEvents::SingleBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
@@ -193,47 +193,47 @@ pub async fn make_event_pipe(
PlainEvents::Wave(j) => {
trace!("EventsItem::Plain Wave for {:?} {:?}", cfgshape, q_agg_kind);
match j {
WavePlainEvents::Byte(j) => {
WavePlainEvents::I8(j) => {
let binner =
WaveNBinner::<i8>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = MultiBinWaveEvents::Byte(out);
let item = MultiBinWaveEvents::I8(out);
let item = XBinnedEvents::MultiBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Short(j) => {
WavePlainEvents::I16(j) => {
let binner =
WaveNBinner::<i16>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = MultiBinWaveEvents::Short(out);
let item = MultiBinWaveEvents::I16(out);
let item = XBinnedEvents::MultiBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Int(j) => {
WavePlainEvents::I32(j) => {
let binner =
WaveNBinner::<i32>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = MultiBinWaveEvents::Int(out);
let item = MultiBinWaveEvents::I32(out);
let item = XBinnedEvents::MultiBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Float(j) => {
WavePlainEvents::F32(j) => {
let binner =
WaveNBinner::<f32>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = MultiBinWaveEvents::Float(out);
let item = MultiBinWaveEvents::F32(out);
let item = XBinnedEvents::MultiBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))
}
WavePlainEvents::Double(j) => {
WavePlainEvents::F64(j) => {
let binner =
WaveNBinner::<f64>::create(cfgshape.clone(), q_agg_kind.clone());
let out = binner.process(j);
let item = MultiBinWaveEvents::Double(out);
let item = MultiBinWaveEvents::F64(out);
let item = XBinnedEvents::MultiBinWave(item);
let item = EventsItem::XBinnedEvents(item);
Ok(StreamItem::DataItem(RangeCompletableItem::Data(item)))

12
archapp/src/events.rs
View File

@@ -290,11 +290,11 @@ impl FrameMakerTrait for FrameMaker {
let shape = &self.shape;
let agg_kind = &self.agg_kind;
match scalar_type {
ScalarType::I8 => arm1!(item, i8, Byte, shape, agg_kind),
ScalarType::I16 => arm1!(item, i16, Short, shape, agg_kind),
ScalarType::I32 => arm1!(item, i32, Int, shape, agg_kind),
ScalarType::F32 => arm1!(item, f32, Float, shape, agg_kind),
ScalarType::F64 => arm1!(item, f64, Double, shape, agg_kind),
ScalarType::I8 => arm1!(item, i8, I8, shape, agg_kind),
ScalarType::I16 => arm1!(item, i16, I16, shape, agg_kind),
ScalarType::I32 => arm1!(item, i32, I32, shape, agg_kind),
ScalarType::F32 => arm1!(item, f32, F32, shape, agg_kind),
ScalarType::F64 => arm1!(item, f64, F64, shape, agg_kind),
_ => {
warn!("TODO for scalar_type {:?}", scalar_type);
err::todoval()
@@ -625,7 +625,7 @@ async fn linear_search_2(
#[allow(unused)]
fn events_item_to_framable(ei: EventsItem) -> Result<Box<dyn Framable + Send>, Error> {
match ei {
EventsItem::Plain(PlainEvents::Scalar(ScalarPlainEvents::Int(h))) => {
EventsItem::Plain(PlainEvents::Scalar(ScalarPlainEvents::I32(h))) => {
let range: NanoRange = err::todoval();
let (x, y) = h
.tss

25
archapp/src/parse.rs
View File

@@ -50,7 +50,7 @@ fn parse_scalar_byte(m: &[u8], year: u32) -> Result<EventsItem, Error> {
let v = msg.get_val().first().map_or(0, |k| *k as i8);
t.tss.push(ts);
t.values.push(v);
Ok(EventsItem::Plain(PlainEvents::Scalar(ScalarPlainEvents::Byte(t))))
Ok(EventsItem::Plain(PlainEvents::Scalar(ScalarPlainEvents::I8(t))))
}
macro_rules! scalar_parse {
@@ -65,6 +65,7 @@ macro_rules! scalar_parse {
let ts =
yd.timestamp() as u64 * 1000000000 + msg.get_secondsintoyear() as u64 * 1000000000 + msg.get_nano() as u64;
let v = msg.get_val();
//eprintln!("ts {} val {}", ts, v);
t.tss.push(ts);
t.values.push(v as $evty);
EventsItem::Plain(PlainEvents::Scalar(ScalarPlainEvents::$eit(t)))
@@ -175,37 +176,37 @@ impl PbFileReader {
let ei = match payload_type {
SCALAR_BYTE => parse_scalar_byte(m, year)?,
SCALAR_ENUM => {
scalar_parse!(m, year, ScalarEnum, Int, i32)
scalar_parse!(m, year, ScalarEnum, I32, i32)
}
SCALAR_SHORT => {
scalar_parse!(m, year, ScalarShort, Short, i16)
scalar_parse!(m, year, ScalarShort, I16, i16)
}
SCALAR_INT => {
scalar_parse!(m, year, ScalarInt, Int, i32)
scalar_parse!(m, year, ScalarInt, I32, i32)
}
SCALAR_FLOAT => {
scalar_parse!(m, year, ScalarFloat, Float, f32)
scalar_parse!(m, year, ScalarFloat, F32, f32)
}
SCALAR_DOUBLE => {
scalar_parse!(m, year, ScalarDouble, Double, f64)
scalar_parse!(m, year, ScalarDouble, F64, f64)
}
WAVEFORM_BYTE => {
wave_parse!(m, year, VectorChar, Byte, i8)
wave_parse!(m, year, VectorChar, I8, i8)
}
WAVEFORM_SHORT => {
wave_parse!(m, year, VectorShort, Short, i16)
wave_parse!(m, year, VectorShort, I16, i16)
}
WAVEFORM_ENUM => {
wave_parse!(m, year, VectorEnum, Int, i32)
wave_parse!(m, year, VectorEnum, I32, i32)
}
WAVEFORM_INT => {
wave_parse!(m, year, VectorInt, Int, i32)
wave_parse!(m, year, VectorInt, I32, i32)
}
WAVEFORM_FLOAT => {
wave_parse!(m, year, VectorFloat, Float, f32)
wave_parse!(m, year, VectorFloat, F32, f32)
}
WAVEFORM_DOUBLE => {
wave_parse!(m, year, VectorDouble, Double, f64)
wave_parse!(m, year, VectorDouble, F64, f64)
}
SCALAR_STRING | WAVEFORM_STRING | V4_GENERIC_BYTES => {
return Err(Error::with_msg_no_trace(format!("not supported: {:?}", payload_type)));