Struct `Usize`

struct Usize<O>(_, _)

A word-sized unsigned integer stored in a given byte order.

Usize is like the native usize type with two major differences: First, it has no alignment requirement (its alignment is 1). Second, the endianness of its memory layout is given by the type parameter O, which can be any type which implements ByteOrder. In particular, this refers to BigEndian, LittleEndian, NativeEndian, and NetworkEndian.

A Usize can be constructed using the new method, and its contained value can be obtained as a native usize using the get method, or updated in place with the set method. In all cases, if the endianness O is not the same as the endianness of the current platform, an endianness swap will be performed in order to uphold the invariants that a) the layout of Usize has endianness O and that, b) the layout of usize has the platform's native endianness.

Usize implements FromBytes, IntoBytes, and Unaligned, making it useful for parsing and serialization. See the module documentation for an example of how it can be used for parsing UDP packets.

Implementations

`impl<O> Usize<O>`

const fn from_bytes(bytes: [u8; 8]) -> Usize<O>

Constructs a new value from bytes which are already in O byte order.

const fn to_bytes(self: Self) -> [u8; 8]

Extracts the bytes of self without swapping the byte order.

The returned bytes will be in O byte order.

`impl<O: ByteOrder> Usize<O>`

const fn new(n: usize) -> Usize<O>: Constructs a new value, possibly performing an endianness swap to guarantee that the returned value has endianness O.
const fn get(self: Self) -> usize: Returns the value as a primitive type, possibly performing an endianness swap to guarantee that the return value has the endianness of the native platform.
fn set(self: &mut Self, n: usize): Updates the value in place as a primitive type, possibly performing an endianness swap to guarantee that the stored value has the endianness O.

`impl<O> AsMut for Usize<O>`

fn as_mut(self: &mut Self) -> &mut [u8; 8]

`impl<O> AsRef for Usize<O>`

fn as_ref(self: &Self) -> &[u8; 8]

`impl<O> Default for Usize<O>`

fn default() -> Usize<O>

`impl<O> Freeze for Usize<O>`

`impl<O> FromBytes for Usize<O>`

`impl<O> FromZeros for Usize<O>`

`impl<O> Immutable for Usize<O>`

`impl<O> IntoBytes for Usize<O>`

`impl<O> KnownLayout for Usize<O>`

`impl<O> Not for Usize<O>`

fn not(self: Self) -> Usize<O>

`impl<O> PartialEq for Usize<O>`

fn eq(self: &Self, other: &[u8; 8]) -> bool

`impl<O> RefUnwindSafe for Usize<O>`

`impl<O> Send for Usize<O>`

`impl<O> StructuralPartialEq for Usize<O>`

`impl<O> Sync for Usize<O>`

`impl<O> TryFromBytes for Usize<O>`

`impl<O> Unaligned for Usize<O>`

`impl<O> Unpin for Usize<O>`

`impl<O> UnsafeUnpin for Usize<O>`

`impl<O> UnwindSafe for Usize<O>`

`impl<O: $crate::clone::Clone> Clone for Usize<O>`

fn clone(self: &Self) -> Usize<O>

`impl<O: $crate::cmp::Eq> Eq for Usize<O>`

`impl<O: $crate::cmp::PartialEq> PartialEq for Usize<O>`

fn eq(self: &Self, other: &Usize<O>) -> bool

`impl<O: $crate::hash::Hash> Hash for Usize<O>`

fn hash<__H: $crate::hash::Hasher>(self: &Self, state: &mut __H)

`impl<O: $crate::marker::Copy> Copy for Usize<O>`

`impl<O: ByteOrder> Add for Usize<O>`

