1use crate::{de::Decode, enc::Encode, impl_borrow_decode};
2use core::sync::atomic::Ordering;
3
4#[cfg(target_has_atomic = "ptr")]
5use core::sync::atomic::{AtomicIsize, AtomicUsize};
6
7#[cfg(target_has_atomic = "8")]
8use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};
9
10#[cfg(target_has_atomic = "16")]
11use core::sync::atomic::{AtomicI16, AtomicU16};
12
13#[cfg(target_has_atomic = "32")]
14use core::sync::atomic::{AtomicI32, AtomicU32};
15
16#[cfg(target_has_atomic = "64")]
17use core::sync::atomic::{AtomicI64, AtomicU64};
18
19#[cfg(target_has_atomic = "8")]
20impl Encode for AtomicBool {
21 fn encode<E: crate::enc::Encoder>(
22 &self,
23 encoder: &mut E,
24 ) -> Result<(), crate::error::EncodeError> {
25 self.load(Ordering::SeqCst).encode(encoder)
26 }
27}
28
29#[cfg(target_has_atomic = "8")]
30impl<Context> Decode<Context> for AtomicBool {
31 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
32 Ok(AtomicBool::new(Decode::decode(decoder)?))
33 }
34}
35#[cfg(target_has_atomic = "8")]
36impl_borrow_decode!(AtomicBool);
37
38#[cfg(target_has_atomic = "8")]
39impl Encode for AtomicU8 {
40 fn encode<E: crate::enc::Encoder>(
41 &self,
42 encoder: &mut E,
43 ) -> Result<(), crate::error::EncodeError> {
44 self.load(Ordering::SeqCst).encode(encoder)
45 }
46}
47
48#[cfg(target_has_atomic = "8")]
49impl<Context> Decode<Context> for AtomicU8 {
50 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
51 Ok(AtomicU8::new(Decode::decode(decoder)?))
52 }
53}
54#[cfg(target_has_atomic = "8")]
55impl_borrow_decode!(AtomicU8);
56
57#[cfg(target_has_atomic = "16")]
58impl Encode for AtomicU16 {
59 fn encode<E: crate::enc::Encoder>(
60 &self,
61 encoder: &mut E,
62 ) -> Result<(), crate::error::EncodeError> {
63 self.load(Ordering::SeqCst).encode(encoder)
64 }
65}
66
67#[cfg(target_has_atomic = "16")]
68impl<Context> Decode<Context> for AtomicU16 {
69 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
70 Ok(AtomicU16::new(Decode::decode(decoder)?))
71 }
72}
73#[cfg(target_has_atomic = "16")]
74impl_borrow_decode!(AtomicU16);
75
76#[cfg(target_has_atomic = "32")]
77impl Encode for AtomicU32 {
78 fn encode<E: crate::enc::Encoder>(
79 &self,
80 encoder: &mut E,
81 ) -> Result<(), crate::error::EncodeError> {
82 self.load(Ordering::SeqCst).encode(encoder)
83 }
84}
85
86#[cfg(target_has_atomic = "32")]
87impl<Context> Decode<Context> for AtomicU32 {
88 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
89 Ok(AtomicU32::new(Decode::decode(decoder)?))
90 }
91}
92#[cfg(target_has_atomic = "32")]
93impl_borrow_decode!(AtomicU32);
94
95#[cfg(target_has_atomic = "64")]
96impl Encode for AtomicU64 {
97 fn encode<E: crate::enc::Encoder>(
98 &self,
99 encoder: &mut E,
100 ) -> Result<(), crate::error::EncodeError> {
101 self.load(Ordering::SeqCst).encode(encoder)
102 }
103}
104
105#[cfg(target_has_atomic = "64")]
106impl<Context> Decode<Context> for AtomicU64 {
107 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
108 Ok(AtomicU64::new(Decode::decode(decoder)?))
109 }
110}
111#[cfg(target_has_atomic = "64")]
112impl_borrow_decode!(AtomicU64);
113
114#[cfg(target_has_atomic = "ptr")]
115impl Encode for AtomicUsize {
116 fn encode<E: crate::enc::Encoder>(
117 &self,
118 encoder: &mut E,
119 ) -> Result<(), crate::error::EncodeError> {
120 self.load(Ordering::SeqCst).encode(encoder)
121 }
122}
123
124#[cfg(target_has_atomic = "ptr")]
125impl<Context> Decode<Context> for AtomicUsize {
126 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
127 Ok(AtomicUsize::new(Decode::decode(decoder)?))
128 }
129}
130#[cfg(target_has_atomic = "ptr")]
131impl_borrow_decode!(AtomicUsize);
132
133#[cfg(target_has_atomic = "8")]
134impl Encode for AtomicI8 {
135 fn encode<E: crate::enc::Encoder>(
136 &self,
137 encoder: &mut E,
138 ) -> Result<(), crate::error::EncodeError> {
139 self.load(Ordering::SeqCst).encode(encoder)
140 }
141}
142
143#[cfg(target_has_atomic = "8")]
144impl<Context> Decode<Context> for AtomicI8 {
145 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
146 Ok(AtomicI8::new(Decode::decode(decoder)?))
147 }
148}
149#[cfg(target_has_atomic = "8")]
150impl_borrow_decode!(AtomicI8);
151
152#[cfg(target_has_atomic = "16")]
153impl Encode for AtomicI16 {
154 fn encode<E: crate::enc::Encoder>(
155 &self,
156 encoder: &mut E,
157 ) -> Result<(), crate::error::EncodeError> {
158 self.load(Ordering::SeqCst).encode(encoder)
159 }
160}
161
162#[cfg(target_has_atomic = "16")]
163impl<Context> Decode<Context> for AtomicI16 {
164 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
165 Ok(AtomicI16::new(Decode::decode(decoder)?))
166 }
167}
168#[cfg(target_has_atomic = "16")]
169impl_borrow_decode!(AtomicI16);
170
171#[cfg(target_has_atomic = "32")]
172impl Encode for AtomicI32 {
173 fn encode<E: crate::enc::Encoder>(
174 &self,
175 encoder: &mut E,
176 ) -> Result<(), crate::error::EncodeError> {
177 self.load(Ordering::SeqCst).encode(encoder)
178 }
179}
180
181#[cfg(target_has_atomic = "32")]
182impl<Context> Decode<Context> for AtomicI32 {
183 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
184 Ok(AtomicI32::new(Decode::decode(decoder)?))
185 }
186}
187#[cfg(target_has_atomic = "32")]
188impl_borrow_decode!(AtomicI32);
189
190#[cfg(target_has_atomic = "64")]
191impl Encode for AtomicI64 {
192 fn encode<E: crate::enc::Encoder>(
193 &self,
194 encoder: &mut E,
195 ) -> Result<(), crate::error::EncodeError> {
196 self.load(Ordering::SeqCst).encode(encoder)
197 }
198}
199
200#[cfg(target_has_atomic = "64")]
201impl<Context> Decode<Context> for AtomicI64 {
202 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
203 Ok(AtomicI64::new(Decode::decode(decoder)?))
204 }
205}
206#[cfg(target_has_atomic = "64")]
207impl_borrow_decode!(AtomicI64);
208
209#[cfg(target_has_atomic = "ptr")]
210impl Encode for AtomicIsize {
211 fn encode<E: crate::enc::Encoder>(
212 &self,
213 encoder: &mut E,
214 ) -> Result<(), crate::error::EncodeError> {
215 self.load(Ordering::SeqCst).encode(encoder)
216 }
217}
218
219#[cfg(target_has_atomic = "ptr")]
220impl<Context> Decode<Context> for AtomicIsize {
221 fn decode<D: crate::de::Decoder>(decoder: &mut D) -> Result<Self, crate::error::DecodeError> {
222 Ok(AtomicIsize::new(Decode::decode(decoder)?))
223 }
224}
225#[cfg(target_has_atomic = "ptr")]
226impl_borrow_decode!(AtomicIsize);
227
228#[cfg(target_has_atomic = "8")]
229impl<C> crate::DecodeUntrusted<C> for AtomicBool {
230 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
231 d: &mut D,
232 ) -> Result<Self, crate::error::DecodeError> {
233 <Self as crate::Decode<C>>::decode(d)
234 }
235}
236#[cfg(target_has_atomic = "8")]
237crate::impl_borrow_decode_untrusted!(AtomicBool);
238#[cfg(target_has_atomic = "8")]
239impl<C> crate::DecodeUntrusted<C> for AtomicU8 {
240 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
241 d: &mut D,
242 ) -> Result<Self, crate::error::DecodeError> {
243 <Self as crate::Decode<C>>::decode(d)
244 }
245}
246#[cfg(target_has_atomic = "8")]
247crate::impl_borrow_decode_untrusted!(AtomicU8);
248#[cfg(target_has_atomic = "16")]
249impl<C> crate::DecodeUntrusted<C> for AtomicU16 {
250 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
251 d: &mut D,
252 ) -> Result<Self, crate::error::DecodeError> {
253 <Self as crate::Decode<C>>::decode(d)
254 }
255}
256#[cfg(target_has_atomic = "16")]
257crate::impl_borrow_decode_untrusted!(AtomicU16);
258#[cfg(target_has_atomic = "32")]
259impl<C> crate::DecodeUntrusted<C> for AtomicU32 {
260 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
261 d: &mut D,
262 ) -> Result<Self, crate::error::DecodeError> {
263 <Self as crate::Decode<C>>::decode(d)
264 }
265}
266#[cfg(target_has_atomic = "32")]
267crate::impl_borrow_decode_untrusted!(AtomicU32);
268#[cfg(target_has_atomic = "64")]
269impl<C> crate::DecodeUntrusted<C> for AtomicU64 {
270 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
271 d: &mut D,
272 ) -> Result<Self, crate::error::DecodeError> {
273 <Self as crate::Decode<C>>::decode(d)
274 }
275}
276#[cfg(target_has_atomic = "64")]
277crate::impl_borrow_decode_untrusted!(AtomicU64);
278#[cfg(target_has_atomic = "ptr")]
279impl<C> crate::DecodeUntrusted<C> for AtomicUsize {
280 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
281 d: &mut D,
282 ) -> Result<Self, crate::error::DecodeError> {
283 <Self as crate::Decode<C>>::decode(d)
284 }
285}
286#[cfg(target_has_atomic = "ptr")]
287crate::impl_borrow_decode_untrusted!(AtomicUsize);
288#[cfg(target_has_atomic = "8")]
289impl<C> crate::DecodeUntrusted<C> for AtomicI8 {
290 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
291 d: &mut D,
292 ) -> Result<Self, crate::error::DecodeError> {
293 <Self as crate::Decode<C>>::decode(d)
294 }
295}
296#[cfg(target_has_atomic = "8")]
297crate::impl_borrow_decode_untrusted!(AtomicI8);
298#[cfg(target_has_atomic = "16")]
299impl<C> crate::DecodeUntrusted<C> for AtomicI16 {
300 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
301 d: &mut D,
302 ) -> Result<Self, crate::error::DecodeError> {
303 <Self as crate::Decode<C>>::decode(d)
304 }
305}
306#[cfg(target_has_atomic = "16")]
307crate::impl_borrow_decode_untrusted!(AtomicI16);
308#[cfg(target_has_atomic = "32")]
309impl<C> crate::DecodeUntrusted<C> for AtomicI32 {
310 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
311 d: &mut D,
312 ) -> Result<Self, crate::error::DecodeError> {
313 <Self as crate::Decode<C>>::decode(d)
314 }
315}
316#[cfg(target_has_atomic = "32")]
317crate::impl_borrow_decode_untrusted!(AtomicI32);
318#[cfg(target_has_atomic = "64")]
319impl<C> crate::DecodeUntrusted<C> for AtomicI64 {
320 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
321 d: &mut D,
322 ) -> Result<Self, crate::error::DecodeError> {
323 <Self as crate::Decode<C>>::decode(d)
324 }
325}
326#[cfg(target_has_atomic = "64")]
327crate::impl_borrow_decode_untrusted!(AtomicI64);
328#[cfg(target_has_atomic = "ptr")]
329impl<C> crate::DecodeUntrusted<C> for AtomicIsize {
330 fn decode_untrusted<D: crate::de::UntrustedDecoder<Context = C>>(
331 d: &mut D,
332 ) -> Result<Self, crate::error::DecodeError> {
333 <Self as crate::Decode<C>>::decode(d)
334 }
335}
336#[cfg(target_has_atomic = "ptr")]
337crate::impl_borrow_decode_untrusted!(AtomicIsize);