embedded_svc/
ws.rs

1use core::fmt::Debug;
2
3pub trait ErrorType {
4    type Error: Debug;
5}
6
7impl<E> ErrorType for &E
8where
9    E: ErrorType,
10{
11    type Error = E::Error;
12}
13
14impl<E> ErrorType for &mut E
15where
16    E: ErrorType,
17{
18    type Error = E::Error;
19}
20
21pub type Fragmented = bool;
22pub type Final = bool;
23
24#[derive(Copy, Clone, PartialEq, Eq, Debug)]
25#[cfg_attr(feature = "defmt", derive(defmt::Format))]
26pub enum FrameType {
27    Text(Fragmented),
28    Binary(Fragmented),
29    Ping,
30    Pong,
31    Close,
32    SocketClose,
33    Continue(Final),
34}
35
36impl FrameType {
37    pub fn is_fragmented(&self) -> bool {
38        match self {
39            Self::Text(fragmented) | Self::Binary(fragmented) => *fragmented,
40            Self::Continue(_) => true,
41            _ => false,
42        }
43    }
44
45    pub fn is_final(&self) -> bool {
46        match self {
47            Self::Text(fragmented) | Self::Binary(fragmented) => !*fragmented,
48            Self::Continue(final_) => *final_,
49            _ => true,
50        }
51    }
52}
53
54pub trait Receiver: ErrorType {
55    fn recv(&mut self, frame_data_buf: &mut [u8]) -> Result<(FrameType, usize), Self::Error>;
56}
57
58impl<R> Receiver for &mut R
59where
60    R: Receiver,
61{
62    fn recv(&mut self, frame_data_buf: &mut [u8]) -> Result<(FrameType, usize), Self::Error> {
63        (*self).recv(frame_data_buf)
64    }
65}
66
67pub trait Sender: ErrorType {
68    fn send(&mut self, frame_type: FrameType, frame_data: &[u8]) -> Result<(), Self::Error>;
69}
70
71impl<S> Sender for &mut S
72where
73    S: Sender,
74{
75    fn send(&mut self, frame_type: FrameType, frame_data: &[u8]) -> Result<(), Self::Error> {
76        (*self).send(frame_type, frame_data)
77    }
78}
79
80pub mod server {
81    pub use super::*;
82
83    pub trait Acceptor: ErrorType {
84        type Connection<'a>: Sender<Error = Self::Error> + Receiver<Error = Self::Error>
85        where
86            Self: 'a;
87
88        fn accept(&self) -> Result<Self::Connection<'_>, Self::Error>;
89    }
90
91    impl<A> Acceptor for &A
92    where
93        A: Acceptor,
94    {
95        type Connection<'a>
96            = A::Connection<'a>
97        where
98            Self: 'a;
99
100        fn accept(&self) -> Result<Self::Connection<'_>, Self::Error> {
101            (*self).accept()
102        }
103    }
104
105    impl<A> Acceptor for &mut A
106    where
107        A: Acceptor,
108    {
109        type Connection<'a>
110            = A::Connection<'a>
111        where
112            Self: 'a;
113
114        fn accept(&self) -> Result<Self::Connection<'_>, Self::Error> {
115            (**self).accept()
116        }
117    }
118}
119
120pub mod asynch {
121    pub use super::{ErrorType, Fragmented, FrameType};
122
123    pub trait Receiver: ErrorType {
124        async fn recv(
125            &mut self,
126            frame_data_buf: &mut [u8],
127        ) -> Result<(FrameType, usize), Self::Error>;
128    }
129
130    impl<R> Receiver for &mut R
131    where
132        R: Receiver,
133    {
134        async fn recv(
135            &mut self,
136            frame_data_buf: &mut [u8],
137        ) -> Result<(FrameType, usize), Self::Error> {
138            (*self).recv(frame_data_buf).await
139        }
140    }
141
142    pub trait Sender: ErrorType {
143        async fn send(
144            &mut self,
145            frame_type: FrameType,
146            frame_data: &[u8],
147        ) -> Result<(), Self::Error>;
148    }
149
150    impl<S> Sender for &mut S
151    where
152        S: Sender,
153    {
154        async fn send(
155            &mut self,
156            frame_type: FrameType,
157            frame_data: &[u8],
158        ) -> Result<(), Self::Error> {
159            (*self).send(frame_type, frame_data).await
160        }
161    }
162
163    pub mod server {
164        pub use super::*;
165
166        pub trait Acceptor: ErrorType {
167            type Sender<'a>: Sender<Error = Self::Error>
168            where
169                Self: 'a;
170            type Receiver<'a>: Receiver<Error = Self::Error>
171            where
172                Self: 'a;
173
174            async fn accept(&self) -> Result<(Self::Sender<'_>, Self::Receiver<'_>), Self::Error>;
175        }
176
177        impl<A> Acceptor for &A
178        where
179            A: Acceptor,
180        {
181            type Sender<'a>
182                = A::Sender<'a>
183            where
184                Self: 'a;
185            type Receiver<'a>
186                = A::Receiver<'a>
187            where
188                Self: 'a;
189
190            async fn accept(&self) -> Result<(Self::Sender<'_>, Self::Receiver<'_>), Self::Error> {
191                (*self).accept().await
192            }
193        }
194
195        impl<A> Acceptor for &mut A
196        where
197            A: Acceptor,
198        {
199            type Sender<'a>
200                = A::Sender<'a>
201            where
202                Self: 'a;
203            type Receiver<'a>
204                = A::Receiver<'a>
205            where
206                Self: 'a;
207
208            async fn accept(&self) -> Result<(Self::Sender<'_>, Self::Receiver<'_>), Self::Error> {
209                (**self).accept().await
210            }
211        }
212    }
213}
embedded_svc/ws.rs

embedded_svc/
ws.rs
