oct 0.29.2

// Copyright 2024-2026 Gabriel Bjørnager Jensen.
//
// SPDX: MIT OR Apache-2.0

//! The [`Deserialise`] trait.

mod test;

use crate::transmute_unchecked;

use alloc::vec;
use alloc::borrow::{Cow, ToOwned};
use alloc::boxed::Box;
use alloc::collections::{BinaryHeap, LinkedList};
use alloc::ffi::CString;
use alloc::rc::{self, Rc};
use alloc::string::String;
use alloc::vec::Vec;
use core::cell::{Cell, RefCell};
use core::marker::{PhantomData, PhantomPinned};
use core::mem::MaybeUninit;
use core::net::{
	IpAddr,
	Ipv4Addr,
	Ipv6Addr,
	SocketAddr,
	SocketAddrV4,
	SocketAddrV6,
};
use core::num::{NonZero, Saturating, Wrapping};
use core::ops::{
	Bound,
	Range,
	RangeFrom,
	RangeFull,
	RangeInclusive,
	RangeTo,
	RangeToInclusive,
};
use core::time::Duration;
use core::hash::{BuildHasher, Hash};
use std::collections::{HashMap, HashSet};
use std::io::{self, ErrorKind, Read};
use std::sync::{self, Mutex, RwLock};

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
use alloc::sync::Arc;

#[allow(unused_imports)]
use core::sync::atomic::Ordering;

#[cfg(target_has_atomic = "8")]
use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};

#[cfg(target_has_atomic = "16")]
use core::sync::atomic::{AtomicI16, AtomicU16};

#[cfg(target_has_atomic = "32")]
use core::sync::atomic::{AtomicI32, AtomicU32};

#[cfg(target_has_atomic = "64")]
use core::sync::atomic::{AtomicI64, AtomicU64};

#[cfg(target_has_atomic = "128")]
use core::sync::atomic::{AtomicI128, AtomicU128};

#[cfg(target_has_atomic = "ptr")]
use core::sync::atomic::{AtomicIsize, AtomicUsize};

/// Denotes a type capable of being deserialised from
/// octets.
pub trait Deserialise: Sized {
	/// Deserialises an object from the provided reader.
	///
	/// # Errors
	///
	/// This function should forward any error given by
	/// `r`. If the implementing type could not be
	/// deserialised, this function should return an
	/// [`InvalidData`] error.
	///
	/// [`InvalidData`]: ErrorKind::InvalidData
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self>;
}

/// Reads an octet array from the underlying buffer.
///
/// # Errors
///
/// This method should return an [`Err`] instance
/// if an error occurs during reading. For this
/// method specifically, this includes if the
/// underlying buffer contains less than `N` octets.
fn read_array<R: ?Sized + Read, const N: usize>(r: &mut R) -> io::Result<[u8; N]> {
	let mut buf = [0; _];
	r.read_exact(&mut buf)?;

	Ok(buf)
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: Deserialise> Deserialise for Arc<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

// SORT: array
impl<T: Deserialise, const N: usize> Deserialise for [T; N] {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let mut this = [const { MaybeUninit::<T>::uninit() }; N];

		for slot in &mut this {
			slot.write(T::deserialise(r)?);
		}

		// SAFETY: All items have been initialised.
		let this = unsafe { transmute_unchecked(this) };
		Ok(this)
	}
}

#[cfg(target_has_atomic = "8")]
impl Deserialise for AtomicBool {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = bool::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "128")]
impl Deserialise for AtomicI128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = i128::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "16")]
impl Deserialise for AtomicI16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = i16::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "32")]
impl Deserialise for AtomicI32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = i32::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "64")]
impl Deserialise for AtomicI64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = i64::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "8")]
impl Deserialise for AtomicI8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = i8::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Deserialise for AtomicIsize {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = isize::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "128")]
impl Deserialise for AtomicU128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u128::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "16")]
impl Deserialise for AtomicU16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u16::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "32")]
impl Deserialise for AtomicU32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u32::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "64")]
impl Deserialise for AtomicU64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u64::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "8")]
impl Deserialise for AtomicU8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u8::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Deserialise for AtomicUsize {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = usize::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(feature = "alloc")]
impl<T: Ord + Deserialise> Deserialise for BinaryHeap<T> {
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let v = Vec::<T>::deserialise(r)?;
		Ok(v.into())
	}
}

impl Deserialise for bool {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u8::deserialise(r)?;

		match value {
			0 => Ok(false),
			1 => Ok(true),
			_ => Err(ErrorKind::InvalidData.into()),
		}
	}
}

impl<T: Deserialise> Deserialise for Bound<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let discriminant = u8::deserialise(r)?;

		match discriminant {
			0 => {
				let bound = T::deserialise(r)?;
				Ok(Self::Included(bound))
			}

			1 => {
				let bound = T::deserialise(r)?;
				Ok(Self::Excluded(bound))
			}

			2 => {
				Ok(Self::Unbounded)
			}

			_ => Err(ErrorKind::InvalidData.into()),
		}
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Box<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for CString {
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = vec![0u8; len];

		r.read_exact(&mut v)?;
		v.push(b'\0');

		let Ok(s) = Self::from_vec_with_nul(v) else {
			unreachable!();
		};

		Ok(s)
	}
}

