ross_protocol/
protocol.rs

1#![allow(mutable_transmutes)]
2use alloc::boxed::Box;
3use alloc::collections::BTreeMap;
4use alloc::vec;
5use alloc::vec::Vec;
6use core::mem::transmute;
7
8use crate::convert_packet::ConvertPacket;
9use crate::interface::*;
10use crate::packet::Packet;
11
12pub const BROADCAST_ADDRESS: u16 = 0xffff;
13
14#[derive(Debug)]
15pub enum ProtocolError {
16    InterfaceError(InterfaceError),
17    NoSuchHandler,
18    PacketTimeout,
19}
20
21pub struct Protocol<'a> {
22    device_address: u16,
23    interface: Box<dyn Interface>,
24    #[cfg(not(feature = "send"))]
25    handlers: BTreeMap<u32, (Box<dyn FnMut(&Packet, &mut Self) + 'a>, bool)>,
26    #[cfg(feature = "send")]
27    handlers: BTreeMap<u32, (Box<dyn FnMut(&Packet, &mut Self) + Send + 'a>, bool)>,
28}
29
30impl<'a> Protocol<'a> {
31    pub fn new(device_address: u16, interface: Box<dyn Interface>) -> Self {
32        Protocol {
33            device_address,
34            interface,
35            handlers: BTreeMap::new(),
36        }
37    }
38
39    pub fn tick(&mut self) -> Result<(), ProtocolError> {
40        match self.interface.try_get_packet() {
41            Ok(packet) => {
42                if packet.device_address == self.device_address
43                    || packet.device_address == BROADCAST_ADDRESS
44                {
45                    self.handle_packet(&packet, true);
46                } else {
47                    self.handle_packet(&packet, false);
48                }
49
50                Ok(())
51            }
52            Err(err) => match err {
53                InterfaceError::NoPacketReceived => Ok(()),
54                _ => Err(ProtocolError::InterfaceError(err)),
55            },
56        }
57    }
58
59    pub fn send_packet(&mut self, packet: &Packet) -> Result<(), ProtocolError> {
60        if packet.device_address == self.device_address {
61            self.handle_packet(&packet, true);
62
63            if self.device_address != BROADCAST_ADDRESS {
64                return Ok(());
65            }
66        }
67
68        match self.interface.try_send_packet(packet) {
69            Ok(_) => Ok(()),
70            Err(err) => Err(ProtocolError::InterfaceError(err)),
71        }
72    }
73
74    pub fn add_packet_handler<'s>(
75        &'s mut self,
76        #[cfg(not(feature = "send"))] handler: Box<dyn FnMut(&Packet, &mut Self) + 'a>,
77        #[cfg(feature = "send")] handler: Box<dyn FnMut(&Packet, &mut Self) + Send + 'a>,
78        capture_all_addresses: bool,
79    ) -> Result<u32, ProtocolError> {
80        let id = self.get_next_handler_id();
81
82        self.handlers.insert(id, (handler, capture_all_addresses));
83
84        Ok(id)
85    }
86
87    pub fn remove_packet_handler(&mut self, id: u32) -> Result<(), ProtocolError> {
88        match self.handlers.remove(&id) {
89            None => Err(ProtocolError::NoSuchHandler),
90            Some(_) => Ok(()),
91        }
92    }
93
94    pub fn exchange_packet<F: Fn(), R: ConvertPacket<R>>(
95        &mut self,
96        packet: Packet,
97        capture_all_addresses: bool,
98        wait_closure: F,
99    ) -> Result<R, ProtocolError> {
100        self.send_packet(&packet)?;
101
102        wait_closure();
103
104        loop {
105            match self.interface.try_get_packet() {
106                Ok(received_packet) => {
107                    if capture_all_addresses
108                        || received_packet.device_address == self.device_address
109                        || received_packet.device_address == BROADCAST_ADDRESS
110                    {
111                        if let Ok(received_event) = R::try_from_packet(&received_packet) {
112                            return Ok(received_event);
113                        }
114                    }
115                }
116                Err(err) => match err {
117                    InterfaceError::NoPacketReceived => break,
118                    _ => return Err(ProtocolError::InterfaceError(err)),
119                },
120            }
121        }
122
123        Err(ProtocolError::PacketTimeout)
124    }
125
126    pub fn exchange_packets<F: Fn(), R: ConvertPacket<R>>(
127        &mut self,
128        packet: Packet,
129        capture_all_addresses: bool,
130        wait_closure: F,
131    ) -> Result<Vec<R>, ProtocolError> {
132        let mut events = vec![];
133
134        self.send_packet(&packet)?;
135
136        wait_closure();
137
138        loop {
139            match self.interface.try_get_packet() {
140                Ok(received_packet) => {
141                    if capture_all_addresses
142                        || received_packet.device_address == self.device_address
143                        || received_packet.device_address == BROADCAST_ADDRESS
144                    {
145                        if let Ok(received_event) = R::try_from_packet(&received_packet) {
146                            events.push(received_event);
147                        }
148                    }
149                }
150                Err(err) => match err {
151                    InterfaceError::NoPacketReceived => break,
152                    _ => return Err(ProtocolError::InterfaceError(err)),
153                },
154            }
155        }
156
157        return Ok(events);
158    }
159
160    fn handle_packet(&self, packet: &Packet, owned_address: bool) {
161        unsafe {
162            for handler in transmute::<&Self, &mut Self>(self).handlers.values_mut() {
163                if owned_address || handler.1 {
164                    handler.0(packet, transmute(self));
165                }
166            }
167        }
168    }
169
170    fn get_next_handler_id(&self) -> u32 {
171        let mut first_available_id = 0;
172
173        for id in self.handlers.keys() {
174            if first_available_id == *id {
175                first_available_id += 1;
176            }
177        }
178
179        return first_available_id;
180    }
181}
ross_protocol/protocol.rs

ross_protocol/
protocol.rs
