oct 0.29.2

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

//! The [`Serialise`] trait.

mod test;

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, LazyCell, RefCell};
use core::convert::Infallible;
use core::ffi::{CStr, c_void};
use core::hash::BuildHasher;
use core::marker::{PhantomData, PhantomPinned};
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 std::collections::{HashMap, HashSet};
use std::io::{self, ErrorKind, Write};
use std::sync::{
	self,
	LazyLock,
	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 serialised into
/// octets.
///
/// Note that we do not provide any guarantees for
/// the representation of serialised types. Users
/// that need fine control over representation
/// should use [`IntoOcts`] instead.
///
/// [`IntoOcts`]: crate::IntoOcts
pub trait Serialise {
	/// Serialises the object into the provided writer.
	///
	/// # Errors
	///
	/// This function should forward any error given by
	/// `w`. If the provided object could not be
	/// serialised, this method should return an
	/// [`InvalidInput`] error.
	///
	/// [`InvalidInput`]: ErrorKind::InvalidInput
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()>;
}

#[cfg(all(feature = "alloc", target_has_atomic = "ptr"))]
impl<T: ?Sized + Serialise> Serialise for Arc<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

// SORT: array
impl<T: Serialise, const N: usize> Serialise for [T; N] {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		for item in self {
			item.serialise(w)?;
		}

		Ok(())
	}
}

#[cfg(target_has_atomic = "8")]
impl Serialise for AtomicBool {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "128")]
impl Serialise for AtomicI128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "16")]
impl Serialise for AtomicI16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "32")]
impl Serialise for AtomicI32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "64")]
impl Serialise for AtomicI64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "8")]
impl Serialise for AtomicI8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Serialise for AtomicIsize {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "128")]
impl Serialise for AtomicU128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "16")]
impl Serialise for AtomicU16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "32")]
impl Serialise for AtomicU32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "64")]
impl Serialise for AtomicU64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "8")]
impl Serialise for AtomicU8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(target_has_atomic = "ptr")]
impl Serialise for AtomicUsize {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.load(Ordering::Relaxed).serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for BinaryHeap<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.as_slice().serialise(w)?;
		Ok(())
	}
}

impl Serialise for bool {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		let value = u8::from(*self);
		value.serialise(w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for Bound<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		match *self {
			Self::Included(ref bound) => {
				0u8.serialise(w)?;
				bound.serialise(w)?;
			}

			Self::Excluded(ref bound) => {
				1u8.serialise(w)?;
				bound.serialise(w)?;
			}

			Self::Unbounded => {
				2u8.serialise(w)?;
			}
		}

		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + Serialise> Serialise for Box<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

impl Serialise for CStr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.to_bytes().serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl Serialise for CString {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.as_c_str().serialise(w)?;
		Ok(())
	}
}

impl Serialise for c_void {
	#[inline]
	fn serialise<W: Write>(&self, _w: &mut W) -> io::Result<()> {
		// NOTE: `c_void` objects may (theoretically) be
		// constructed.
		unreachable!("`c_void` objects should not be constructed >:(")
	}
}

impl<T: Copy + Serialise> Serialise for Cell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for char {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		let value = *self as u32;
		value.serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + ToOwned + Serialise> Serialise for Cow<'_, T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

impl Serialise for Duration {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.as_secs().serialise(w)?;
		self.subsec_nanos().serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "f16")]
impl Serialise for f16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for f32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for f64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

#[cfg(feature = "f128")]
impl Serialise for f128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

#[cfg(feature = "std")]
impl<K: Serialise, V: Serialise, S: BuildHasher> Serialise for HashMap<K, V, S> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.len().serialise(w)?;

		for (key, value) in self {
			key.serialise(w)?;
			value.serialise(w)?;
		}

		Ok(())
	}
}

#[cfg(feature = "std")]
impl<T: Serialise, S: BuildHasher> Serialise for HashSet<T, S> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.len().serialise(w)?;

		for key in self {
			key.serialise(w)?;
		}

		Ok(())
	}
}

