oct 0.37.0

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

//! The [`IntoOctets`] trait.

mod test;

use core::cell::{Cell, UnsafeCell};
use core::cmp::{self, Reverse};
use core::convert::Infallible;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::ManuallyDrop;
use core::num::{NonZero, Saturating, Wrapping};
use oct::{FromOctets, Immutable, octets_of, octets_of_mut};

#[cfg(feature = "ascii")]
use core::ascii;

#[cfg(feature = "bstr")]
use core::bstr::ByteStr;

#[cfg(feature = "simd")]
use core::simd::{Simd, SimdElement};

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
use core::arch::aarch64 as arch;

#[cfg(target_arch = "wasm32")]
use core::arch::wasm32 as arch;

#[cfg(target_arch = "x86")]
use core::arch::x86 as arch;

#[cfg(target_arch = "x86_64")]
use core::arch::x86_64 as arch;

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

#[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 = "8")]
use core::sync::atomic::{AtomicBool, AtomicI8, AtomicU8};

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

/// Denotes a type representable as octets (bytes.)
///
/// A type that implements this trait is a type that
/// has a well-defined octet representation, i.e.
/// which can soundly be converted into an octet
/// array. Theoretically, any allocated Rust object
/// has such representation; however, this trait
/// specifically requires that the type of any such
/// object only permits objects that are fully
/// initialised within their allocation.
///
/// This trait is mainly useful for cases where the
/// raw representation must be modified indirectly
/// of the formal object value.
///
/// # Safety
///
/// Only types that always guarantee a
/// fully-initialised state may implement this trait.
///
/// Formally, a type may implement this trait if the
/// following conditions are met:
///
/// * For all non-constructable types, the type may
///   always implement this trait.
/// * For structures and unions, the type may
///   implement this trait if all fields support the
///   same semantics and the cumulative size of
///   these fields equals the size of any object of
///   that type (i.e. the type may never contain
///   padding bytes.)
/// * For enumerations, the type may implement this
///   trait if all variant fields support the same
///   semantics, the discriminant is absent, and
///   trait if the cumulated sizes of all variant
///   fields, added to the discriminant's size, equals the
///
/// A type that does not meet the above requirements
/// may not implement this trait, unless the above
/// logic is non-exhaustive (in which case a bug
/// report is requested.)
#[doc(alias = "IntoBytes")]
pub unsafe trait IntoOctets {
	/// Reinterprets the object as a slice of octets.
	///
	/// *This operation is semantically identical to the
	/// [`octets_of`] global function.*
	#[doc(alias = "as_bytes")]
	#[inline]
	#[must_use]
	fn as_octets(&self) -> &[u8]
	where
		Self: Immutable,
	{
		octets_of(self)
	}

	/// Reinterprets the object as a mutable slice of
	/// octets.
	///
	/// *This operation is semantically identical to the
	/// [`octets_of_mut`] global function.*
	#[doc(alias = "as_bytes_mut")]
	#[doc(alias = "as_mut_bytes")]
	#[doc(alias = "as_mut_octets")]
	#[inline]
	#[must_use]
	fn as_octets_mut(&mut self) -> &mut [u8]
	where
		Self: FromOctets,
	{
		octets_of_mut(self)
	}
}

unsafe impl<T: IntoOctets, const N: usize> IntoOctets for [T; N] {}

#[cfg(target_has_atomic = "8")]
unsafe impl IntoOctets for AtomicBool {}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl IntoOctets for AtomicI128 {}

#[cfg(target_has_atomic = "16")]
unsafe impl IntoOctets for AtomicI16 {}

#[cfg(target_has_atomic = "32")]
unsafe impl IntoOctets for AtomicI32 {}

#[cfg(target_has_atomic = "64")]
unsafe impl IntoOctets for AtomicI64 {}

#[cfg(target_has_atomic = "8")]
unsafe impl IntoOctets for AtomicI8 {}

#[cfg(target_has_atomic = "ptr")]
unsafe impl IntoOctets for AtomicIsize {}

#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl IntoOctets for AtomicU128 {}

#[cfg(target_has_atomic = "16")]
unsafe impl IntoOctets for AtomicU16 {}

#[cfg(target_has_atomic = "32")]
unsafe impl IntoOctets for AtomicU32 {}

#[cfg(target_has_atomic = "64")]
unsafe impl IntoOctets for AtomicU64 {}

#[cfg(target_has_atomic = "8")]
unsafe impl IntoOctets for AtomicU8 {}

#[cfg(target_has_atomic = "ptr")]
unsafe impl IntoOctets for AtomicUsize {}

unsafe impl IntoOctets for bool {}

#[cfg(feature = "bstr")]
unsafe impl IntoOctets for ByteStr {}

unsafe impl<T: IntoOctets> IntoOctets for Cell<T> {}

unsafe impl IntoOctets for char {}

#[cfg(feature = "ascii")]
unsafe impl IntoOctets for ascii::Char {}

#[cfg(feature = "f128")]
unsafe impl IntoOctets for f128 {}

