esp_wifi/
fmt.rs

1#![macro_use]
2#![allow(unused_macros)]
3
4#[collapse_debuginfo(yes)]
5macro_rules! assert {
6    ($($x:tt)*) => {
7        {
8            cfg_if::cfg_if! {
9                if #[cfg(feature = "defmt")] {
10                    ::defmt::assert!($($x)*);
11                } else {
12                    ::core::assert!($($x)*);
13                }
14            }
15        }
16    };
17}
18
19#[collapse_debuginfo(yes)]
20macro_rules! assert_eq {
21    ($($x:tt)*) => {
22        {
23            cfg_if::cfg_if! {
24                if #[cfg(feature = "defmt")] {
25                    ::defmt::assert_eq!($($x)*);
26                } else {
27                    ::core::assert_eq!($($x)*);
28                }
29            }
30        }
31    };
32}
33
34#[collapse_debuginfo(yes)]
35macro_rules! assert_ne {
36    ($($x:tt)*) => {
37        {
38            cfg_if::cfg_if! {
39                if #[cfg(feature = "defmt")] {
40                    ::defmt::assert_ne!($($x)*);
41                } else {
42                    ::core::assert_ne!($($x)*);
43                }
44            }
45        }
46    };
47}
48
49#[collapse_debuginfo(yes)]
50macro_rules! debug_assert {
51    ($($x:tt)*) => {
52        {
53            cfg_if::cfg_if! {
54                if #[cfg(feature = "defmt")] {
55                    ::defmt::debug_assert!($($x)*);
56                } else {
57                    ::core::debug_assert!($($x)*);
58                }
59            }
60        }
61    };
62}
63
64#[collapse_debuginfo(yes)]
65macro_rules! debug_assert_eq {
66    ($($x:tt)*) => {
67        {
68            cfg_if::cfg_if! {
69                if #[cfg(feature = "defmt")] {
70                    ::defmt::debug_assert_eq!($($x)*);
71                } else {
72                    ::core::debug_assert_eq!($($x)*);
73                }
74            }
75        }
76    };
77}
78
79#[collapse_debuginfo(yes)]
80macro_rules! debug_assert_ne {
81    ($($x:tt)*) => {
82        {
83            cfg_if::cfg_if! {
84                if #[cfg(feature = "defmt")] {
85                    ::defmt::debug_assert_ne!($($x)*);
86                } else {
87                    ::core::debug_assert_ne!($($x)*);
88                }
89            }
90        }
91    };
92}
93
94#[collapse_debuginfo(yes)]
95macro_rules! todo {
96    ($($x:tt)*) => {
97        {
98            cfg_if::cfg_if! {
99                if #[cfg(feature = "defmt")] {
100                    ::defmt::todo!($($x)*);
101                } else {
102                    ::core::todo!($($x)*);
103                }
104            }
105        }
106    };
107}
108
109#[collapse_debuginfo(yes)]
110macro_rules! unreachable {
111    ($($x:tt)*) => {
112        {
113            cfg_if::cfg_if! {
114                if #[cfg(feature = "defmt")] {
115                    ::defmt::unreachable!($($x)*);
116                } else {
117                    ::core::unreachable!($($x)*);
118                }
119            }
120        }
121    };
122}
123
124#[collapse_debuginfo(yes)]
125macro_rules! panic {
126    ($($x:tt)*) => {
127        {
128            cfg_if::cfg_if! {
129                if #[cfg(feature = "defmt")] {
130                    ::defmt::panic!($($x)*);
131                } else {
132                    ::core::panic!($($x)*);
133                }
134            }
135        }
136    };
137}
138
139#[collapse_debuginfo(yes)]
140macro_rules! trace {
141    ($s:literal $(, $x:expr)* $(,)?) => {
142        {
143            cfg_if::cfg_if! {
144                if #[cfg(feature = "defmt")] {
145                    ::defmt::trace!($s $(, $x)*);
146                } else if #[cfg(feature = "log-04")] {
147                    ::log_04::trace!($s $(, $x)*);
148                } else {
149                    let _ = ($( & $x ),*);
150                }
151            }
152        }
153    };
154}
155
156#[collapse_debuginfo(yes)]
157macro_rules! debug {
158    ($s:literal $(, $x:expr)* $(,)?) => {
159        {
160            cfg_if::cfg_if! {
161                if #[cfg(feature = "defmt")] {
162                    ::defmt::debug!($s $(, $x)*);
163                } else if #[cfg(feature = "log-04")] {
164                    ::log_04::debug!($s $(, $x)*);
165                } else {
166                    let _ = ($( & $x ),*);
167                }
168            }
169        }
170    };
171}
172
173#[collapse_debuginfo(yes)]
174macro_rules! info {
175    ($s:literal $(, $x:expr)* $(,)?) => {
176        {
177            cfg_if::cfg_if! {
178                if #[cfg(feature = "defmt")] {
179                    ::defmt::info!($s $(, $x)*);
180                } else if #[cfg(feature = "log-04")] {
181                    ::log_04::info!($s $(, $x)*);
182                } else {
183                    let _ = ($( & $x ),*);
184                }
185            }
186        }
187    };
188}
189
190#[collapse_debuginfo(yes)]
191macro_rules! warn {
192    ($s:literal $(, $x:expr)* $(,)?) => {
193        {
194            cfg_if::cfg_if! {
195                if #[cfg(feature = "defmt")] {
196                    ::defmt::warn!($s $(, $x)*);
197                } else if #[cfg(feature = "log-04")] {
198                    ::log_04::warn!($s $(, $x)*);
199                } else {
200                    let _ = ($( & $x ),*);
201                }
202            }
203        }
204    };
205}
206
207#[collapse_debuginfo(yes)]
208macro_rules! error {
209    ($s:literal $(, $x:expr)* $(,)?) => {
210        {
211            cfg_if::cfg_if! {
212                if #[cfg(feature = "defmt")] {
213                    ::defmt::error!($s $(, $x)*);
214                } else if #[cfg(feature = "log-04")] {
215                    ::log_04::error!($s $(, $x)*);
216                } else {
217                    let _ = ($( & $x ),*);
218                }
219            }
220        }
221    };
222}
223
224#[cfg(feature = "defmt")]
225#[collapse_debuginfo(yes)]
226macro_rules! unwrap {
227    ($($x:tt)*) => {
228        ::defmt::unwrap!($($x)*)
229    };
230}
231
232#[cfg(not(feature = "defmt"))]
233#[collapse_debuginfo(yes)]
234macro_rules! unwrap {
235    ($arg:expr) => {
236        match $crate::fmt::Try::into_result($arg) {
237            ::core::result::Result::Ok(t) => t,
238            ::core::result::Result::Err(e) => {
239                ::core::panic!("unwrap of `{}` failed: {:?}", ::core::stringify!($arg), e);
240            }
241        }
242    };
243    ($arg:expr, $($msg:expr),+ $(,)? ) => {
244        match $crate::fmt::Try::into_result($arg) {
245            ::core::result::Result::Ok(t) => t,
246            ::core::result::Result::Err(e) => {
247                ::core::panic!("unwrap of `{}` failed: {}: {:?}", ::core::stringify!($arg), ::core::format_args!($($msg,)*), e);
248            }
249        }
250    }
251}
252
253#[derive(Debug, Copy, Clone, Eq, PartialEq)]
254pub struct NoneError;
255
256pub trait Try {
257    type Ok;
258    type Error;
259    #[allow(unused)]
260    fn into_result(self) -> Result<Self::Ok, Self::Error>;
261}
262
263impl<T> Try for Option<T> {
264    type Ok = T;
265    type Error = NoneError;
266
267    #[inline]
268    fn into_result(self) -> Result<T, NoneError> {
269        self.ok_or(NoneError)
270    }
271}
272
273impl<T, E> Try for Result<T, E> {
274    type Ok = T;
275    type Error = E;
276
277    #[inline]
278    fn into_result(self) -> Self {
279        self
280    }
281}