impl<T: Deserialise> Deserialise for Cell<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

impl Deserialise for char {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u32::deserialise(r)?;
		value.try_into().ok().ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

#[cfg(feature = "alloc")]
impl<T: ToOwned<Owned: Deserialise>> Deserialise for Cow<'_, T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::Owned(value))
	}
}

impl Deserialise for Duration {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let secs         = Deserialise::deserialise(r)?;
		let subsec_nanos = Deserialise::deserialise(r)?;

		Ok(Self::new(secs, subsec_nanos))
	}
}

#[cfg(feature = "f16")]
impl Deserialise for f16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bits = Deserialise::deserialise(r)?;
		Ok(Self::from_bits(bits))
	}
}

impl Deserialise for f32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bits = Deserialise::deserialise(r)?;
		Ok(Self::from_bits(bits))
	}
}

impl Deserialise for f64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bits = Deserialise::deserialise(r)?;
		Ok(Self::from_bits(bits))
	}
}

#[cfg(feature = "f128")]
impl Deserialise for f128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bits = Deserialise::deserialise(r)?;
		Ok(Self::from_bits(bits))
	}
}

#[cfg(feature = "std")]
impl<K: Eq + Hash + Deserialise, V: Deserialise, S: Default + BuildHasher> Deserialise for HashMap<K, V, S> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut this = Self::with_hasher(Default::default());

		for _ in 0..len {
			let key  = Deserialise::deserialise(r)?;
			let value = Deserialise::deserialise(r)?;

			this.insert(key, value);
		}

		Ok(this)
	}
}

#[cfg(feature = "std")]
impl<T: Eq + Hash + Deserialise, S: BuildHasher + Default> Deserialise for HashSet<T, S> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut this = Self::with_hasher(Default::default());

		for _ in 0..len {
			let key = Deserialise::deserialise(r)?;
			this.insert(key);
		}

		Ok(this)
	}
}

impl Deserialise for i128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for i16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for i32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for i64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for i8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for IpAddr {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let discriminant = u8::deserialise(r)?;

		match discriminant {
			4 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V4(addr))
			}

			6 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V6(addr))
			}

			_ => Err(ErrorKind::InvalidData.into()),
		}
	}
}

impl Deserialise for Ipv4Addr {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bits = Deserialise::deserialise(r)?;
		Ok(Self::from_bits(bits))
	}
}

impl Deserialise for Ipv6Addr {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bits = Deserialise::deserialise(r)?;
		Ok(Self::from_bits(bits))
	}
}

impl Deserialise for isize {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = i16::deserialise(r)?;
		Ok(value.into())
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for LinkedList<T> {
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut this = Self::new();

		for _ in 0..len {
			let item = Deserialise::deserialise(r)?;
			this.push_back(item);
		}

		Ok(this)
	}
}

#[cfg(feature = "std")]
impl<T: Deserialise> Deserialise for Mutex<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

impl Deserialise for NonZero<i128> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<i16> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<i32> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<i64> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<i8> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<isize> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<u128> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<u16> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<u32> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<u64> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<u8> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl Deserialise for NonZero<usize> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Self::new(value).ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

impl<T: Deserialise> Deserialise for Option<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let discriminant = u8::deserialise(r)?;

		match discriminant {
			0 => {
				Ok(None)
			}

			1 => {
				let value = Deserialise::deserialise(r)?;
				Ok(Some(value))
			}

			_ => Err(ErrorKind::InvalidData.into()),
		}
	}
}

impl<T: ?Sized> Deserialise for PhantomData<T> {
	#[inline(always)]
	fn deserialise<R: Read>(_r: &mut R) -> io::Result<Self> {
		Ok(Self)
	}
}

impl Deserialise for PhantomPinned {
	#[inline(always)]
	fn deserialise<R: Read>(_r: &mut R) -> io::Result<Self> {
		Ok(Self)
	}
}

impl<T: Deserialise> Deserialise for Range<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let start = Deserialise::deserialise(r)?;
		let end   = Deserialise::deserialise(r)?;

		Ok(start..end)
	}
}

impl<T: Deserialise> Deserialise for RangeFrom<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let start = Deserialise::deserialise(r)?;
		Ok(start..)
	}
}

impl Deserialise for RangeFull {
	#[inline(always)]
	fn deserialise<R: Read>(_r: &mut R) -> io::Result<Self> {
		Ok(..)
	}
}

impl<T: Deserialise> Deserialise for RangeInclusive<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let start = Deserialise::deserialise(r)?;
		let end   = Deserialise::deserialise(r)?;

		Ok(start..=end)
	}
}

impl<T: Deserialise> Deserialise for RangeTo<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let end = Deserialise::deserialise(r)?;
		Ok(..end)
	}
}

