1#[cfg(feature = "alloc")]
2#[cfg_attr(doc_cfg, doc(cfg(feature = "alloc")))]
3mod alloc;
4#[cfg(feature = "std")]
5#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
6mod net;
7mod range;
8mod tuples;
9
10use core::ffi::CStr;
11use core::num::{
12 NonZeroI128, NonZeroI16, NonZeroI32, NonZeroI64, NonZeroI8, NonZeroIsize, NonZeroU128,
13 NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize, Wrapping,
14};
15use core::{fmt, marker};
16
17use crate::de::{
18 Decode, DecodeBytes, DecodePacked, DecodeUnsized, DecodeUnsizedBytes, Decoder, SequenceDecoder,
19 UnsizedVisitor, VariantDecoder,
20};
21use crate::en::{Encode, EncodeBytes, EncodePacked, Encoder, SequenceEncoder, VariantEncoder};
22use crate::hint::SequenceHint;
23use crate::Context;
24
25#[cfg(feature = "std")]
27#[derive(Encode, Decode)]
28#[musli(crate)]
29enum PlatformTag {
30 Unix,
31 Windows,
32}
33
34impl<M> Encode<M> for () {
35 #[inline]
36 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
37 where
38 E: Encoder,
39 {
40 encoder.encode_empty()
41 }
42}
43
44impl<'de, M> Decode<'de, M> for () {
45 #[inline]
46 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
47 where
48 D: Decoder<'de>,
49 {
50 decoder.decode_empty()
51 }
52}
53
54impl<T, M> Encode<M> for marker::PhantomData<T> {
55 #[inline]
56 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
57 where
58 E: Encoder,
59 {
60 encoder.encode_empty()
61 }
62}
63
64impl<'de, M, T> Decode<'de, M> for marker::PhantomData<T> {
65 #[inline]
66 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
67 where
68 D: Decoder<'de>,
69 {
70 decoder.decode_empty()?;
71 Ok(marker::PhantomData)
72 }
73}
74
75macro_rules! atomic_impl {
76 ($size:literal $(, $ty:ident)*) => {
77 $(
78 #[cfg(target_has_atomic = $size)]
79 impl<'de, M> Decode<'de, M> for core::sync::atomic::$ty {
80 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
81 where
82 D: Decoder<'de>,
83 {
84 decoder.decode().map(Self::new)
85 }
86 }
87 )*
88 };
89}
90
91atomic_impl!("8", AtomicBool, AtomicI8, AtomicU8);
92atomic_impl!("16", AtomicI16, AtomicU16);
93atomic_impl!("32", AtomicI32, AtomicU32);
94atomic_impl!("64", AtomicI64, AtomicU64);
95atomic_impl!("ptr", AtomicIsize, AtomicUsize);
96
97macro_rules! non_zero {
98 ($ty:ty) => {
99 impl<M> Encode<M> for $ty {
100 #[inline]
101 fn encode<E>(&self, cx: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
102 where
103 E: Encoder,
104 {
105 self.get().encode(cx, encoder)
106 }
107 }
108
109 impl<'de, M> Decode<'de, M> for $ty {
110 fn decode<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
111 where
112 D: Decoder<'de>,
113 {
114 let value = decoder.decode()?;
115
116 match Self::new(value) {
117 Some(value) => Ok(value),
118 None => Err(cx.message(NonZeroUnsupportedValue {
119 type_name: stringify!($ty),
120 value,
121 })),
122 }
123 }
124 }
125 };
126}
127
128non_zero!(NonZeroI128);
129non_zero!(NonZeroI16);
130non_zero!(NonZeroI32);
131non_zero!(NonZeroI64);
132non_zero!(NonZeroI8);
133non_zero!(NonZeroIsize);
134non_zero!(NonZeroU128);
135non_zero!(NonZeroU16);
136non_zero!(NonZeroU32);
137non_zero!(NonZeroU64);
138non_zero!(NonZeroU8);
139non_zero!(NonZeroUsize);
140
141struct NonZeroUnsupportedValue<T> {
142 type_name: &'static str,
143 value: T,
144}
145
146impl<T> fmt::Display for NonZeroUnsupportedValue<T>
147where
148 T: fmt::Display,
149{
150 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
151 write!(
152 f,
153 "{}: unsupported non-zero value `{}`",
154 self.type_name, self.value
155 )
156 }
157}
158
159impl<M, T, const N: usize> Encode<M> for [T; N]
160where
161 T: Encode<M>,
162{
163 #[inline]
164 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
165 where
166 E: Encoder<Mode = M>,
167 {
168 let hint = SequenceHint::with_size(N);
169
170 encoder.encode_sequence_fn(&hint, |seq| {
171 for value in self.iter() {
172 seq.push(value)?;
173 }
174
175 Ok(())
176 })
177 }
178}
179
180impl<'de, M, T, const N: usize> Decode<'de, M> for [T; N]
181where
182 T: Decode<'de, M>,
183{
184 #[inline]
185 fn decode<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
186 where
187 D: Decoder<'de, Mode = M>,
188 {
189 let mark = cx.mark();
190
191 decoder.decode_sequence(|seq| {
192 let mut array = crate::internal::FixedVec::new();
193
194 while let Some(item) = seq.try_decode_next()? {
195 array.try_push(item.decode()?).map_err(cx.map())?;
196 }
197
198 if array.len() != N {
199 return Err(cx.marked_message(
200 mark,
201 format_args!(
202 "Array with length {} does not have the expected {N} number of elements",
203 array.len()
204 ),
205 ));
206 }
207
208 Ok(array.into_inner())
209 })
210 }
211}
212
213impl<M, T, const N: usize> EncodePacked<M> for [T; N]
214where
215 T: Encode<M>,
216{
217 #[inline]
218 fn encode_packed<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
219 where
220 E: Encoder<Mode = M>,
221 {
222 encoder.encode_pack_fn(|seq| {
223 for value in self.iter() {
224 seq.push(value)?;
225 }
226
227 Ok(())
228 })
229 }
230}
231
232impl<'de, M, T, const N: usize> DecodePacked<'de, M> for [T; N]
233where
234 T: Decode<'de, M>,
235{
236 #[inline]
237 fn decode_packed<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
238 where
239 D: Decoder<'de, Mode = M>,
240 {
241 decoder.decode_pack(|pack| {
242 let mut array = crate::internal::FixedVec::new();
243
244 while array.len() < N {
245 let item = pack.decode_next()?;
246 array.try_push(item.decode()?).map_err(cx.map())?;
247 }
248
249 Ok(array.into_inner())
250 })
251 }
252}
253
254macro_rules! impl_number {
255 ($ty:ty, $read:ident, $write:ident) => {
256 impl<M> Encode<M> for $ty {
257 #[inline]
258 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
259 where
260 E: Encoder,
261 {
262 encoder.$write(*self)
263 }
264 }
265
266 impl<'de, M> Decode<'de, M> for $ty {
267 #[inline]
268 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
269 where
270 D: Decoder<'de>,
271 {
272 decoder.$read()
273 }
274 }
275 };
276}
277
278impl<M> Encode<M> for bool {
279 #[inline]
280 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
281 where
282 E: Encoder,
283 {
284 encoder.encode_bool(*self)
285 }
286}
287
288impl<'de, M> Decode<'de, M> for bool {
289 #[inline]
290 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
291 where
292 D: Decoder<'de>,
293 {
294 decoder.decode_bool()
295 }
296}
297
298impl<M> Encode<M> for char {
299 #[inline]
300 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
301 where
302 E: Encoder,
303 {
304 encoder.encode_char(*self)
305 }
306}
307
308impl<'de, M> Decode<'de, M> for char {
309 #[inline]
310 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
311 where
312 D: Decoder<'de>,
313 {
314 decoder.decode_char()
315 }
316}
317
318impl_number!(usize, decode_usize, encode_usize);
319impl_number!(isize, decode_isize, encode_isize);
320impl_number!(u8, decode_u8, encode_u8);
321impl_number!(u16, decode_u16, encode_u16);
322impl_number!(u32, decode_u32, encode_u32);
323impl_number!(u64, decode_u64, encode_u64);
324impl_number!(u128, decode_u128, encode_u128);
325impl_number!(i8, decode_i8, encode_i8);
326impl_number!(i16, decode_i16, encode_i16);
327impl_number!(i32, decode_i32, encode_i32);
328impl_number!(i64, decode_i64, encode_i64);
329impl_number!(i128, decode_i128, encode_i128);
330impl_number!(f32, decode_f32, encode_f32);
331impl_number!(f64, decode_f64, encode_f64);
332
333impl<M> Encode<M> for str {
334 #[inline]
335 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
336 where
337 E: Encoder,
338 {
339 encoder.encode_string(self)
340 }
341}
342
343impl<'de, M> Decode<'de, M> for &'de str {
344 #[inline]
345 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
346 where
347 D: Decoder<'de>,
348 {
349 struct Visitor;
350
351 impl<'de, C> UnsizedVisitor<'de, C, str> for Visitor
352 where
353 C: ?Sized + Context,
354 {
355 type Ok = &'de str;
356
357 #[inline]
358 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
359 write!(f, "string borrowed from source")
360 }
361
362 #[inline]
363 fn visit_borrowed(self, _: &C, string: &'de str) -> Result<Self::Ok, C::Error> {
364 Ok(string)
365 }
366 }
367
368 decoder.decode_string(Visitor)
369 }
370}
371
372impl<'de, M> DecodeUnsized<'de, M> for str {
373 #[inline]
374 fn decode_unsized<D, F, O>(_: &D::Cx, decoder: D, f: F) -> Result<O, D::Error>
375 where
376 D: Decoder<'de>,
377 F: FnOnce(&Self) -> Result<O, D::Error>,
378 {
379 struct Visitor<F>(F);
380
381 impl<'de, C, F, O> UnsizedVisitor<'de, C, str> for Visitor<F>
382 where
383 C: ?Sized + Context,
384 F: FnOnce(&str) -> Result<O, C::Error>,
385 {
386 type Ok = O;
387
388 #[inline]
389 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
390 write!(f, "string visited from source")
391 }
392
393 #[inline]
394 fn visit_ref(self, _: &C, string: &str) -> Result<Self::Ok, C::Error> {
395 (self.0)(string)
396 }
397 }
398
399 decoder.decode_string(Visitor(f))
400 }
401}
402
403impl<M, T> Encode<M> for [T]
404where
405 T: Encode<M>,
406{
407 fn encode<E>(&self, cx: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
408 where
409 E: Encoder<Mode = M>,
410 {
411 let hint = SequenceHint::with_size(self.len());
412
413 encoder.encode_sequence_fn(&hint, |seq| {
414 let mut index = 0;
415
416 for value in self {
417 cx.enter_sequence_index(index);
418 seq.encode_next()?.encode(value)?;
419 cx.leave_sequence_index();
420 index = index.wrapping_add(index);
421 }
422
423 Ok(())
424 })
425 }
426}
427
428impl<'de, M> Decode<'de, M> for &'de [u8] {
429 #[inline]
430 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
431 where
432 D: Decoder<'de>,
433 {
434 struct Visitor;
435
436 impl<'de, C> UnsizedVisitor<'de, C, [u8]> for Visitor
437 where
438 C: ?Sized + Context,
439 {
440 type Ok = &'de [u8];
441
442 #[inline]
443 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
444 write!(f, "bytes borrowed from source")
445 }
446
447 #[inline]
448 fn visit_borrowed(self, _: &C, bytes: &'de [u8]) -> Result<Self::Ok, C::Error> {
449 Ok(bytes)
450 }
451 }
452
453 decoder.decode_bytes(Visitor)
454 }
455}
456
457impl<'de, M> DecodeUnsizedBytes<'de, M> for [u8] {
458 #[inline]
459 fn decode_unsized_bytes<D, F, O>(_: &D::Cx, decoder: D, f: F) -> Result<O, D::Error>
460 where
461 D: Decoder<'de>,
462 F: FnOnce(&Self) -> Result<O, D::Error>,
463 {
464 struct Visitor<F>(F);
465
466 impl<'de, C, F, O> UnsizedVisitor<'de, C, [u8]> for Visitor<F>
467 where
468 C: ?Sized + Context,
469 F: FnOnce(&[u8]) -> Result<O, C::Error>,
470 {
471 type Ok = O;
472
473 #[inline]
474 fn expecting(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
475 write!(f, "bytes visited from source")
476 }
477
478 #[inline]
479 fn visit_ref(self, _: &C, bytes: &[u8]) -> Result<Self::Ok, C::Error> {
480 (self.0)(bytes)
481 }
482 }
483
484 decoder.decode_bytes(Visitor(f))
485 }
486}
487
488impl<T, M> Encode<M> for Option<T>
489where
490 T: Encode<M>,
491{
492 #[inline]
493 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
494 where
495 E: Encoder<Mode = M>,
496 {
497 match self {
498 Some(value) => encoder.encode_some()?.encode(value),
499 None => encoder.encode_none(),
500 }
501 }
502}
503
504impl<'de, M, T> Decode<'de, M> for Option<T>
505where
506 T: Decode<'de, M>,
507{
508 #[inline]
509 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
510 where
511 D: Decoder<'de, Mode = M>,
512 {
513 if let Some(decoder) = decoder.decode_option()? {
514 Ok(Some(decoder.decode()?))
515 } else {
516 Ok(None)
517 }
518 }
519}
520
521#[derive(Encode, Decode)]
522#[musli(crate)]
523enum ResultTag {
524 Ok,
525 Err,
526}
527
528impl<T, U, M> Encode<M> for Result<T, U>
529where
530 T: Encode<M>,
531 U: Encode<M>,
532 ResultTag: Encode<M>,
533{
534 #[inline]
535 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
536 where
537 E: Encoder<Mode = M>,
538 {
539 let variant = encoder.encode_variant()?;
540
541 match self {
542 Ok(ok) => variant.insert_variant(ResultTag::Ok, ok),
543 Err(err) => variant.insert_variant(ResultTag::Err, err),
544 }
545 }
546}
547
548impl<'de, M, T, U> Decode<'de, M> for Result<T, U>
549where
550 T: Decode<'de, M>,
551 U: Decode<'de, M>,
552 ResultTag: Decode<'de, M>,
553{
554 #[inline]
555 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
556 where
557 D: Decoder<'de, Mode = M>,
558 {
559 decoder.decode_variant(|variant| {
560 let tag = variant.decode_tag()?.decode()?;
561
562 Ok(match tag {
563 ResultTag::Ok => Ok(variant.decode_value()?.decode()?),
564 ResultTag::Err => Err(variant.decode_value()?.decode()?),
565 })
566 })
567 }
568}
569
570impl<T, M> Encode<M> for Wrapping<T>
571where
572 T: Encode<M>,
573{
574 #[inline]
575 fn encode<E>(&self, cx: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
576 where
577 E: Encoder<Mode = M>,
578 {
579 self.0.encode(cx, encoder)
580 }
581}
582
583impl<'de, M, T> Decode<'de, M> for Wrapping<T>
584where
585 T: Decode<'de, M>,
586{
587 #[inline]
588 fn decode<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
589 where
590 D: Decoder<'de, Mode = M>,
591 {
592 Ok(Wrapping(decoder.decode()?))
593 }
594}
595
596impl<M> Encode<M> for CStr {
597 #[inline]
598 fn encode<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
599 where
600 E: Encoder,
601 {
602 encoder.encode_bytes(self.to_bytes_with_nul())
603 }
604}
605
606impl<'de, M> Decode<'de, M> for &'de CStr {
607 #[inline]
608 fn decode<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
609 where
610 D: Decoder<'de>,
611 {
612 let bytes = decoder.decode()?;
613 CStr::from_bytes_with_nul(bytes).map_err(cx.map())
614 }
615}
616
617impl<'de, M> DecodeUnsized<'de, M> for CStr {
618 #[inline(always)]
619 fn decode_unsized<D, F, O>(cx: &D::Cx, decoder: D, f: F) -> Result<O, D::Error>
620 where
621 D: Decoder<'de, Mode = M>,
622 F: FnOnce(&Self) -> Result<O, D::Error>,
623 {
624 cx.decode_unsized_bytes(decoder, |bytes: &[u8]| {
625 let cstr = CStr::from_bytes_with_nul(bytes).map_err(cx.map())?;
626 f(cstr)
627 })
628 }
629}
630
631impl<M> EncodeBytes<M> for [u8] {
632 #[inline]
633 fn encode_bytes<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
634 where
635 E: Encoder<Mode = M>,
636 {
637 encoder.encode_bytes(self)
638 }
639}
640
641impl<const N: usize, M> EncodeBytes<M> for [u8; N] {
642 #[inline]
643 fn encode_bytes<E>(&self, _: &E::Cx, encoder: E) -> Result<E::Ok, E::Error>
644 where
645 E: Encoder<Mode = M>,
646 {
647 encoder.encode_array(self)
648 }
649}
650
651impl<'de, M> DecodeBytes<'de, M> for &'de [u8] {
652 #[inline]
653 fn decode_bytes<D>(cx: &D::Cx, decoder: D) -> Result<Self, D::Error>
654 where
655 D: Decoder<'de>,
656 {
657 Decode::decode(cx, decoder)
658 }
659}
660
661impl<'de, M, const N: usize> DecodeBytes<'de, M> for [u8; N] {
662 #[inline]
663 fn decode_bytes<D>(_: &D::Cx, decoder: D) -> Result<Self, D::Error>
664 where
665 D: Decoder<'de>,
666 {
667 decoder.decode_array()
668 }
669}