#[cfg(feature = "f16")]
unsafe impl IntoOctets for f16 {}

unsafe impl IntoOctets for f32 {}

unsafe impl IntoOctets for f64 {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::float16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::float32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec"))]
unsafe impl IntoOctets for arch::float64x2x4_t {}

unsafe impl IntoOctets for i128 {}

unsafe impl IntoOctets for i16 {}

unsafe impl IntoOctets for i32 {}

unsafe impl IntoOctets for i64 {}

unsafe impl IntoOctets for i8 {}

// SAFETY: `Infallible` cannot be constructed, so
// its actual representation is irrelevant.
unsafe impl IntoOctets for Infallible {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::int8x8x4_t {}

unsafe impl IntoOctets for isize {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m128 {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl IntoOctets for arch::__m128bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m128d {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::__m128h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m128i {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m256 {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl IntoOctets for arch::__m256bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m256d {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::__m256h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m256i {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m512 {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.89)]
unsafe impl IntoOctets for arch::__m512bh {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m512d {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
#[rustversion::since(1.94)]
unsafe impl IntoOctets for arch::__m512h {}

#[cfg(any(target_arch = "x86", target_arch = "x86_64"))]
unsafe impl IntoOctets for arch::__m512i {}

unsafe impl<T: IntoOctets> IntoOctets for ManuallyDrop<T> {}

// unsafe impl IntoOctets for ! {}

unsafe impl IntoOctets for NonZero<i128> {}

unsafe impl IntoOctets for NonZero<i16> {}

unsafe impl IntoOctets for NonZero<i32> {}

unsafe impl IntoOctets for NonZero<i64> {}

unsafe impl IntoOctets for NonZero<i8> {}

unsafe impl IntoOctets for NonZero<isize> {}

unsafe impl IntoOctets for NonZero<u128> {}

unsafe impl IntoOctets for NonZero<u16> {}

unsafe impl IntoOctets for NonZero<u32> {}

unsafe impl IntoOctets for NonZero<u64> {}

unsafe impl IntoOctets for NonZero<u8> {}

unsafe impl IntoOctets for NonZero<usize> {}

unsafe impl IntoOctets for Option<NonZero<i128>> {}

unsafe impl IntoOctets for Option<NonZero<i16>> {}

unsafe impl IntoOctets for Option<NonZero<i32>> {}

unsafe impl IntoOctets for Option<NonZero<i64>> {}

unsafe impl IntoOctets for Option<NonZero<i8>> {}

unsafe impl IntoOctets for Option<NonZero<isize>> {}

unsafe impl IntoOctets for Option<NonZero<u128>> {}

unsafe impl IntoOctets for Option<NonZero<u16>> {}

unsafe impl IntoOctets for Option<NonZero<u32>> {}

unsafe impl IntoOctets for Option<NonZero<u64>> {}

unsafe impl IntoOctets for Option<NonZero<u8>> {}

unsafe impl IntoOctets for Option<NonZero<usize>> {}

unsafe impl IntoOctets for cmp::Ordering {}

unsafe impl<T: ?Sized> IntoOctets for PhantomData<T> {}

unsafe impl IntoOctets for PhantomPinned {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::poly8x8x4_t {}

unsafe impl<T: IntoOctets> IntoOctets for Reverse<T> {}

unsafe impl<T: IntoOctets> IntoOctets for Saturating<T> {}

#[cfg(feature = "simd")]
unsafe impl<T: SimdElement + IntoOctets, const N: usize> IntoOctets for Simd<T, N> {}

unsafe impl<T: IntoOctets> IntoOctets for [T] {}

unsafe impl IntoOctets for str {}

/// Implemented for homogeneous tuples with up to
/// twelve members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
unsafe impl<T: IntoOctets> IntoOctets for (T,) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T, T, T, T, T, T) {}

#[doc(hidden)]
unsafe impl<T: IntoOctets> IntoOctets for (T, T, T, T, T, T, T, T, T, T, T, T) {}

unsafe impl IntoOctets for u128 {}

unsafe impl IntoOctets for u16 {}

unsafe impl IntoOctets for u32 {}

unsafe impl IntoOctets for u64 {}

unsafe impl IntoOctets for u8 {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint16x8x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x4x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x4x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint32x4x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x1_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x1x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x1x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x1x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x2x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x2x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint64x2x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x16_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x16x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x16x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x16x4_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x8_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x8x2_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x8x3_t {}

#[cfg(any(target_arch = "aarch64", target_arch = "arm64ec", target_feature = "v7"))]
unsafe impl IntoOctets for arch::uint8x8x4_t {}

unsafe impl IntoOctets for () {}

unsafe impl<T: IntoOctets> IntoOctets for UnsafeCell<T> {}

unsafe impl IntoOctets for usize {}

#[cfg(target_arch = "wasm32")]
unsafe impl IntoOctets for arch::v128 {}

unsafe impl<T: IntoOctets> IntoOctets for Wrapping<T> {}