Struct `U128`

struct U128<O>(_, _)

A 128-bit unsigned integer stored in a given byte order.

U128 is like the native u128 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 U128 can be constructed using the new method, and its contained value can be obtained as a native u128 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 U128 has endianness O and that, b) the layout of u128 has the platform's native endianness.

U128 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> U128<O>`

const fn from_bytes(bytes: [u8; 16]) -> U128<O>

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

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

Extracts the bytes of self without swapping the byte order.

The returned bytes will be in O byte order.

`impl<O: ByteOrder> U128<O>`

const fn new(n: u128) -> U128<O>: Constructs a new value, possibly performing an endianness swap to guarantee that the returned value has endianness O.
const fn get(self: Self) -> u128: 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: u128): 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 U128<O>`

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

`impl<O> AsRef for U128<O>`

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

`impl<O> Default for U128<O>`

fn default() -> U128<O>

`impl<O> Freeze for U128<O>`

`impl<O> FromBytes for U128<O>`

`impl<O> FromZeros for U128<O>`

`impl<O> Immutable for U128<O>`

`impl<O> IntoBytes for U128<O>`

`impl<O> KnownLayout for U128<O>`

`impl<O> Not for U128<O>`

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

`impl<O> PartialEq for U128<O>`

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

`impl<O> RefUnwindSafe for U128<O>`

`impl<O> Send for U128<O>`

`impl<O> StructuralPartialEq for U128<O>`

`impl<O> Sync for U128<O>`

`impl<O> TryFromBytes for U128<O>`

`impl<O> Unaligned for U128<O>`

`impl<O> Unpin for U128<O>`

`impl<O> UnsafeUnpin for U128<O>`

`impl<O> UnwindSafe for U128<O>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn from(x: u128) -> U128<O>

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

fn from(bytes: [u8; 16]) -> U128<O>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn from(x: U16<O>) -> U128

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

fn from(x: U32<O>) -> U128

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

fn from(x: U64<O>) -> U128

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

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

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

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

`impl<T, U> Into for U128<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 U128<O>`

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

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

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