dfir_rs/scheduled/handoff/
tee.rs

1//! Module for teeing handoffs, not currently used much.
2
3use std::any::Any;
4use std::cell::RefCell;
5use std::collections::VecDeque;
6use std::rc::Rc;
7
8use super::{CanReceive, Handoff, HandoffMeta};
9
10struct ReaderHandoff<T> {
11    contents: VecDeque<Vec<T>>,
12}
13
14impl<T> Default for ReaderHandoff<T> {
15    fn default() -> Self {
16        Self {
17            contents: Default::default(),
18        }
19    }
20}
21
22struct TeeingHandoffInternal<T> {
23    /// (is alive, reader)
24    readers: Vec<(bool, ReaderHandoff<T>)>,
25}
26
27/// A [Handoff] which is part of a "family" of handoffs. Writing to this handoff
28/// will write to every reader. New readers can be created by calling `tee`.
29#[derive(Clone)]
30pub struct TeeingHandoff<T>
31where
32    T: 'static,
33{
34    read_from: usize,
35    internal: Rc<RefCell<TeeingHandoffInternal<T>>>,
36}
37
38impl<T> Default for TeeingHandoff<T> {
39    fn default() -> Self {
40        TeeingHandoff {
41            read_from: 0,
42            internal: Rc::new(RefCell::new(TeeingHandoffInternal {
43                readers: vec![(true, ReaderHandoff::<T>::default())],
44            })),
45        }
46    }
47}
48
49impl<T> TeeingHandoff<T>
50where
51    T: Clone,
52{
53    /// Tee the internal shared datastructure to create a new tee output.
54    #[must_use]
55    pub(crate) fn tee(&self) -> Self {
56        let id = (*self.internal).borrow().readers.len();
57        (*self.internal)
58            .borrow_mut()
59            .readers
60            .push((true, ReaderHandoff::default()));
61        Self {
62            read_from: id,
63            internal: self.internal.clone(),
64        }
65    }
66
67    /// Mark this particular teeing handoff output as dead, so no more data will be written to it.
68    pub(crate) fn drop(&self) {
69        self.internal.borrow_mut().readers[self.read_from].0 = false;
70    }
71}
72
73impl<T> HandoffMeta for TeeingHandoff<T> {
74    fn any_ref(&self) -> &dyn Any {
75        self
76    }
77
78    /// If this output's buffer is empty, return true.
79    fn is_bottom(&self) -> bool {
80        self.internal.borrow().readers[self.read_from]
81            .1
82            .contents
83            .iter()
84            .all(Vec::is_empty)
85    }
86}
87
88impl<T> Handoff for TeeingHandoff<T> {
89    type Inner = VecDeque<Vec<T>>;
90
91    fn take_inner(&self) -> Self::Inner {
92        std::mem::take(
93            &mut (*self.internal).borrow_mut().readers[self.read_from]
94                .1
95                .contents,
96        )
97    }
98
99    fn borrow_mut_swap(&self) -> std::cell::RefMut<Self::Inner> {
100        todo!()
101    }
102}
103
104impl<T> CanReceive<Vec<T>> for TeeingHandoff<T>
105where
106    T: Clone,
107{
108    fn give(&self, vec: Vec<T>) -> Vec<T> {
109        let readers = &mut (*self.internal).borrow_mut().readers;
110        if let Some((last, rest)) = readers.split_last_mut() {
111            for reader in rest {
112                if reader.0 {
113                    reader.1.contents.push_back(vec.clone());
114                }
115            }
116            if last.0 {
117                last.1.contents.push_back(vec);
118            }
119        }
120        Vec::new()
121    }
122}