impl Serialise for i128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for i16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for i32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for i64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for i8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for Infallible {
	#[inline]
	fn serialise<W: Write>(&self, _w: &mut W) -> io::Result<()> {
		unreachable!()
	}
}

impl Serialise for IpAddr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		match *self {
			Self::V4(addr) => {
				4u8.serialise(w)?;
				addr.serialise(w)?;
			}

			Self::V6(addr) => {
				6u8.serialise(w)?;
				addr.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl Serialise for Ipv4Addr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.to_bits().serialise(w)?;
		Ok(())
	}
}

impl Serialise for Ipv6Addr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.to_bits().serialise(w)?;
		Ok(())
	}
}

impl Serialise for isize {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		let value = i16::try_from(*self).map_err(|_| ErrorKind::InvalidInput)?;
		w.write_all(&value.to_le_bytes())?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for LazyCell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

#[cfg(feature = "std")]
impl<T: Serialise> Serialise for LazyLock<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for LinkedList<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.len().serialise(w)?;

		for item in self {
			item.serialise(w)?;
		}

		Ok(())
	}
}

#[cfg(feature = "std")]
impl<T: Serialise> Serialise for Mutex<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		let lock = match self.lock() {
			Ok(lock) => lock,
			Err(e)   => e.into_inner(),
		};

		T::serialise(&lock, w)?;
		Ok(())
	}
}

impl Serialise for NonZero<i128> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<i16> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<i32> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<i64> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<i8> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<isize> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<u128> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<u16> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<u32> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<u64> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<u8> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl Serialise for NonZero<usize> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.get().serialise(w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for Option<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		match *self {
			None => {
				0u8.serialise(w)?;
			}

			Some(ref value) => {
				1u8.serialise(w)?;
				value.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl<T: ?Sized> Serialise for PhantomData<T> {
	#[inline(always)]
	fn serialise<W: Write>(&self, _w: &mut W) -> io::Result<()> {
		Ok(())
	}
}

impl Serialise for PhantomPinned {
	#[inline(always)]
	fn serialise<W: Write>(&self, _w: &mut W) -> io::Result<()> {
		Ok(())
	}
}

impl<T: Serialise> Serialise for Range<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.start.serialise(w)?;
		self.end.serialise(w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for RangeFrom<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.start.serialise(w)?;
		Ok(())
	}
}

impl Serialise for RangeFull {
	#[inline(always)]
	fn serialise<W: Write>(&self, _w: &mut W) -> io::Result<()> {
		Ok(())
	}
}

impl<T: Serialise> Serialise for RangeInclusive<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.start().serialise(w)?;
		self.end().serialise(w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for RangeTo<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.end.serialise(w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for RangeToInclusive<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.end.serialise(w)?;
		Ok(())
	}
}

impl<T: ?Sized + Serialise> Serialise for RefCell<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(&self.borrow(), w)?;
		Ok(())
	}
}

impl<T: Serialise, E: Serialise> Serialise for Result<T, E> {
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		match *self {
			Ok(ref value) => {
				0u8.serialise(w)?;
				value.serialise(w)?;
			}

			Err(ref e) => {
				1u8.serialise(w)?;
				e.serialise(w)?;
			}
		}

		Ok(())
	}
}

// SORT: reference
impl<T: Serialise> Serialise for &T {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: ?Sized + Serialise> Serialise for Rc<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		T::serialise(self, w)?;
		Ok(())
	}
}

#[cfg(feature = "std")]
impl<T: ?Sized + Serialise> Serialise for RwLock<T> {
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		let lock = match self.read() {
			Ok(lock) => lock,
			Err(e)   => e.into_inner(),
		};

		T::serialise(&lock, w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for Saturating<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		Ok(())
	}
}

impl Serialise for SocketAddr {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		match *self {
			Self::V4(addr) => {
				4u8.serialise(w)?;
				addr.serialise(w)?;
			}

