oct 0.36.2

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

//! The [`FromOctets`] trait.

mod test;

use core::cell::{Cell, UnsafeCell};
use core::cmp::Reverse;
use core::marker::{PhantomData, PhantomPinned};
use core::mem::{ManuallyDrop, MaybeUninit};
use core::num::{NonZero, Saturating, Wrapping};
use core::ptr::NonNull;
use oct::{
	Immutable,
	Init,
	Outlay,
	Zeroable,
	transmute_mut,
	transmute_mut_with_metadata,
	transmute_ref,
	transmute_ref_with_metadata,
};

#[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::{AtomicI8, AtomicU8};

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

/// Denotes a type that can represent all octets
/// (bytes).
///
/// # Pointers
///
/// This type isn't implemented for pointers as any
/// pointer constructed from such octets would be
/// without provenance -- even if the address itself
/// is valid. We do therefore not implement this
/// trait for any pointer type as we see it to be
/// too confusing.
///
/// Pointers do, however, implement [`Zeroable`], as
/// such behaviour cannot be confused in the same
/// way. Similarly, pointers also implement
/// [`IntoOctets`] as that alone can't lead to any
/// undefined behaviour.
///
/// [`IntoOctets`]: oct::IntoOctets
///
/// # `MaybeUninit`
///
/// Whilst [`MaybeUninit<T>`] does implement this
/// trait for any type `T`, such implementation
/// alone makes no guarantees about the validity of
/// calls to [`assume_init`]; such still depends on
/// whether or not the provided representation is
/// valid for the given instance of `T`; Where
/// `T: FromOctets` applies, this is always valid.
///
/// [`assume_init`]: MaybeUninit::assume_init
///
/// # Safety
///
/// Types that implement this trait must be able to
/// represent any permutation of [`u8`] patterns of
/// the same size. Furthermore, any such
/// representation must constitute an initialised
/// state of the type in question (by extension,
/// this prohibits uninhabited types from
/// implementing this trait).
///
/// The provided functions of this trait may not be
/// overriden.
#[doc(alias = "FromBytes")]
pub unsafe trait FromOctets: Zeroable {
	/// Reads an object from octets.
	///
	/// The returned object is considered initialised.
	///
	/// # Panics
	///
	/// This constructor will panic if the provided
	/// octets are unaligned for `Self` or their length
	/// is less than the size of `Size`.
	#[inline]
	#[must_use]
	#[track_caller]
	fn read_from_octets(octets: &[u8]) -> Self
	where
		Self: Sized,
	{
		assert!(
			octets.len() >= size_of::<Self>(),
			"cannot read object from undersized octets",
		);

		let p = octets.as_ptr().cast::<Self>();

		assert!(
			p.is_aligned(),
			"cannot read object from unaligned octets",
		);

		// SAFETY:
		// * The pointer inherits read capabilities from a
		//   reference.
		//
		// * The pointer can likewise thus not be un-
		//   aligned.
		//
		// * `u8` already guarantees an initialised state.
		//   The `Self: FromOctets` bound requires that any
		//   such representation may be transmuted to
		//   `Self`.
		unsafe { p.read() }
	}

	/// Reads an object from octets.
	///
	/// The returned object is considered initialised.
	///
	/// # Panics
	///
	/// If the length of the provided octets is less
	/// than the size of `Self`, this function will
	/// panic.
	#[inline]
	#[must_use]
	#[track_caller]
	fn read_from_octets_unaligned(octets: &[u8]) -> Self
	where
		Self: Sized,
	{
		assert!(
			octets.len() >= size_of::<Self>(),
			"cannot read object from undersized octets",
		);

		let p = octets.as_ptr().cast::<Self>();

		// SAFETY:
		// * The pointer inherits read capabilities from a
		//   reference.
		//
		// * `u8` already guarantees an initialised state.
		//   The `Self: FromOctets` bound requires that any
		//   such representation may be transmuted to
		unsafe { p.read_unaligned() }
	}

	/// Reinterprets octets as a reference.
	///
	/// The referenced object is considered initialised.
	///
	/// # Panics
	///
	/// If the length of the provided octets is less
	/// than the size of `Self` or the octets themselves
	/// are unaligned, this constructor will panic.
	#[inline]
	#[must_use]
	#[track_caller]
	fn ref_from_octets(octets: &[u8]) -> &Self
	where
		Self: Outlay + Immutable,
	{
		transmute_ref::<[u8], Self>(octets)
	}

	/// Reinterprets octets as a mutable reference.
	///
	/// The referenced object is considered initialised.
	///
	/// # Panics
	///
	/// If the length of the provided octets is less
	/// than the size of `Self` or the octets themselves
	/// are unaligned, this constructor will panic.
	#[inline]
	#[must_use]
	#[track_caller]
	fn mut_from_octets(octets: &mut [u8]) -> &mut Self
	where
		Self: Outlay + Init,
	{
		transmute_mut::<[u8], Self>(octets)
	}

