use ice_rpc_rx::{Event, ObservableError, RpcError};
use rkyv::{Archive, Deserialize, Serialize};
use super::header::EventKind;
#[derive(Archive, Serialize, Deserialize, Debug, Clone, PartialEq, Eq)]
#[doc(hidden)]
pub enum WireEvent<T, E> {
Next(T),
Complete,
CompleteWith(T),
Error(E),
RpcError(RpcError),
}
impl<T, E> WireEvent<T, E> {
#[inline]
pub fn is_terminal(&self) -> bool {
matches!(
self,
WireEvent::Complete
| WireEvent::CompleteWith(_)
| WireEvent::Error(_)
| WireEvent::RpcError(_)
)
}
#[inline]
pub fn kind(&self) -> EventKind {
match self {
WireEvent::Next(_) => EventKind::Next,
WireEvent::Complete | WireEvent::CompleteWith(_) => EventKind::Complete,
WireEvent::Error(_) => EventKind::Error,
WireEvent::RpcError(_) => EventKind::RpcError,
}
}
}
impl<T, E> From<Event<T, E>> for WireEvent<T, E> {
fn from(event: Event<T, E>) -> Self {
match event {
Event::Next(v) => WireEvent::Next(v),
Event::Complete => WireEvent::Complete,
Event::Error(ObservableError::Business(e)) => WireEvent::Error(e),
Event::Error(ObservableError::Technical(e)) => WireEvent::RpcError(e),
Event::Error(ObservableError::Empty) => WireEvent::Complete,
}
}
}
pub(crate) fn normalize_wire_event<T, E>(
event: WireEvent<T, E>,
) -> (Event<T, E>, Option<Event<T, E>>) {
match event {
WireEvent::Next(v) => (Event::Next(v), None),
WireEvent::Complete => (Event::Complete, None),
WireEvent::CompleteWith(v) => (Event::Next(v), Some(Event::Complete)),
WireEvent::Error(e) => (Event::Error(ObservableError::Business(e)), None),
WireEvent::RpcError(e) => (Event::Error(ObservableError::Technical(e)), None),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn wire_event_is_terminal_flags() {
assert!(!WireEvent::<i32, String>::Next(1).is_terminal());
assert!(WireEvent::<i32, String>::Complete.is_terminal());
assert!(WireEvent::<i32, String>::CompleteWith(1).is_terminal());
assert!(WireEvent::<i32, String>::Error("boom".to_string()).is_terminal());
assert!(WireEvent::<i32, String>::RpcError(RpcError::Timeout).is_terminal());
}
#[test]
fn wire_event_rkyv_roundtrip_complete_with() {
let event: WireEvent<i32, String> = WireEvent::CompleteWith(42);
let bytes = rkyv::to_bytes::<rkyv::rancor::Error>(&event).expect("the event is encodable");
let decoded = rkyv::from_bytes::<WireEvent<i32, String>, rkyv::rancor::Error>(&bytes)
.expect("what was just encoded must decode");
match decoded {
WireEvent::CompleteWith(v) => assert_eq!(v, 42),
other => panic!("expected CompleteWith, got {other:?}"),
}
}
#[test]
fn normalize_complete_with_expands_into_next_then_complete() {
let (event, follow_up) = normalize_wire_event(WireEvent::<i32, String>::CompleteWith(7));
assert_eq!(event, Event::Next(7));
assert_eq!(follow_up, Some(Event::Complete));
}
#[test]
fn every_wire_variant_maps_to_its_own_kind() {
let kinds = [
(WireEvent::<i32, String>::Next(1), EventKind::Next),
(WireEvent::<i32, String>::Complete, EventKind::Complete),
(
WireEvent::<i32, String>::CompleteWith(1),
EventKind::Complete,
),
(
WireEvent::<i32, String>::Error(String::new()),
EventKind::Error,
),
(
WireEvent::<i32, String>::RpcError(RpcError::Timeout),
EventKind::RpcError,
),
];
for (event, expected) in kinds {
assert_eq!(event.kind(), expected, "wrong kind for {event:?}");
}
}
}