Skip to main content

sim_lib_stream_host/
cassette.rs

1//! Host callback cassette and replay support.
2
3use sim_kernel::Result;
4use sim_lib_stream_core::{
5    StreamCassette, StreamItem, StreamMetadata, StreamPacket, StreamStats, TransportProfile,
6};
7
8use crate::HostCallbackQueue;
9
10/// Deterministic recording of host callback items.
11#[derive(Clone, Debug, Default, PartialEq, Eq)]
12pub struct HostCallbackCassette {
13    items: Vec<StreamItem>,
14}
15
16impl HostCallbackCassette {
17    /// Creates an empty cassette.
18    pub fn new() -> Self {
19        Self::default()
20    }
21
22    /// Creates a cassette from callback items.
23    pub fn from_items(items: Vec<StreamItem>) -> Self {
24        Self { items }
25    }
26
27    /// Appends one callback item.
28    pub fn record_item(&mut self, item: StreamItem) {
29        self.items.push(item);
30    }
31
32    /// Appends one packet with no explicit ticks.
33    pub fn record_packet(&mut self, packet: StreamPacket) {
34        self.record_item(StreamItem::new(packet));
35    }
36
37    /// Returns recorded callback items.
38    pub fn items(&self) -> &[StreamItem] {
39        &self.items
40    }
41
42    /// Converts a shared stream cassette into a callback cassette.
43    pub fn from_stream_cassette(cassette: &StreamCassette) -> Result<Self> {
44        Ok(Self {
45            items: cassette.items()?,
46        })
47    }
48
49    /// Converts recorded callbacks into the shared stream cassette format.
50    pub fn to_stream_cassette(
51        &self,
52        metadata: StreamMetadata,
53        profile: TransportProfile,
54    ) -> Result<StreamCassette> {
55        StreamCassette::from_items(
56            metadata,
57            self.items.clone(),
58            profile,
59            StreamStats {
60                pushed: self.items.len() as u64,
61                accepted: self.items.len() as u64,
62                ..StreamStats::default()
63            },
64        )
65    }
66
67    /// Replays every recorded item into a host callback queue.
68    pub fn replay(&self, queue: &HostCallbackQueue) -> Result<()> {
69        for item in &self.items {
70            queue.callback_item(item.clone())?;
71        }
72        Ok(())
73    }
74}