	/// Reinterprets octets as a reference with a
	/// predefined length component.
	///
	/// This function reinterprets the provided octets
	/// as a representation of `Self`, using the
	/// provided length component as the slice length.
	///
	/// # Panics
	///
	/// If the length of the provided octets is less
	/// than the size of `Self` or the octets themselves
	/// are unaligned, this constructor will panic.
	#[inline]
	#[must_use]
	#[track_caller]
	fn ref_from_octets_with_metadata(octets: &[u8], metadata: Self::Metadata) -> &Self
	where
		Self: Outlay + Immutable,
	{
		transmute_ref_with_metadata::<[u8], Self>(octets, metadata)
	}

	/// Reinterprets octets as a mutable reference with
	/// a length component.
	///
	/// This function reinterprets the provided octets
	/// as a representation of `Self`, using the
	/// provided length component as the slice length.
	///
	/// # Panics
	///
	/// If the length of the provided octets is less
	/// than the size of `Self` or the octets themselves
	/// are unaligned, this constructor will panic.
	#[inline]
	#[must_use]
	#[track_caller]
	fn mut_from_octets_with_metadata(octets: &mut [u8], metadata: Self::Metadata) -> &mut Self
	where
		Self: Outlay + Init,
	{
		transmute_mut_with_metadata::<[u8], Self>(octets, metadata)
	}

	/// Constructs a new object from all-ones.
	///
	/// The returned object is considered initialised.
	#[inline]
	#[must_use]
	fn new_oned() -> Self
	where
		Self: Sized,
	{
		let mut this = MaybeUninit::<Self>::uninit();
		this.make_oned();

		// SAFETY: `make_oned` guarantees an initialised
		// state.
		unsafe { this.assume_init() }
	}

	/// Overwrites the object with all-ones.
	///
	/// The provided object is considered initialised
	/// after a successful call to this method.
	#[inline]
	fn make_oned(&mut self) {
		let len = size_of_val(self);
		let ptr = (&raw mut *self).cast::<u8>();

		// SAFETY:
		// * `size_of_val` returns the exact size of the
		//   object.
		//
		// * The pointer derives from a reference and can
		//   therefore not be unaligned.
		//
		// * The object is initialised entirely with all-
		//   zeros, and the `Self: FromOctets` bound re-
		//   quires that this representation (and any
		//   other) is valid.
		unsafe { ptr.write_bytes(0b11111111, len) };
	}
}

// SORT: array
unsafe impl<T: FromOctets, const N: usize> FromOctets for [T; N] {}

// SAFETY: `AtomicI128` is transparent to `i128`.
#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl FromOctets for AtomicI128 {}

// SAFETY: `AtomicI16` is transparent to `i16`.
#[cfg(target_has_atomic = "16")]
unsafe impl FromOctets for AtomicI16 {}

// SAFETY: `AtomicI32` is transparent to `i32`.
#[cfg(target_has_atomic = "32")]
unsafe impl FromOctets for AtomicI32 {}

// SAFETY: `AtomicI64` is transparent to `i64`.
#[cfg(target_has_atomic = "64")]
unsafe impl FromOctets for AtomicI64 {}

// SAFETY: `AtomicI8` is transparent to `i8`.
#[cfg(target_has_atomic = "8")]
unsafe impl FromOctets for AtomicI8 {}

// SAFETY: `AtomicIsize` is transparent to `isize`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl FromOctets for AtomicIsize {}

// SAFETY: `AtomicU128` is transparent to `u128`.
#[cfg(all(target_has_atomic = "128", feature = "atomic_u128_i128"))]
unsafe impl FromOctets for AtomicU128 {}

// SAFETY: `AtomicU16` is transparent to `u16`.
#[cfg(target_has_atomic = "16")]
unsafe impl FromOctets for AtomicU16 {}

// SAFETY: `AtomicU32` is transparent to `u32`.
#[cfg(target_has_atomic = "32")]
unsafe impl FromOctets for AtomicU32 {}

// SAFETY: `AtomicU64` is transparent to `u64`.
#[cfg(target_has_atomic = "64")]
unsafe impl FromOctets for AtomicU64 {}

// SAFETY: `AtomicU8` is transparent to `u8`.
#[cfg(target_has_atomic = "8")]
unsafe impl FromOctets for AtomicU8 {}

// SAFETY: `AtomicUsize` is transparent to `usize`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl FromOctets for AtomicUsize {}

// SAFETY: `ByteStr` is transparent to `[u8]`.
#[cfg(feature = "bstr")]
unsafe impl FromOctets for ByteStr {}

// SAFETY: `Cell<T>` is transparent to `T`.
unsafe impl<T: FromOctets> FromOctets for Cell<T> {}

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

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

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

unsafe impl FromOctets for f32 {}