fn add(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> Add for Usize<O>`

fn add(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> AddAssign for Usize<O>`

fn add_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> AddAssign for Usize<O>`

fn add_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> Binary for Usize<O>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<O: ByteOrder> BitAnd for Usize<O>`

fn bitand(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> BitAnd for Usize<O>`

fn bitand(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> BitAndAssign for Usize<O>`

fn bitand_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> BitAndAssign for Usize<O>`

fn bitand_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> BitOr for Usize<O>`

fn bitor(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> BitOr for Usize<O>`

fn bitor(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> BitOrAssign for Usize<O>`

fn bitor_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> BitOrAssign for Usize<O>`

fn bitor_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> BitXor for Usize<O>`

fn bitxor(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> BitXor for Usize<O>`

fn bitxor(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> BitXorAssign for Usize<O>`

fn bitxor_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> BitXorAssign for Usize<O>`

fn bitxor_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> Debug for Usize<O>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<O: ByteOrder> Display for Usize<O>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<O: ByteOrder> Div for Usize<O>`

fn div(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> Div for Usize<O>`

fn div(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> DivAssign for Usize<O>`

fn div_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> DivAssign for Usize<O>`

fn div_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> From for Usize<O>`

fn from(bytes: [u8; 8]) -> Usize<O>

`impl<O: ByteOrder> From for Usize<O>`

fn from(x: usize) -> Usize<O>

`impl<O: ByteOrder> LowerHex for Usize<O>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<O: ByteOrder> Mul for Usize<O>`

fn mul(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> Mul for Usize<O>`

fn mul(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> MulAssign for Usize<O>`

fn mul_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> MulAssign for Usize<O>`

fn mul_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> Octal for Usize<O>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<O: ByteOrder> Ord for Usize<O>`

fn cmp(self: &Self, other: &Self) -> Ordering

`impl<O: ByteOrder> PartialEq for Usize<O>`

fn eq(self: &Self, other: &usize) -> bool

`impl<O: ByteOrder> PartialOrd for Usize<O>`

fn partial_cmp(self: &Self, other: &usize) -> Option<Ordering>

`impl<O: ByteOrder> PartialOrd for Usize<O>`

fn partial_cmp(self: &Self, other: &Self) -> Option<Ordering>

`impl<O: ByteOrder> Rem for Usize<O>`

fn rem(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> Rem for Usize<O>`

fn rem(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> RemAssign for Usize<O>`

fn rem_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> RemAssign for Usize<O>`

fn rem_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> Shl for Usize<O>`

fn shl(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> Shl for Usize<O>`

fn shl(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> ShlAssign for Usize<O>`

fn shl_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> ShlAssign for Usize<O>`

fn shl_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> Shr for Usize<O>`

fn shr(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> Shr for Usize<O>`

fn shr(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> ShrAssign for Usize<O>`

fn shr_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> ShrAssign for Usize<O>`

fn shr_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> Sub for Usize<O>`

fn sub(self: Self, rhs: usize) -> Usize<O>

`impl<O: ByteOrder> Sub for Usize<O>`

fn sub(self: Self, rhs: Usize<O>) -> Usize<O>

`impl<O: ByteOrder> SubAssign for Usize<O>`

fn sub_assign(self: &mut Self, rhs: Usize<O>)

`impl<O: ByteOrder> SubAssign for Usize<O>`

fn sub_assign(self: &mut Self, rhs: usize)

`impl<O: ByteOrder> UpperHex for Usize<O>`

fn fmt(self: &Self, f: &mut Formatter<'_>) -> Result

`impl<O: ByteOrder, P: ByteOrder> From for Usize<P>`

fn from(x: U16<O>) -> Usize<P>

`impl<T> Any for Usize<O>`

fn type_id(self: &Self) -> TypeId

`impl<T> Borrow for Usize<O>`

fn borrow(self: &Self) -> &T

`impl<T> BorrowMut for Usize<O>`

fn borrow_mut(self: &mut Self) -> &mut T

`impl<T> CloneToUninit for Usize<O>`

unsafe fn clone_to_uninit(self: &Self, dest: *mut u8)

`impl<T> From for Usize<O>`

fn from(t: T) -> T: Returns the argument unchanged.

`impl<T, U> Into for Usize<O>`

fn into(self: Self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of [From]<T> for U chooses to do.

`impl<T, U> TryFrom for Usize<O>`

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

`impl<T, U> TryInto for Usize<O>`

fn try_into(self: Self) -> Result<U, <U as TryFrom<T>>::Error>