Struct Usize

#[repr(transparent)]
pub struct Usize<O>(/* private field */, /* private field */);

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 ZERO: Usize<O> = _;

The value zero.

This constant should be preferred to constructing a new value using new, as new may perform an endianness swap depending on the endianness and platform.

const MAX_VALUE: Usize<O> = _;

The maximum value.

This constant should be preferred to constructing a new value using new, as new may perform an endianness swap depending on the endianness O and the endianness of the platform.

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) -> [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) -> 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(&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.

Trait Implementations

impl<O> AsMut<[u8; 8]> for Usize<O>

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

impl<O> AsRef<[u8; 8]> for Usize<O>

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

impl<O> Default for Usize<O>

fn default() -> Usize<O>

impl<O> FromBytes for Usize<O> where [u8; 8]: FromBytes, PhantomData<O>: FromBytes,

impl<O> FromZeros for Usize<O> where [u8; 8]: FromZeros, PhantomData<O>: FromZeros,

impl<O> Immutable for Usize<O> where [u8; 8]: Immutable, PhantomData<O>: Immutable,

impl<O> IntoBytes for Usize<O> where [u8; 8]: IntoBytes, PhantomData<O>: IntoBytes,

impl<O> KnownLayout for Usize<O> where Self: Sized,

type PointerMetadata = ();

impl<O> Not for Usize<O>

type Output = Usize<O>;
fn not(self) -> Usize<O>

impl<O> PartialEq<[u8; 8]> for Usize<O>

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

impl<O> TryFromBytes for Usize<O> where [u8; 8]: TryFromBytes, PhantomData<O>: TryFromBytes,

impl<O> Unaligned for Usize<O> where [u8; 8]: Unaligned, PhantomData<O>: Unaligned,

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

type Output = Usize<O>;
fn add(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn add(self, rhs: usize) -> Usize<O>

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

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

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

fn add_assign(&mut self, rhs: usize)

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

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

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

type Output = Usize<O>;
fn bitand(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn bitand(self, rhs: usize) -> Usize<O>

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

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

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

fn bitand_assign(&mut self, rhs: usize)

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

type Output = Usize<O>;
fn bitor(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn bitor(self, rhs: usize) -> Usize<O>

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

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

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

fn bitor_assign(&mut self, rhs: usize)

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

type Output = Usize<O>;
fn bitxor(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn bitxor(self, rhs: usize) -> Usize<O>

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

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

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

fn bitxor_assign(&mut self, rhs: usize)

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

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

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

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

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

type Output = Usize<O>;
fn div(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn div(self, rhs: usize) -> Usize<O>

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

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

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

fn div_assign(&mut self, rhs: usize)

impl<O: ByteOrder> From<[u8; 8]> for Usize<O>

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

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

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

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

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

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

type Output = Usize<O>;
fn mul(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn mul(self, rhs: usize) -> Usize<O>

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

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

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

fn mul_assign(&mut self, rhs: usize)

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

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

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

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

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

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

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

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

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

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

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

type Output = Usize<O>;
fn rem(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn rem(self, rhs: usize) -> Usize<O>

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

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

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

fn rem_assign(&mut self, rhs: usize)

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

type Output = Usize<O>;
fn shl(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn shl(self, rhs: usize) -> Usize<O>

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

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

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

fn shl_assign(&mut self, rhs: usize)

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

type Output = Usize<O>;
fn shr(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn shr(self, rhs: usize) -> Usize<O>

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

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

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

fn shr_assign(&mut self, rhs: usize)

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

type Output = Usize<O>;
fn sub(self, rhs: Usize<O>) -> Usize<O>

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

type Output = Usize<O>;
fn sub(self, rhs: usize) -> Usize<O>

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

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

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

fn sub_assign(&mut self, rhs: usize)

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

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

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

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

impl<O: Clone> Clone for Usize<O>

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

impl<O: Copy> Copy for Usize<O>

impl<O: Eq> Eq for Usize<O>

impl<O: Hash> Hash for Usize<O>

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

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

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

impl<O: PartialEq> StructuralPartialEq for Usize<O>

Auto Trait Implementations

impl<O> Freeze for Usize<O> where PhantomData<O>: Freeze,

impl<O> RefUnwindSafe for Usize<O> where PhantomData<O>: RefUnwindSafe,

impl<O> Send for Usize<O> where PhantomData<O>: Send,

impl<O> Sync for Usize<O> where PhantomData<O>: Sync,

impl<O> Unpin for Usize<O> where PhantomData<O>: Unpin,

impl<O> UnsafeUnpin for Usize<O> where PhantomData<O>: UnsafeUnpin,

impl<O> UnwindSafe for Usize<O> where PhantomData<O>: UnwindSafe,

Blanket Implementations

impl<T> Any for Usize<O> where T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Usize<O> where T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Usize<O> where T: ?Sized,

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

impl<T> CloneToUninit for Usize<O> where T: Clone,

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

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

fn from(t: T) -> T

Returns the argument unchanged.

impl<T, U> Into<U> for Usize<O> where U: From<T>,

fn into(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<U> for Usize<O> where U: Into<T>,

type Error = never;
fn try_from(value: U) -> Result<T, never>

impl<T, U> TryInto<U> for Usize<O> where U: TryFrom<T>,

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