oct 0.37.0 - Docs.rs

// 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,
	IntoOctets,
	Zeroable,
	Outlay,
	transmute_copy,
	transmute_mut,
	transmute_ref,
};

#[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, AtomicPtr, AtomicUsize};

/// Denotes a type that can represent all octets
/// (bytes.)
///
/// ## Pointers
///
/// Whilst this type is implemented for thin,
/// primitive pointers types, special care should
/// be used with pointers constructed from raw
/// octets: Notably, these pointers never have
/// provenance or any read/write capabilites, and
/// can thus never interact with Rust's memory
/// model.
///
/// ## `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`] etc.; such still
/// depend 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
///
/// Any type that implements this trait guarantees
/// that any [`u8`] sequence may be reinterpreted or
/// transmuted into the implementing type in
/// question.
///
/// Formally, a type may implement this trait in the
/// following cases:
///
/// * For all types, the type must be constructable
///   (i.e. inhabited) and not have any invariants
///   at all.
/// * For structures, the type may implement this
///   trait if all member fields support the same
///   semantics as well.
/// * For enumerations, the type may implement this
///   trait if the discriminant is absent *or* if
///   all, possible values are assigned to variants
///   and all fields of these variants support the
///   same semantics as this trait as well.
/// * For unions, the type may otherwise always
///   implement this trait.
///
/// (Padding bytes have fully undefined values and
/// do therefore not have invariants; so these are
/// always considered as fields implementing this
/// trait.)
///
/// 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 = "FromBytes")]
pub unsafe trait FromOctets: Zeroable {
	/// Copies an object from octets.
	///
	/// *This operation is semantically identical to the
	/// [`transmute_copy`] global function.*
	#[inline(always)]
	#[must_use]
	fn copy_from_octets(octets: &[u8]) -> Self
	where
		Self: Sized,
	{
		transmute_copy(octets)
	}

	/// Reinterprets octets as a reference.
	///
	/// The referenced object is considered initialised.
	///
	/// *This operation is semantically identical to the
	/// [`transmute_ref`] global function.*
	///
	/// # 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(always)]
	#[must_use]
	fn ref_from_octets(octets: &[u8]) -> &Self
	where
		Self: Immutable + Outlay,
	{
		transmute_ref::<[u8], Self>(octets)
	}

	/// Reinterprets octets as a mutable reference.
	///
	/// The referenced object is considered initialised.
	///
	/// *This operation is semantically identical to the
	/// [`transmute_mut`] global function.*
	///
	/// # 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(always)]
	#[must_use]
	fn mut_from_octets(octets: &mut [u8]) -> &mut Self
	where
		Self: IntoOctets + Outlay,
	{
		transmute_mut::<[u8], Self>(octets)
	}
}

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

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

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

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

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

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

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

// FIXME: Require `T: Thin` instead of `T: Sized`.
//
// SAFETY: See safety note for `*mut _`.
#[cfg(target_has_atomic = "ptr")]
unsafe impl<T> FromOctets for AtomicPtr<T> {}

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

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

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

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

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

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

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

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 {}

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

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

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

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

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

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

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

#[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 {}

#[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 {}

#[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 {}

#[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 {}

#[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 {}

#[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 {}

#[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 {}

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

unsafe impl<T> FromOctets for MaybeUninit<T> {}

// unsafe impl FromOctets for ! {}

// SAFETY: See safety note for `*mut _`.
//
// FIXME: Require `T: Thin` instead of `T: Sized`.
unsafe impl<T> FromOctets for Option<NonNull<T>> {}

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

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

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

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

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

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

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

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

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

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

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

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

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

unsafe impl FromOctets for PhantomPinned {}

// FIXME: Require `T: Thin` instead of `T: Sized`.
//
// SAFETY: See safety note for `*mut _`.
unsafe impl<T> FromOctets for *const T {}

// FIXME: Require `T: Thin` instead of `T: Sized`.
//
// SAFETY: (Thin) pointers may be constructed from
// any integral representation: [0]
//
// > ... integers can be converted to pointers and
// > back without any loss (via `as` casts or via
// > `transmute`).
//
// Thus, there shouldn't be any issues with doing
// this transmutation for thin pointers. Note, how-
// ever, that pointers constructed this away can
// only be used for volatile operations outside of
// Rust's memory model.
//
// BUT, consider: Is this idiot-proof? Maybe, as
// `IntoOctets` is still not implemented for point-
// ers, so an e.g. structure-to-bytes-to-structure
// transmutation is not possible... In any case, I
// personally need this implementation, and it
// isn't unsound (it just adds more food for though
// when using pointers.)
//
// [0]: The Rust Standard Library, core::mem::transmute
unsafe impl<T> FromOctets for *mut T {}

#[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 {}

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

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

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

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

unsafe impl FromOctets for str {}

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

#[doc(hidden)]
unsafe impl<T0, T1> FromOctets for (T0, T1)
where
	T0: FromOctets,
	T1: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2> FromOctets for (T0, T1, T2)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3> FromOctets for (T0, T1, T2, T3)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4> FromOctets for (T0, T1, T2, T3, T4)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
	T4: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5> FromOctets for (T0, T1, T2, T3, T4, T5)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
	T4: FromOctets,
	T5: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6> FromOctets for (T0, T1, T2, T3, T4, T5, T6)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
	T4: FromOctets,
	T5: FromOctets,
	T6: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7> FromOctets for (T0, T1, T2, T3, T4, T5, T6, T7)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
	T4: FromOctets,
	T5: FromOctets,
	T6: FromOctets,
	T7: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8> FromOctets for (T0, T1, T2, T3, T4, T5, T6, T7, T8)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
	T4: FromOctets,
	T5: FromOctets,
	T6: FromOctets,
	T7: FromOctets,
	T8: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9> FromOctets for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9)
where
	T0: FromOctets,
	T1: FromOctets,
	T2: FromOctets,
	T3: FromOctets,
	T4: FromOctets,
	T5: FromOctets,
	T6: FromOctets,
	T7: FromOctets,
	T8: FromOctets,
	T9: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10> FromOctets for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10)
where
	T0:  FromOctets,
	T1:  FromOctets,
	T2:  FromOctets,
	T3:  FromOctets,
	T4:  FromOctets,
	T5:  FromOctets,
	T6:  FromOctets,
	T7:  FromOctets,
	T8:  FromOctets,
	T9:  FromOctets,
	T10: FromOctets,
{}

#[doc(hidden)]
unsafe impl<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11> FromOctets for (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11)
where
	T0:  FromOctets,
	T1:  FromOctets,
	T2:  FromOctets,
	T3:  FromOctets,
	T4:  FromOctets,
	T5:  FromOctets,
	T6:  FromOctets,
	T7:  FromOctets,
	T8:  FromOctets,
	T9:  FromOctets,
	T10: FromOctets,
	T11: FromOctets,
{}

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 {}

unsafe impl FromOctets for () {}

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

unsafe impl FromOctets for usize {}

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

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