			Self::V6(addr) => {
				6u8.serialise(w)?;
				addr.serialise(w)?;
			}
		}

		Ok(())
	}
}

impl Serialise for SocketAddrV4 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.ip().serialise(w)?;
		self.port().serialise(w)?;
		Ok(())
	}
}

impl Serialise for SocketAddrV6 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.ip().serialise(w)?;
		self.port().serialise(w)?;
		self.flowinfo().serialise(w)?;
		self.scope_id().serialise(w)?;
		Ok(())
	}
}

// SORT: slice
impl<T: Serialise> Serialise for [T] {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.len().serialise(w)?;

		for item in self {
			item.serialise(w)?;
		}

		Ok(())
	}
}

impl Serialise for str {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.as_bytes().serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl Serialise for String {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.as_str().serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
impl<T: Serialise> Serialise for (T,) {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1> Serialise for (T0, T1)
where
	T0: Serialise,
	T1: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2> Serialise for (T0, T1, T2)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3> Serialise for (T0, T1, T2, T3)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4> Serialise for (T0, T1, T2, T3, T4)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5> Serialise for (T0, T1, T2, T3, T4, T5)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6> Serialise for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
	T7: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
	T7: Serialise,
	T8: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: Serialise,
	T1: Serialise,
	T2: Serialise,
	T3: Serialise,
	T4: Serialise,
	T5: Serialise,
	T6: Serialise,
	T7: Serialise,
	T8: Serialise,
	T9: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		self.9.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  Serialise,
	T1:  Serialise,
	T2:  Serialise,
	T3:  Serialise,
	T4:  Serialise,
	T5:  Serialise,
	T6:  Serialise,
	T7:  Serialise,
	T8:  Serialise,
	T9:  Serialise,
	T10: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		self.9.serialise(w)?;
		self.10.serialise(w)?;
		Ok(())
	}
}

// SORT: tuple
#[doc(hidden)]
impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> Serialise for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  Serialise,
	T1:  Serialise,
	T2:  Serialise,
	T3:  Serialise,
	T4:  Serialise,
	T5:  Serialise,
	T6:  Serialise,
	T7:  Serialise,
	T8:  Serialise,
	T9:  Serialise,
	T10: Serialise,
	T11: Serialise,
{
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		self.1.serialise(w)?;
		self.2.serialise(w)?;
		self.3.serialise(w)?;
		self.4.serialise(w)?;
		self.5.serialise(w)?;
		self.6.serialise(w)?;
		self.7.serialise(w)?;
		self.8.serialise(w)?;
		self.9.serialise(w)?;
		self.10.serialise(w)?;
		self.11.serialise(w)?;
		Ok(())
	}
}

// SORT: unit
impl Serialise for () {
	#[inline(always)]
	fn serialise<W: Write>(&self, _w: &mut W) -> io::Result<()> {
		Ok(())
	}
}

impl Serialise for u128 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for u16 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for u32 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for u64 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for u8 {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		w.write_all(&self.to_le_bytes())?;
		Ok(())
	}
}

impl Serialise for usize {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		let value = u16::try_from(*self).map_err(|_| ErrorKind::InvalidInput)?;
		w.write_all(&value.to_le_bytes())?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for Vec<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.as_slice().serialise(w)?;
		Ok(())
	}
}

#[cfg(feature = "alloc")]
impl<T: Serialise> Serialise for rc::Weak<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.upgrade().serialise(w)?;
		Ok(())
	}
}

#[cfg(all(feature = "std", target_has_atomic = "ptr"))]
impl<T: Serialise> Serialise for sync::Weak<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.upgrade().serialise(w)?;
		Ok(())
	}
}

impl<T: Serialise> Serialise for Wrapping<T> {
	#[inline]
	fn serialise<W: Write>(&self, w: &mut W) -> io::Result<()> {
		self.0.serialise(w)?;
		Ok(())
	}
}