impl<T: Deserialise> Deserialise for RangeToInclusive<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let end = Deserialise::deserialise(r)?;
		Ok(..=end)
	}
}

impl<T: Deserialise> Deserialise for RefCell<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

impl<T: Deserialise, E: Deserialise> Deserialise for Result<T, E> {
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let discriminant = u8::deserialise(r)?;

		match discriminant {
			0 => {
				let value = Deserialise::deserialise(r)?;
				Ok(Ok(value))
			}

			1 => {
				let e = Deserialise::deserialise(r)?;
				Ok(Err(e))
			}

			_ => Err(ErrorKind::InvalidData.into())
		}
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Rc<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

#[cfg(feature = "std")]
impl<T: Deserialise> Deserialise for RwLock<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self::new(value))
	}
}

impl<T: Deserialise> Deserialise for Saturating<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self(value))
	}
}

impl Deserialise for SocketAddr {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let discriminant = u8::deserialise(r)?;

		match discriminant {
			4 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V4(addr))
			}

			6 => {
				let addr = Deserialise::deserialise(r)?;
				Ok(Self::V6(addr))
			}

			_ => Err(ErrorKind::InvalidData.into()),
		}
	}
}

impl Deserialise for SocketAddrV4 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let ip   = Deserialise::deserialise(r)?;
		let port = Deserialise::deserialise(r)?;

		Ok(Self::new(ip, port))
	}
}

impl Deserialise for SocketAddrV6 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let ip       = Deserialise::deserialise(r)?;
		let port     = Deserialise::deserialise(r)?;
		let flowinfo = Deserialise::deserialise(r)?;
		let scope_id = Deserialise::deserialise(r)?;

		Ok(Self::new(ip, port, flowinfo, scope_id))
	}
}

#[cfg(feature = "alloc")]
impl Deserialise for String {
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = vec![0; len];
		r.read_exact(&mut v)?;

		Self::from_utf8(v).ok().ok_or_else(|| ErrorKind::InvalidData.into())
	}
}

// SORT: tuple
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
impl<T: Deserialise> Deserialise for (T,) {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1> Deserialise for (T0, T1)
where
	T0: Deserialise,
	T1: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2> Deserialise for (T0, T1, T2)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3> Deserialise for (T0, T1, T2, T3)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4> Deserialise for (T0, T1, T2, T3, T4)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5> Deserialise for (T0, T1, T2, T3, T4, T5)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6> Deserialise for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
	T7: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
	T7: Deserialise,
	T8: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: Deserialise,
	T1: Deserialise,
	T2: Deserialise,
	T3: Deserialise,
	T4: Deserialise,
	T5: Deserialise,
	T6: Deserialise,
	T7: Deserialise,
	T8: Deserialise,
	T9: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  Deserialise,
	T1:  Deserialise,
	T2:  Deserialise,
	T3:  Deserialise,
	T4:  Deserialise,
	T5:  Deserialise,
	T6:  Deserialise,
	T7:  Deserialise,
	T8:  Deserialise,
	T9:  Deserialise,
	T10: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Deserialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  Deserialise,
	T1:  Deserialise,
	T2:  Deserialise,
	T3:  Deserialise,
	T4:  Deserialise,
	T5:  Deserialise,
	T6:  Deserialise,
	T7:  Deserialise,
	T8:  Deserialise,
	T9:  Deserialise,
	T10: Deserialise,
	T11: Deserialise,
{
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		Ok((
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
			Deserialise::deserialise(r)?,
		))
	}
}

// SORT: unit
impl Deserialise for () {
	#[inline(always)]
	fn deserialise<R: Read>(_r: &mut R) -> io::Result<Self> {
		Ok(())
	}
}

impl Deserialise for u128 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for u16 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for u32 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for u64 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for u8 {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let bytes = read_array::<_, { size_of::<Self>() }>(r).unwrap();
		Ok(Self::from_le_bytes(bytes))
	}
}

impl Deserialise for usize {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = u16::deserialise(r)?;
		Ok(value.into())
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for Vec<T> {
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let len = usize::deserialise(r)?;

		let mut v = Self::with_capacity(len);

		for _ in 0..len {
			let item = Deserialise::deserialise(r)?;
			v.push(item);
		}

		Ok(v)
	}
}

#[cfg(feature = "alloc")]
impl<T: Deserialise> Deserialise for rc::Weak<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		// Deserialise the value and drop it immediately.

		let _ = Option::<T>::deserialise(r)?;

		let this = Self::new();
		Ok(this)
	}
}

#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
impl<T: Deserialise> Deserialise for sync::Weak<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		// Deserialise the value and drop it immediately.

		let _ = Option::<T>::deserialise(r)?;

		let this = Self::new();
		Ok(this)
	}
}

impl<T: Deserialise> Deserialise for Wrapping<T> {
	#[inline]
	fn deserialise<R: Read>(r: &mut R) -> io::Result<Self> {
		let value = Deserialise::deserialise(r)?;
		Ok(Self(value))
	}
}