buffer_trigger/buffer_trigger_sync/
simple.rs

1use super::{
2    general::{self, General},
3    BufferTrigger,
4};
5use lifetime_thread::Outer;
6use std::{fmt, mem, time::Duration};
7#[derive(Debug)]
8struct Payload<C>
9where
10    C: fmt::Debug + Send,
11{
12    len: usize,
13    container: C,
14    defalut_container: fn() -> C,
15}
16
17pub struct Simple<E, C>
18where
19    E: fmt::Debug + Send + 'static,
20    C: fmt::Debug + Send + 'static,
21{
22    general: Outer<General<E, C, Payload<C>>>,
23}
24
25impl<E, C> BufferTrigger<E> for Simple<E, C>
26where
27    E: fmt::Debug + Send,
28    C: fmt::Debug + Send,
29{
30    fn is_empty(&self) -> bool {
31        self.general.is_empty()
32    }
33    fn len(&self) -> usize {
34        self.general.len()
35    }
36    fn push(&self, value: E) {
37        self.general.push(value)
38    }
39    fn trigger(&self) {
40        self.general.trigger()
41    }
42    // fn listen_clock_trigger(&self) {
43    //     self.general.listen_clock_trigger()
44    // }
45}
46
47pub struct Builder<E, C>
48where
49    E: fmt::Debug,
50    C: fmt::Debug,
51{
52    name: String,
53    defalut_container: fn() -> C,
54    accumulator: fn(&mut C, E),
55    consumer: fn(C),
56    max_len: usize,
57    interval: Option<Duration>,
58}
59
60impl<E, C> fmt::Debug for Builder<E, C>
61where
62    E: fmt::Debug,
63    C: fmt::Debug,
64{
65    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
66        write!(f, "name {}", self.name)
67    }
68}
69
70impl<E, C> Builder<E, C>
71where
72    E: fmt::Debug + Send,
73    C: fmt::Debug + Send,
74{
75    /// init
76    pub fn builder(defalut_container: fn() -> C) -> Self {
77        Self {
78            name: "anonymous".to_owned(),
79            defalut_container,
80            accumulator: |_, _| {},
81            consumer: |_| {},
82            max_len: std::usize::MAX,
83            interval: None,
84        }
85    }
86
87    /// set `name`
88    #[must_use]
89    pub fn name(mut self, name: String) -> Self {
90        self.name = name;
91        self
92    }
93
94    /// set `accumulator`
95    pub fn accumulator(mut self, accumulator: fn(&mut C, E)) -> Self {
96        self.accumulator = accumulator;
97        self
98    }
99
100    /// set `consumer`
101    pub fn consumer(mut self, consumer: fn(C)) -> Self {
102        self.consumer = consumer;
103        self
104    }
105
106    /// set `max_len`
107    #[must_use]
108    pub fn max_len(mut self, max_len: usize) -> Self {
109        self.max_len = max_len;
110        self
111    }
112
113    /// set `interval`
114    #[must_use]
115    pub fn interval(mut self, interval: Duration) -> Self {
116        self.interval = Some(interval);
117        self
118    }
119
120    /// `build`
121    #[must_use]
122    pub fn build(self) -> Simple<E, C> {
123        let payload = Payload {
124            container: (self.defalut_container)(),
125            defalut_container: self.defalut_container,
126            len: 0,
127        };
128
129        let mut general = general::builder::Builder::builder();
130        if let Some(t) = self.interval {
131            general = general.interval(t);
132        }
133        let general = general
134            .consumer(self.consumer)
135            .max_len(self.max_len)
136            .payload(payload)
137            .get_len(|p| p.as_ref().unwrap().len)
138            .incr_len(|p| p.as_mut().unwrap().len += 1)
139            .clear_len(|p| p.as_mut().unwrap().len = 0)
140            .get_container(|p| &mut p.as_mut().unwrap().container)
141            .get_and_clear_container(|p| {
142                let mut new_container = (p.as_ref().unwrap().defalut_container)();
143                mem::swap(&mut new_container, &mut p.as_mut().unwrap().container);
144                new_container
145            })
146            .accumulator(self.accumulator)
147            .build();
148
149        Simple { general }
150    }
151}
buffer_trigger/buffer_trigger_sync/simple.rs

buffer_trigger/buffer_trigger_sync/
simple.rs
