1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
use std::sync::{Arc, Mutex};
use crate::concurrent::{agent_runner::Agent, logbuffer::term_reader::ErrorHandler};
pub struct AgentInvoker<T: Agent> {
agent: Arc<Mutex<T>>,
exception_handler: ErrorHandler,
is_started: bool,
is_running: bool,
is_closed: bool,
}
impl<T: Agent> AgentInvoker<T> {
pub fn new(agent: Arc<Mutex<T>>, exception_handler: ErrorHandler) -> Self {
Self {
agent,
exception_handler,
is_started: false,
is_running: false,
is_closed: false,
}
}
pub fn is_started(&self) -> bool {
self.is_started
}
pub fn is_running(&self) -> bool {
self.is_running
}
pub fn is_closed(&self) -> bool {
self.is_closed
}
pub fn start(&mut self) {
if !self.is_started {
self.is_started = true;
let on_start_result = self.agent.lock().expect("Mutex poisoned").on_start();
if let Err(error) = on_start_result {
(self.exception_handler)(error);
self.close();
} else {
self.is_running = true;
}
}
}
pub fn invoke(&self) -> i32 {
let mut work_count = 0;
if self.is_running {
match self.agent.lock().expect("Mutex poisoned").do_work() {
Err(error) => (self.exception_handler)(error),
Ok(wrk_cnt) => work_count = wrk_cnt,
}
}
work_count
}
pub fn close(&mut self) {
if !self.is_closed {
self.is_running = false;
self.is_closed = true;
if let Err(error) = self.agent.lock().expect("Mutex poisoned").on_close() {
(self.exception_handler)(error);
}
}
}
}