700 lines
21 KiB
Rust
700 lines
21 KiB
Rust
use crate::merger;
|
|
use crate::merger_cev::MergeableCev;
|
|
use crate::Events;
|
|
use items::FrameType;
|
|
use items::FrameTypeInnerStatic;
|
|
use items_0::collect_s::Collectable;
|
|
use items_0::collect_s::Collector;
|
|
use items_0::AsAnyMut;
|
|
use items_0::AsAnyRef;
|
|
use netpod::log::*;
|
|
use serde::{Deserialize, Serialize};
|
|
use std::any::Any;
|
|
use std::fmt;
|
|
|
|
// TODO maybe rename to ChannelStatus?
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
pub enum ConnStatus {
|
|
Connect,
|
|
Disconnect,
|
|
}
|
|
|
|
impl ConnStatus {
|
|
pub fn from_ca_ingest_status_kind(k: u32) -> Self {
|
|
match k {
|
|
1 => Self::Connect,
|
|
2 => Self::Disconnect,
|
|
3 => Self::Disconnect,
|
|
_ => Self::Disconnect,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
|
pub struct ConnStatusEvent {
|
|
pub ts: u64,
|
|
pub status: ConnStatus,
|
|
}
|
|
|
|
impl ConnStatusEvent {
|
|
pub fn new(ts: u64, status: ConnStatus) -> Self {
|
|
Self { ts, status }
|
|
}
|
|
}
|
|
|
|
/// Events on a channel consist not only of e.g. timestamped values, but can be also
|
|
/// connection status changes.
|
|
#[derive(Debug)]
|
|
pub enum ChannelEvents {
|
|
Events(Box<dyn Events>),
|
|
Status(ConnStatusEvent),
|
|
}
|
|
|
|
impl FrameTypeInnerStatic for ChannelEvents {
|
|
const FRAME_TYPE_ID: u32 = items::ITEMS_2_CHANNEL_EVENTS_FRAME_TYPE_ID;
|
|
}
|
|
|
|
impl FrameType for ChannelEvents {
|
|
fn frame_type_id(&self) -> u32 {
|
|
// TODO SubFrId missing, but get rid of the frame type concept anyhow.
|
|
<Self as FrameTypeInnerStatic>::FRAME_TYPE_ID
|
|
}
|
|
}
|
|
|
|
impl Clone for ChannelEvents {
|
|
fn clone(&self) -> Self {
|
|
match self {
|
|
Self::Events(arg0) => Self::Events(arg0.clone_dyn()),
|
|
Self::Status(arg0) => Self::Status(arg0.clone()),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl AsAnyRef for ChannelEvents {
|
|
fn as_any_ref(&self) -> &dyn Any {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl AsAnyMut for ChannelEvents {
|
|
fn as_any_mut(&mut self) -> &mut dyn Any {
|
|
self
|
|
}
|
|
}
|
|
|
|
mod serde_channel_events {
|
|
use super::{ChannelEvents, Events};
|
|
use crate::channelevents::ConnStatusEvent;
|
|
use crate::eventsdim0::EventsDim0;
|
|
use items_0::subfr::SubFrId;
|
|
use serde::de::{self, EnumAccess, VariantAccess, Visitor};
|
|
use serde::ser::SerializeSeq;
|
|
use serde::{Deserialize, Deserializer, Serialize, Serializer};
|
|
use std::fmt;
|
|
|
|
struct EvRef<'a>(&'a dyn Events);
|
|
|
|
struct EvBox(Box<dyn Events>);
|
|
|
|
impl<'a> Serialize for EvRef<'a> {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let mut ser = serializer.serialize_seq(Some(3))?;
|
|
ser.serialize_element(self.0.serde_id())?;
|
|
ser.serialize_element(&self.0.nty_id())?;
|
|
ser.serialize_element(self.0)?;
|
|
ser.end()
|
|
}
|
|
}
|
|
|
|
struct EvBoxVis;
|
|
|
|
impl EvBoxVis {
|
|
fn name() -> &'static str {
|
|
"Events"
|
|
}
|
|
}
|
|
|
|
impl<'de> Visitor<'de> for EvBoxVis {
|
|
type Value = EvBox;
|
|
|
|
fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(fmt, "{}", Self::name())
|
|
}
|
|
|
|
fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
|
|
where
|
|
A: de::SeqAccess<'de>,
|
|
{
|
|
let e0: &str = seq.next_element()?.ok_or(de::Error::missing_field("[0] cty"))?;
|
|
let e1: u32 = seq.next_element()?.ok_or(de::Error::missing_field("[1] nty"))?;
|
|
if e0 == EventsDim0::<u8>::serde_id() {
|
|
match e1 {
|
|
u8::SUB => {
|
|
let obj: EventsDim0<u8> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
u16::SUB => {
|
|
let obj: EventsDim0<u16> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
u32::SUB => {
|
|
let obj: EventsDim0<u32> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
u64::SUB => {
|
|
let obj: EventsDim0<u64> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
i8::SUB => {
|
|
let obj: EventsDim0<i8> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
i16::SUB => {
|
|
let obj: EventsDim0<i16> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
i32::SUB => {
|
|
let obj: EventsDim0<i32> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
i64::SUB => {
|
|
let obj: EventsDim0<i64> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
f32::SUB => {
|
|
let obj: EventsDim0<f32> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
f64::SUB => {
|
|
let obj: EventsDim0<f64> = seq.next_element()?.ok_or(de::Error::missing_field("[2] obj"))?;
|
|
Ok(EvBox(Box::new(obj)))
|
|
}
|
|
_ => Err(de::Error::custom(&format!("unknown nty {e1}"))),
|
|
}
|
|
} else {
|
|
Err(de::Error::custom(&format!("unknown cty {e0}")))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for EvBox {
|
|
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
deserializer.deserialize_seq(EvBoxVis)
|
|
}
|
|
}
|
|
|
|
impl Serialize for ChannelEvents {
|
|
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
|
|
where
|
|
S: Serializer,
|
|
{
|
|
let name = "ChannelEvents";
|
|
let vars = ChannelEventsVis::allowed_variants();
|
|
match self {
|
|
ChannelEvents::Events(obj) => {
|
|
serializer.serialize_newtype_variant(name, 0, vars[0], &EvRef(obj.as_ref()))
|
|
}
|
|
ChannelEvents::Status(val) => serializer.serialize_newtype_variant(name, 1, vars[1], val),
|
|
}
|
|
}
|
|
}
|
|
|
|
enum VarId {
|
|
Events,
|
|
Status,
|
|
}
|
|
|
|
struct VarIdVis;
|
|
|
|
impl<'de> Visitor<'de> for VarIdVis {
|
|
type Value = VarId;
|
|
|
|
fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(fmt, "variant identifier")
|
|
}
|
|
|
|
fn visit_u64<E>(self, val: u64) -> Result<Self::Value, E>
|
|
where
|
|
E: de::Error,
|
|
{
|
|
match val {
|
|
0 => Ok(VarId::Events),
|
|
1 => Ok(VarId::Status),
|
|
_ => Err(de::Error::invalid_value(
|
|
de::Unexpected::Unsigned(val),
|
|
&"variant index 0..2",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn visit_str<E>(self, val: &str) -> Result<Self::Value, E>
|
|
where
|
|
E: de::Error,
|
|
{
|
|
let vars = ChannelEventsVis::allowed_variants();
|
|
if val == vars[0] {
|
|
Ok(VarId::Events)
|
|
} else if val == vars[1] {
|
|
Ok(VarId::Status)
|
|
} else {
|
|
Err(de::Error::unknown_variant(val, ChannelEventsVis::allowed_variants()))
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for VarId {
|
|
fn deserialize<D>(de: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
de.deserialize_identifier(VarIdVis)
|
|
}
|
|
}
|
|
|
|
pub struct ChannelEventsVis;
|
|
|
|
impl ChannelEventsVis {
|
|
fn name() -> &'static str {
|
|
"ChannelEvents"
|
|
}
|
|
|
|
fn allowed_variants() -> &'static [&'static str] {
|
|
&["Events", "Status"]
|
|
}
|
|
}
|
|
|
|
impl<'de> Visitor<'de> for ChannelEventsVis {
|
|
type Value = ChannelEvents;
|
|
|
|
fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
write!(fmt, "{}", Self::name())
|
|
}
|
|
|
|
fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
|
|
where
|
|
A: EnumAccess<'de>,
|
|
{
|
|
let (id, var) = data.variant()?;
|
|
match id {
|
|
VarId::Events => {
|
|
let x: EvBox = var.newtype_variant()?;
|
|
Ok(Self::Value::Events(x.0))
|
|
}
|
|
VarId::Status => {
|
|
let x: ConnStatusEvent = var.newtype_variant()?;
|
|
Ok(Self::Value::Status(x))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl<'de> Deserialize<'de> for ChannelEvents {
|
|
fn deserialize<D>(de: D) -> Result<Self, D::Error>
|
|
where
|
|
D: Deserializer<'de>,
|
|
{
|
|
de.deserialize_enum(
|
|
ChannelEventsVis::name(),
|
|
ChannelEventsVis::allowed_variants(),
|
|
ChannelEventsVis,
|
|
)
|
|
}
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod test_channel_events_serde {
|
|
use super::ChannelEvents;
|
|
use crate::channelevents::ConnStatusEvent;
|
|
use crate::eventsdim0::EventsDim0;
|
|
use bincode::config::FixintEncoding;
|
|
use bincode::config::LittleEndian;
|
|
use bincode::config::RejectTrailing;
|
|
use bincode::config::WithOtherEndian;
|
|
use bincode::config::WithOtherIntEncoding;
|
|
use bincode::config::WithOtherTrailing;
|
|
use bincode::DefaultOptions;
|
|
use items_0::bincode;
|
|
use items_0::Empty;
|
|
use serde::{Deserialize, Serialize};
|
|
|
|
#[test]
|
|
fn channel_events() {
|
|
let mut evs = EventsDim0::empty();
|
|
evs.push(8, 2, 3.0f32);
|
|
evs.push(12, 3, 3.2f32);
|
|
let item = ChannelEvents::Events(Box::new(evs));
|
|
let s = serde_json::to_string_pretty(&item).unwrap();
|
|
eprintln!("{s}");
|
|
let w: ChannelEvents = serde_json::from_str(&s).unwrap();
|
|
eprintln!("{w:?}");
|
|
}
|
|
|
|
type OptsTy = WithOtherTrailing<
|
|
WithOtherIntEncoding<WithOtherEndian<DefaultOptions, LittleEndian>, FixintEncoding>,
|
|
RejectTrailing,
|
|
>;
|
|
|
|
fn bincode_opts() -> OptsTy {
|
|
use bincode::Options;
|
|
let opts = bincode::DefaultOptions::new()
|
|
.with_little_endian()
|
|
.with_fixint_encoding()
|
|
.reject_trailing_bytes();
|
|
opts
|
|
}
|
|
|
|
#[test]
|
|
fn channel_events_bincode() {
|
|
let mut evs = EventsDim0::empty();
|
|
evs.push(8, 2, 3.0f32);
|
|
evs.push(12, 3, 3.2f32);
|
|
let item = ChannelEvents::Events(Box::new(evs));
|
|
let opts = bincode_opts();
|
|
let mut out = Vec::new();
|
|
let mut ser = bincode::Serializer::new(&mut out, opts);
|
|
item.serialize(&mut ser).unwrap();
|
|
eprintln!("serialized into {} bytes", out.len());
|
|
let mut de = bincode::Deserializer::from_slice(&out, opts);
|
|
let item = <ChannelEvents as Deserialize>::deserialize(&mut de).unwrap();
|
|
let item = if let ChannelEvents::Events(x) = item {
|
|
x
|
|
} else {
|
|
panic!()
|
|
};
|
|
let item: &EventsDim0<f32> = item.as_any_ref().downcast_ref().unwrap();
|
|
assert_eq!(item.tss().len(), 2);
|
|
assert_eq!(item.tss()[1], 12);
|
|
}
|
|
|
|
#[test]
|
|
fn channel_status_bincode() {
|
|
let mut evs = EventsDim0::empty();
|
|
evs.push(8, 2, 3.0f32);
|
|
evs.push(12, 3, 3.2f32);
|
|
let status = ConnStatusEvent {
|
|
ts: 567,
|
|
status: crate::channelevents::ConnStatus::Connect,
|
|
};
|
|
let item = ChannelEvents::Status(status);
|
|
let opts = bincode_opts();
|
|
let mut out = Vec::new();
|
|
let mut ser = bincode::Serializer::new(&mut out, opts);
|
|
item.serialize(&mut ser).unwrap();
|
|
eprintln!("serialized into {} bytes", out.len());
|
|
let mut de = bincode::Deserializer::from_slice(&out, opts);
|
|
let item = <ChannelEvents as Deserialize>::deserialize(&mut de).unwrap();
|
|
let item = if let ChannelEvents::Status(x) = item {
|
|
x
|
|
} else {
|
|
panic!()
|
|
};
|
|
assert_eq!(item.ts, 567);
|
|
}
|
|
}
|
|
|
|
impl PartialEq for ChannelEvents {
|
|
fn eq(&self, other: &Self) -> bool {
|
|
match (self, other) {
|
|
(Self::Events(l0), Self::Events(r0)) => l0 == r0,
|
|
(Self::Status(l0), Self::Status(r0)) => l0 == r0,
|
|
_ => core::mem::discriminant(self) == core::mem::discriminant(other),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl MergeableCev for ChannelEvents {
|
|
fn ts_min(&self) -> Option<u64> {
|
|
use ChannelEvents::*;
|
|
match self {
|
|
Events(k) => k.ts_min(),
|
|
Status(k) => Some(k.ts),
|
|
}
|
|
}
|
|
|
|
fn ts_max(&self) -> Option<u64> {
|
|
error!("TODO impl MergableEvents for ChannelEvents");
|
|
err::todoval()
|
|
}
|
|
}
|
|
|
|
impl crate::merger::Mergeable for ChannelEvents {
|
|
fn len(&self) -> usize {
|
|
match self {
|
|
ChannelEvents::Events(k) => k.len(),
|
|
ChannelEvents::Status(_) => 1,
|
|
}
|
|
}
|
|
|
|
fn ts_min(&self) -> Option<u64> {
|
|
match self {
|
|
ChannelEvents::Events(k) => k.ts_min(),
|
|
ChannelEvents::Status(k) => Some(k.ts),
|
|
}
|
|
}
|
|
|
|
fn ts_max(&self) -> Option<u64> {
|
|
match self {
|
|
ChannelEvents::Events(k) => k.ts_max(),
|
|
ChannelEvents::Status(k) => Some(k.ts),
|
|
}
|
|
}
|
|
|
|
fn is_compatible_target(&self, tgt: &Self) -> bool {
|
|
use ChannelEvents::*;
|
|
match self {
|
|
Events(_) => {
|
|
// TODO better to delegate this to inner type?
|
|
if let Events(_) = tgt {
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
Status(_) => {
|
|
// TODO better to delegate this to inner type?
|
|
if let Status(_) = tgt {
|
|
true
|
|
} else {
|
|
false
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
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),
|
|
},
|
|
}
|
|
}
|
|
}
|
|
|
|
impl Collectable for ChannelEvents {
|
|
fn new_collector(&self) -> Box<dyn Collector> {
|
|
match self {
|
|
ChannelEvents::Events(_item) => todo!(),
|
|
ChannelEvents::Status(_) => todo!(),
|
|
}
|
|
}
|
|
}
|
|
|
|
pub struct ChannelEventsTimeBinner {
|
|
// TODO `ConnStatus` contains all the changes that can happen to a connection, but
|
|
// here we would rather require a simplified current state for binning purpose.
|
|
edges: Vec<u64>,
|
|
do_time_weight: bool,
|
|
conn_state: ConnStatus,
|
|
binner: Option<Box<dyn crate::TimeBinner>>,
|
|
}
|
|
|
|
impl fmt::Debug for ChannelEventsTimeBinner {
|
|
fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
|
|
fmt.debug_struct("ChannelEventsTimeBinner")
|
|
.field("conn_state", &self.conn_state)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
impl crate::timebin::TimeBinner for ChannelEventsTimeBinner {
|
|
type Input = ChannelEvents;
|
|
type Output = Box<dyn items_0::TimeBinned>;
|
|
|
|
fn ingest(&mut self, item: &mut Self::Input) {
|
|
match item {
|
|
ChannelEvents::Events(item) => {
|
|
if self.binner.is_none() {
|
|
let binner = item.time_binner_new(self.edges.clone(), self.do_time_weight);
|
|
self.binner = Some(binner);
|
|
}
|
|
match self.binner.as_mut() {
|
|
Some(binner) => binner.ingest(item.as_time_binnable()),
|
|
None => {
|
|
error!("ingest without active binner item {item:?}");
|
|
()
|
|
}
|
|
}
|
|
}
|
|
ChannelEvents::Status(item) => {
|
|
warn!("TODO consider channel status in time binning {item:?}");
|
|
}
|
|
}
|
|
}
|
|
|
|
fn set_range_complete(&mut self) {
|
|
match self.binner.as_mut() {
|
|
Some(binner) => binner.set_range_complete(),
|
|
None => (),
|
|
}
|
|
}
|
|
|
|
fn bins_ready_count(&self) -> usize {
|
|
match &self.binner {
|
|
Some(binner) => binner.bins_ready_count(),
|
|
None => 0,
|
|
}
|
|
}
|
|
|
|
fn bins_ready(&mut self) -> Option<Self::Output> {
|
|
match self.binner.as_mut() {
|
|
Some(binner) => binner.bins_ready(),
|
|
None => None,
|
|
}
|
|
}
|
|
|
|
fn push_in_progress(&mut self, push_empty: bool) {
|
|
match self.binner.as_mut() {
|
|
Some(binner) => binner.push_in_progress(push_empty),
|
|
None => (),
|
|
}
|
|
}
|
|
|
|
fn cycle(&mut self) {
|
|
match self.binner.as_mut() {
|
|
Some(binner) => binner.cycle(),
|
|
None => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
impl crate::timebin::TimeBinnable for ChannelEvents {
|
|
type TimeBinner = ChannelEventsTimeBinner;
|
|
|
|
fn time_binner_new(&self, edges: Vec<u64>, do_time_weight: bool) -> Self::TimeBinner {
|
|
let (binner, status) = match self {
|
|
ChannelEvents::Events(_events) => (None, ConnStatus::Connect),
|
|
ChannelEvents::Status(status) => (None, status.status.clone()),
|
|
};
|
|
ChannelEventsTimeBinner {
|
|
edges,
|
|
do_time_weight,
|
|
conn_state: status,
|
|
binner,
|
|
}
|
|
}
|
|
}
|
|
|
|
#[derive(Debug, Serialize, Deserialize)]
|
|
pub struct ChannelEventsCollectorOutput {}
|
|
|
|
impl AsAnyRef for ChannelEventsCollectorOutput {
|
|
fn as_any_ref(&self) -> &dyn Any {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl AsAnyMut for ChannelEventsCollectorOutput {
|
|
fn as_any_mut(&mut self) -> &mut dyn Any {
|
|
self
|
|
}
|
|
}
|
|
|
|
impl crate::ToJsonResult for ChannelEventsCollectorOutput {
|
|
fn to_json_result(&self) -> Result<Box<dyn items_0::collect_s::ToJsonBytes>, err::Error> {
|
|
todo!()
|
|
}
|
|
}
|
|
|
|
impl items_0::collect_c::Collected for ChannelEventsCollectorOutput {}
|
|
|
|
#[derive(Debug)]
|
|
pub struct ChannelEventsCollector {
|
|
coll: Option<Box<dyn items_0::collect_c::CollectorDyn>>,
|
|
range_complete: bool,
|
|
timed_out: bool,
|
|
}
|
|
|
|
impl ChannelEventsCollector {
|
|
pub fn new() -> Self {
|
|
Self {
|
|
coll: None,
|
|
range_complete: false,
|
|
timed_out: false,
|
|
}
|
|
}
|
|
}
|
|
|
|
impl items_0::collect_c::Collector for ChannelEventsCollector {
|
|
fn len(&self) -> usize {
|
|
match &self.coll {
|
|
Some(coll) => coll.len(),
|
|
None => 0,
|
|
}
|
|
}
|
|
|
|
fn ingest(&mut self, item: &mut dyn items_0::collect_c::Collectable) {
|
|
if let Some(item) = item.as_any_mut().downcast_mut::<ChannelEvents>() {
|
|
match item {
|
|
ChannelEvents::Events(item) => {
|
|
if self.coll.is_none() {
|
|
let coll = item.as_ref().as_collectable_with_default_ref().new_collector();
|
|
self.coll = Some(coll);
|
|
}
|
|
let coll = self.coll.as_mut().unwrap();
|
|
coll.ingest(item.as_collectable_with_default_mut());
|
|
}
|
|
ChannelEvents::Status(_) => {
|
|
// TODO decide on output format to collect also the connection status events
|
|
}
|
|
}
|
|
} else {
|
|
error!("ChannelEventsCollector::ingest unexpected item {:?}", item);
|
|
}
|
|
}
|
|
|
|
fn set_range_complete(&mut self) {
|
|
self.range_complete = true;
|
|
}
|
|
|
|
fn set_timed_out(&mut self) {
|
|
self.timed_out = true;
|
|
}
|
|
|
|
fn result(&mut self) -> Result<Box<dyn items_0::collect_c::Collected>, err::Error> {
|
|
match self.coll.as_mut() {
|
|
Some(coll) => {
|
|
if self.range_complete {
|
|
coll.set_range_complete();
|
|
}
|
|
if self.timed_out {
|
|
coll.set_timed_out();
|
|
}
|
|
let res = coll.result()?;
|
|
//error!("fix output of ChannelEventsCollector [03ce6bc5a]");
|
|
//err::todo();
|
|
//let output = ChannelEventsCollectorOutput {};
|
|
Ok(res)
|
|
}
|
|
None => {
|
|
error!("nothing collected [caa8d2565]");
|
|
todo!()
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
impl items_0::collect_c::Collectable for ChannelEvents {
|
|
fn new_collector(&self) -> Box<dyn items_0::collect_c::Collector> {
|
|
Box::new(ChannelEventsCollector::new())
|
|
}
|
|
}
|