pub type NonZeroU16 = NonZero<u16>;
Expand description
A u16
that is known not to equal zero.
This enables some memory layout optimization.
For example, Option<NonZeroU16>
is the same size as u16
:
use std::mem::size_of;
assert_eq!(size_of::<Option<core::num::NonZeroU16>>(), size_of::<u16>());
§Layout
NonZeroU16
is guaranteed to have the same layout and bit validity as u16
with the exception that 0
is not a valid instance.
Option<NonZeroU16>
is guaranteed to be compatible with u16
,
including in FFI.
Thanks to the null pointer optimization,
NonZeroU16
and Option<NonZeroU16>
are guaranteed to have the same size and alignment:
use std::num::NonZeroU16;
assert_eq!(size_of::<NonZeroU16>(), size_of::<Option<NonZeroU16>>());
assert_eq!(align_of::<NonZeroU16>(), align_of::<Option<NonZeroU16>>());
Aliased Type§
struct NonZeroU16(/* private fields */);
Implementations
Source§impl<T> NonZero<T>where
T: ZeroablePrimitive,
impl<T> NonZero<T>where
T: ZeroablePrimitive,
1.28.0 (const: 1.47.0) · Sourcepub const fn new(n: T) -> Option<NonZero<T>>
pub const fn new(n: T) -> Option<NonZero<T>>
Creates a non-zero if the given value is not zero.
1.28.0 (const: 1.28.0) · Sourcepub const unsafe fn new_unchecked(n: T) -> NonZero<T>
pub const unsafe fn new_unchecked(n: T) -> NonZero<T>
Creates a non-zero without checking whether the value is non-zero. This results in undefined behavior if the value is zero.
§Safety
The value must not be zero.
Sourcepub fn from_mut(n: &mut T) -> Option<&mut NonZero<T>>
🔬This is a nightly-only experimental API. (nonzero_from_mut
)
pub fn from_mut(n: &mut T) -> Option<&mut NonZero<T>>
nonzero_from_mut
)Converts a reference to a non-zero mutable reference if the referenced value is not zero.
Sourcepub unsafe fn from_mut_unchecked(n: &mut T) -> &mut NonZero<T>
🔬This is a nightly-only experimental API. (nonzero_from_mut
)
pub unsafe fn from_mut_unchecked(n: &mut T) -> &mut NonZero<T>
nonzero_from_mut
)Converts a mutable reference to a non-zero mutable reference without checking whether the referenced value is non-zero. This results in undefined behavior if the referenced value is zero.
§Safety
The referenced value must not be zero.
Source§impl NonZero<u16>
impl NonZero<u16>
Sourcepub const fn div_ceil(self, rhs: NonZero<u16>) -> NonZero<u16>
🔬This is a nightly-only experimental API. (unsigned_nonzero_div_ceil
)
pub const fn div_ceil(self, rhs: NonZero<u16>) -> NonZero<u16>
unsigned_nonzero_div_ceil
)Calculates the quotient of self
and rhs
, rounding the result towards positive infinity.
The result is guaranteed to be non-zero.
§Examples
let one = NonZero::new(1u16).unwrap();
let max = NonZero::new(u16::MAX).unwrap();
assert_eq!(one.div_ceil(max), one);
let two = NonZero::new(2u16).unwrap();
let three = NonZero::new(3u16).unwrap();
assert_eq!(three.div_ceil(two), two);
Source§impl NonZero<u16>
impl NonZero<u16>
1.70.0 · Sourcepub const MIN: NonZero<u16>
pub const MIN: NonZero<u16>
The smallest value that can be represented by this non-zero integer type, 1.
§Examples
assert_eq!(NonZero::<u16>::MIN.get(), 1u16);
1.53.0 (const: 1.53.0) · Sourcepub const fn leading_zeros(self) -> u32
pub const fn leading_zeros(self) -> u32
Returns the number of leading zeros in the binary representation of self
.
On many architectures, this function can perform better than leading_zeros()
on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u16>::new(u16::MAX)?;
assert_eq!(n.leading_zeros(), 0);
1.53.0 (const: 1.53.0) · Sourcepub const fn trailing_zeros(self) -> u32
pub const fn trailing_zeros(self) -> u32
Returns the number of trailing zeros in the binary representation
of self
.
On many architectures, this function can perform better than trailing_zeros()
on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let n = NonZero::<u16>::new(0b0101000)?;
assert_eq!(n.trailing_zeros(), 3);
Sourcepub const fn isolate_most_significant_one(self) -> NonZero<u16>
🔬This is a nightly-only experimental API. (isolate_most_least_significant_one
)
pub const fn isolate_most_significant_one(self) -> NonZero<u16>
isolate_most_least_significant_one
)Returns self
with only the most significant bit set.
§Example
Basic usage:
#![feature(isolate_most_least_significant_one)]
let a = NonZero::<u16>::new(0b_01100100)?;
let b = NonZero::<u16>::new(0b_01000000)?;
assert_eq!(a.isolate_most_significant_one(), b);
Sourcepub const fn isolate_least_significant_one(self) -> NonZero<u16>
🔬This is a nightly-only experimental API. (isolate_most_least_significant_one
)
pub const fn isolate_least_significant_one(self) -> NonZero<u16>
isolate_most_least_significant_one
)Returns self
with only the least significant bit set.
§Example
Basic usage:
#![feature(isolate_most_least_significant_one)]
let a = NonZero::<u16>::new(0b_01100100)?;
let b = NonZero::<u16>::new(0b_00000100)?;
assert_eq!(a.isolate_least_significant_one(), b);
1.86.0 (const: 1.86.0) · Sourcepub const fn count_ones(self) -> NonZero<u32>
pub const fn count_ones(self) -> NonZero<u32>
Returns the number of ones in the binary representation of self
.
§Examples
Basic usage:
let a = NonZero::<u16>::new(0b100_0000)?;
let b = NonZero::<u16>::new(0b100_0011)?;
assert_eq!(a.count_ones(), NonZero::new(1)?);
assert_eq!(b.count_ones(), NonZero::new(3)?);
Sourcepub const fn rotate_left(self, n: u32) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn rotate_left(self, n: u32) -> NonZero<u16>
nonzero_bitwise
)Shifts the bits to the left by a specified amount, n
,
wrapping the truncated bits to the end of the resulting integer.
Please note this isn’t the same operation as the <<
shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0xa003u16)?;
let m = NonZero::new(0x3a)?;
assert_eq!(n.rotate_left(4), m);
Sourcepub const fn rotate_right(self, n: u32) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn rotate_right(self, n: u32) -> NonZero<u16>
nonzero_bitwise
)Shifts the bits to the right by a specified amount, n
,
wrapping the truncated bits to the beginning of the resulting
integer.
Please note this isn’t the same operation as the >>
shifting operator!
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x3au16)?;
let m = NonZero::new(0xa003)?;
assert_eq!(n.rotate_right(4), m);
Sourcepub const fn swap_bytes(self) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn swap_bytes(self) -> NonZero<u16>
nonzero_bitwise
)Reverses the byte order of the integer.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234u16)?;
let m = n.swap_bytes();
assert_eq!(m, NonZero::new(0x3412)?);
Sourcepub const fn reverse_bits(self) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn reverse_bits(self) -> NonZero<u16>
nonzero_bitwise
)Reverses the order of bits in the integer. The least significant bit becomes the most significant bit, second least-significant bit becomes second most-significant bit, etc.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1234u16)?;
let m = n.reverse_bits();
assert_eq!(m, NonZero::new(0x2c48)?);
Sourcepub const fn from_be(x: NonZero<u16>) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn from_be(x: NonZero<u16>) -> NonZero<u16>
nonzero_bitwise
)Converts an integer from big endian to the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU16;
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "big") {
assert_eq!(NonZeroU16::from_be(n), n)
} else {
assert_eq!(NonZeroU16::from_be(n), n.swap_bytes())
}
Sourcepub const fn from_le(x: NonZero<u16>) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn from_le(x: NonZero<u16>) -> NonZero<u16>
nonzero_bitwise
)Converts an integer from little endian to the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
use std::num::NonZeroU16;
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "little") {
assert_eq!(NonZeroU16::from_le(n), n)
} else {
assert_eq!(NonZeroU16::from_le(n), n.swap_bytes())
}
Sourcepub const fn to_be(self) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn to_be(self) -> NonZero<u16>
nonzero_bitwise
)Converts self
to big endian from the target’s endianness.
On big endian this is a no-op. On little endian the bytes are swapped.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "big") {
assert_eq!(n.to_be(), n)
} else {
assert_eq!(n.to_be(), n.swap_bytes())
}
Sourcepub const fn to_le(self) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_bitwise
)
pub const fn to_le(self) -> NonZero<u16>
nonzero_bitwise
)Converts self
to little endian from the target’s endianness.
On little endian this is a no-op. On big endian the bytes are swapped.
§Examples
Basic usage:
#![feature(nonzero_bitwise)]
let n = NonZero::new(0x1Au16)?;
if cfg!(target_endian = "little") {
assert_eq!(n.to_le(), n)
} else {
assert_eq!(n.to_le(), n.swap_bytes())
}
1.64.0 (const: 1.64.0) · Sourcepub const fn checked_add(self, other: u16) -> Option<NonZero<u16>>
pub const fn checked_add(self, other: u16) -> Option<NonZero<u16>>
Adds an unsigned integer to a non-zero value.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
§Examples
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(Some(two), one.checked_add(1));
assert_eq!(None, max.checked_add(1));
1.64.0 (const: 1.64.0) · Sourcepub const fn saturating_add(self, other: u16) -> NonZero<u16>
pub const fn saturating_add(self, other: u16) -> NonZero<u16>
Adds an unsigned integer to a non-zero value.
Return NonZero::<u16>::MAX
on overflow.
§Examples
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(two, one.saturating_add(1));
assert_eq!(max, max.saturating_add(1));
Sourcepub const unsafe fn unchecked_add(self, other: u16) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_ops
)
pub const unsafe fn unchecked_add(self, other: u16) -> NonZero<u16>
nonzero_ops
)Adds an unsigned integer to a non-zero value,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behavior to overflow
even if the result would wrap to a non-zero value.
The behavior is undefined as soon as
self + rhs > u16::MAX
.
§Examples
#![feature(nonzero_ops)]
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
assert_eq!(two, unsafe { one.unchecked_add(1) });
1.64.0 (const: 1.64.0) · Sourcepub const fn checked_next_power_of_two(self) -> Option<NonZero<u16>>
pub const fn checked_next_power_of_two(self) -> Option<NonZero<u16>>
Returns the smallest power of two greater than or equal to self
.
Checks for overflow and returns None
if the next power of two is greater than the type’s maximum value.
As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u16)?;
let three = NonZero::new(3u16)?;
let four = NonZero::new(4u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(Some(two), two.checked_next_power_of_two() );
assert_eq!(Some(four), three.checked_next_power_of_two() );
assert_eq!(None, max.checked_next_power_of_two() );
1.67.0 (const: 1.67.0) · Sourcepub const fn ilog2(self) -> u32
pub const fn ilog2(self) -> u32
Returns the base 2 logarithm of the number, rounded down.
This is the same operation as
u16::ilog2
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZero::new(7u16)?.ilog2(), 2);
assert_eq!(NonZero::new(8u16)?.ilog2(), 3);
assert_eq!(NonZero::new(9u16)?.ilog2(), 3);
1.67.0 (const: 1.67.0) · Sourcepub const fn ilog10(self) -> u32
pub const fn ilog10(self) -> u32
Returns the base 10 logarithm of the number, rounded down.
This is the same operation as
u16::ilog10
,
except that it has no failure cases to worry about
since this value can never be zero.
§Examples
assert_eq!(NonZero::new(99u16)?.ilog10(), 1);
assert_eq!(NonZero::new(100u16)?.ilog10(), 2);
assert_eq!(NonZero::new(101u16)?.ilog10(), 2);
1.85.0 (const: 1.85.0) · Sourcepub const fn midpoint(self, rhs: NonZero<u16>) -> NonZero<u16>
pub const fn midpoint(self, rhs: NonZero<u16>) -> NonZero<u16>
Calculates the middle point of self
and rhs
.
midpoint(a, b)
is (a + b) >> 1
as if it were performed in a
sufficiently-large signed integral type. This implies that the result is
always rounded towards negative infinity and that no overflow will ever occur.
§Examples
let one = NonZero::new(1u16)?;
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
assert_eq!(one.midpoint(four), two);
assert_eq!(four.midpoint(one), two);
1.59.0 (const: 1.59.0) · Sourcepub const fn is_power_of_two(self) -> bool
pub const fn is_power_of_two(self) -> bool
Returns true
if and only if self == (1 << k)
for some k
.
On many architectures, this function can perform better than is_power_of_two()
on the underlying integer type, as special handling of zero can be avoided.
§Examples
Basic usage:
let eight = NonZero::new(8u16)?;
assert!(eight.is_power_of_two());
let ten = NonZero::new(10u16)?;
assert!(!ten.is_power_of_two());
1.84.0 (const: 1.84.0) · Sourcepub const fn isqrt(self) -> NonZero<u16>
pub const fn isqrt(self) -> NonZero<u16>
Returns the square root of the number, rounded down.
§Examples
Basic usage:
let ten = NonZero::new(10u16)?;
let three = NonZero::new(3u16)?;
assert_eq!(ten.isqrt(), three);
1.87.0 (const: 1.87.0) · Sourcepub const fn cast_signed(self) -> NonZero<i16>
pub const fn cast_signed(self) -> NonZero<i16>
Returns the bit pattern of self
reinterpreted as a signed integer of the same size.
§Examples
Basic usage:
let n = NonZero::<u16>::MAX;
assert_eq!(n.cast_signed(), NonZero::new(-1i16).unwrap());
1.64.0 (const: 1.64.0) · Sourcepub const fn checked_mul(self, other: NonZero<u16>) -> Option<NonZero<u16>>
pub const fn checked_mul(self, other: NonZero<u16>) -> Option<NonZero<u16>>
Multiplies two non-zero integers together.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
§Examples
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(Some(four), two.checked_mul(two));
assert_eq!(None, max.checked_mul(two));
1.64.0 (const: 1.64.0) · Sourcepub const fn saturating_mul(self, other: NonZero<u16>) -> NonZero<u16>
pub const fn saturating_mul(self, other: NonZero<u16>) -> NonZero<u16>
Multiplies two non-zero integers together.
Return NonZero::<u16>::MAX
on overflow.
§Examples
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(four, two.saturating_mul(two));
assert_eq!(max, four.saturating_mul(max));
Sourcepub const unsafe fn unchecked_mul(self, other: NonZero<u16>) -> NonZero<u16>
🔬This is a nightly-only experimental API. (nonzero_ops
)
pub const unsafe fn unchecked_mul(self, other: NonZero<u16>) -> NonZero<u16>
nonzero_ops
)Multiplies two non-zero integers together,
assuming overflow cannot occur.
Overflow is unchecked, and it is undefined behavior to overflow
even if the result would wrap to a non-zero value.
The behavior is undefined as soon as
self * rhs > u16::MAX
.
§Examples
#![feature(nonzero_ops)]
let two = NonZero::new(2u16)?;
let four = NonZero::new(4u16)?;
assert_eq!(four, unsafe { two.unchecked_mul(two) });
1.64.0 (const: 1.64.0) · Sourcepub const fn checked_pow(self, other: u32) -> Option<NonZero<u16>>
pub const fn checked_pow(self, other: u32) -> Option<NonZero<u16>>
Raises non-zero value to an integer power.
Checks for overflow and returns None
on overflow.
As a consequence, the result cannot wrap to zero.
§Examples
let three = NonZero::new(3u16)?;
let twenty_seven = NonZero::new(27u16)?;
let half_max = NonZero::new(u16::MAX / 2)?;
assert_eq!(Some(twenty_seven), three.checked_pow(3));
assert_eq!(None, half_max.checked_pow(3));
1.64.0 (const: 1.64.0) · Sourcepub const fn saturating_pow(self, other: u32) -> NonZero<u16>
pub const fn saturating_pow(self, other: u32) -> NonZero<u16>
Raise non-zero value to an integer power.
Return NonZero::<u16>::MAX
on overflow.
§Examples
let three = NonZero::new(3u16)?;
let twenty_seven = NonZero::new(27u16)?;
let max = NonZero::new(u16::MAX)?;
assert_eq!(twenty_seven, three.saturating_pow(3));
assert_eq!(max, max.saturating_pow(3));
Trait Implementations
Source§impl AsBytes for NonZero<u16>
impl AsBytes for NonZero<u16>
1.45.0 · Source§impl<T> BitOrAssign<T> for NonZero<T>
impl<T> BitOrAssign<T> for NonZero<T>
Source§fn bitor_assign(&mut self, rhs: T)
fn bitor_assign(&mut self, rhs: T)
|=
operation. Read more1.45.0 · Source§impl<T> BitOrAssign for NonZero<T>
impl<T> BitOrAssign for NonZero<T>
Source§fn bitor_assign(&mut self, rhs: NonZero<T>)
fn bitor_assign(&mut self, rhs: NonZero<T>)
|=
operation. Read more1.28.0 · Source§impl<T> Clone for NonZero<T>where
T: ZeroablePrimitive,
impl<T> Clone for NonZero<T>where
T: ZeroablePrimitive,
1.31.0 · Source§impl<T> From<NonZero<T>> for Twhere
T: ZeroablePrimitive,
impl<T> From<NonZero<T>> for Twhere
T: ZeroablePrimitive,
Source§impl IntoBytes for NonZero<u16>
impl IntoBytes for NonZero<u16>
Source§fn as_mut_bytes(&mut self) -> &mut [u8] ⓘwhere
Self: FromBytes,
fn as_mut_bytes(&mut self) -> &mut [u8] ⓘwhere
Self: FromBytes,
Source§fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>where
Self: Immutable,
fn write_to(&self, dst: &mut [u8]) -> Result<(), SizeError<&Self, &mut [u8]>>where
Self: Immutable,
Source§impl KnownLayout for NonZero<u16>
impl KnownLayout for NonZero<u16>
Source§type PointerMetadata = ()
type PointerMetadata = ()
Self
. Read more1.28.0 · Source§impl<T> Ord for NonZero<T>where
T: ZeroablePrimitive + Ord,
impl<T> Ord for NonZero<T>where
T: ZeroablePrimitive + Ord,
1.28.0 · Source§impl<T> PartialOrd for NonZero<T>where
T: ZeroablePrimitive + PartialOrd,
impl<T> PartialOrd for NonZero<T>where
T: ZeroablePrimitive + PartialOrd,
Source§impl TryFromBytes for NonZero<u16>
impl TryFromBytes for NonZero<u16>
Source§fn try_ref_from_bytes(
source: &[u8],
) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>where
Self: KnownLayout + Immutable,
fn try_ref_from_bytes(
source: &[u8],
) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>where
Self: KnownLayout + Immutable,
Source§fn try_ref_from_prefix(
source: &[u8],
) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>where
Self: KnownLayout + Immutable,
fn try_ref_from_prefix(
source: &[u8],
) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>where
Self: KnownLayout + Immutable,
Source§fn try_ref_from_suffix(
source: &[u8],
) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>where
Self: KnownLayout + Immutable,
fn try_ref_from_suffix(
source: &[u8],
) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>where
Self: KnownLayout + Immutable,
Source§fn try_mut_from_bytes(
bytes: &mut [u8],
) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>where
Self: KnownLayout + IntoBytes,
fn try_mut_from_bytes(
bytes: &mut [u8],
) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>where
Self: KnownLayout + IntoBytes,
Source§fn try_mut_from_prefix(
source: &mut [u8],
) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>where
Self: KnownLayout + IntoBytes,
fn try_mut_from_prefix(
source: &mut [u8],
) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>where
Self: KnownLayout + IntoBytes,
Source§fn try_mut_from_suffix(
source: &mut [u8],
) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>where
Self: KnownLayout + IntoBytes,
fn try_mut_from_suffix(
source: &mut [u8],
) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>where
Self: KnownLayout + IntoBytes,
Source§fn try_ref_from_bytes_with_elems(
source: &[u8],
count: usize,
) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_bytes_with_elems( source: &[u8], count: usize, ) -> Result<&Self, ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
Source§fn try_ref_from_prefix_with_elems(
source: &[u8],
count: usize,
) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_prefix_with_elems( source: &[u8], count: usize, ) -> Result<(&Self, &[u8]), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
source
as a &Self
with
a DST length equal to count
. Read moreSource§fn try_ref_from_suffix_with_elems(
source: &[u8],
count: usize,
) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
fn try_ref_from_suffix_with_elems( source: &[u8], count: usize, ) -> Result<(&[u8], &Self), ConvertError<AlignmentError<&[u8], Self>, SizeError<&[u8], Self>, ValidityError<&[u8], Self>>>
source
as a &Self
with
a DST length equal to count
. Read moreSource§fn try_mut_from_bytes_with_elems(
source: &mut [u8],
count: usize,
) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_bytes_with_elems( source: &mut [u8], count: usize, ) -> Result<&mut Self, ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
Source§fn try_mut_from_prefix_with_elems(
source: &mut [u8],
count: usize,
) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_prefix_with_elems( source: &mut [u8], count: usize, ) -> Result<(&mut Self, &mut [u8]), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
source
as a &mut Self
with a DST length equal to count
. Read moreSource§fn try_mut_from_suffix_with_elems(
source: &mut [u8],
count: usize,
) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
fn try_mut_from_suffix_with_elems( source: &mut [u8], count: usize, ) -> Result<(&mut [u8], &mut Self), ConvertError<AlignmentError<&mut [u8], Self>, SizeError<&mut [u8], Self>, ValidityError<&mut [u8], Self>>>
source
as a &mut Self
with a DST length equal to count
. Read more