unsafe impl FromOctets for f64 {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl FromOctets for i128 {}

unsafe impl FromOctets for i16 {}

unsafe impl FromOctets for i32 {}

unsafe impl FromOctets for i64 {}

unsafe impl FromOctets for i8 {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl FromOctets for isize {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SAFETY: `ManuallyDrop<T>` is transparent to `T`.
unsafe impl<T: FromOctets> FromOctets for ManuallyDrop<T> {}

// SAFETY: `MaybeUninit<T>` supports any represen-
// tation.
unsafe impl<T> FromOctets for MaybeUninit<T> {}

// // SORT: never
// unsafe impl FromOctets for ! {}

// FIXME: Require `T: Thin` instead of `T: Sized`.
// SAFETY: `Option<NonNull<T>>` is transparent to
// to `Option<NonZero<usize>>` when `T: Sized`.
unsafe impl<T> FromOctets for Option<NonNull<T>> {}

// SAFETY: `Option<NonZero<i128>>` is transparent
// to `i128`.
unsafe impl FromOctets for Option<NonZero<i128>> {}

// SAFETY: `Option<NonZero<i16>>` is transparent to
// `i16`.
unsafe impl FromOctets for Option<NonZero<i16>> {}

// SAFETY: `Option<NonZero<i32>>` is transparent to
// `i32`.
unsafe impl FromOctets for Option<NonZero<i32>> {}

// SAFETY: `Option<NonZero<i64>>` is transparent to
// `i64`.
unsafe impl FromOctets for Option<NonZero<i64>> {}

// SAFETY: `Option<NonZero<i8>>` is transparent to
// `i8`.
unsafe impl FromOctets for Option<NonZero<i8>> {}

// SAFETY: `Option<NonZero<isize>>` is transparent
// to `isize`.
unsafe impl FromOctets for Option<NonZero<isize>> {}

// SAFETY: `Option<NonZero<u128>>` is transparent
// to `u128`.
unsafe impl FromOctets for Option<NonZero<u128>> {}

// SAFETY: `Option<NonZero<u16>>` is transparent to
// `u16`.
unsafe impl FromOctets for Option<NonZero<u16>> {}

// SAFETY: `Option<NonZero<u32>>` is transparent to
// `u32`.
unsafe impl FromOctets for Option<NonZero<u32>> {}

// SAFETY: `Option<NonZero<u64>>` is transparent to
// `u64`.
unsafe impl FromOctets for Option<NonZero<u64>> {}

// SAFETY: `Option<NonZero<u8>>` is transparent to
// `u8`.
unsafe impl FromOctets for Option<NonZero<u8>> {}

// SAFETY: `Option<NonZero<usize>>` is transparent
// to `usize`.
unsafe impl FromOctets for Option<NonZero<usize>> {}

// SAFETY: `PhantomData<T>` is a ZST.
unsafe impl<T: ?Sized> FromOctets for PhantomData<T> {}

// SAFETY: `PhantomPinned` is a ZST.
unsafe impl FromOctets for PhantomPinned {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SAFETY `Reverse<T>` is transparent to `T`.
unsafe impl<T: FromOctets> FromOctets for Reverse<T> {}

// SAFETY: `Saturating<T>` is transparent to `T`.
unsafe impl<T: FromOctets> FromOctets for Saturating<T> {}

// SAFETY `Simd<T, N>` is transparent to `[T; N]`.
#[cfg(feature = "simd")]
unsafe impl<T: SimdElement + FromOctets, const N: usize> FromOctets for Simd<T, N> {}

// SORT: slice
// SAFETY: Slices have the same representation as
// arrays.
unsafe impl<T: FromOctets> FromOctets for [T] {}

unsafe impl FromOctets for str {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
/// Implemented for tuples with up to twelve
/// members.
#[cfg_attr(feature = "unstable_docs", doc(fake_variadic))]
unsafe impl<T: FromOctets> FromOctets for (T,) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T, T, T, T, T, T) {}

// SORT: tuple
// SAFETY: Homogeneous tuples have the same repre-
// sentation as arrays.
#[doc(hidden)]
unsafe impl<T: FromOctets> FromOctets for (T, T, T, T, T, T, T, T, T, T, T, T) {}

unsafe impl FromOctets for u128 {}

unsafe impl FromOctets for u16 {}

unsafe impl FromOctets for u32 {}

unsafe impl FromOctets for u64 {}

unsafe impl FromOctets for u8 {}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// SORT: unit
unsafe impl FromOctets for () {}

// SAFETY: `UnsafeCell<T>` is transparent to `T`.
unsafe impl<T: FromOctets> FromOctets for UnsafeCell<T> {}

unsafe impl FromOctets for usize {}

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

// SAFETY: `Wrapping<T>` is transparent to `T`.
unsafe impl<T: FromOctets> FromOctets for Wrapping<T> {}