Struct `Isize`

struct Isize<O>(_, _)

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

Isize is like the native isize 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.

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

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

const fn from_bytes(bytes: [u8; 8]) -> Isize<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> Isize<O>`

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

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

`impl<O> AsRef for Isize<O>`

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

`impl<O> Default for Isize<O>`

fn default() -> Isize<O>

`impl<O> Freeze for Isize<O>`

`impl<O> FromBytes for Isize<O>`

`impl<O> FromZeros for Isize<O>`

`impl<O> Immutable for Isize<O>`

`impl<O> IntoBytes for Isize<O>`

`impl<O> KnownLayout for Isize<O>`

`impl<O> Not for Isize<O>`

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

`impl<O> PartialEq for Isize<O>`

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

`impl<O> RefUnwindSafe for Isize<O>`

`impl<O> Send for Isize<O>`

`impl<O> StructuralPartialEq for Isize<O>`

`impl<O> Sync for Isize<O>`

`impl<O> TryFromBytes for Isize<O>`

`impl<O> Unaligned for Isize<O>`

`impl<O> Unpin for Isize<O>`

`impl<O> UnsafeUnpin for Isize<O>`

`impl<O> UnwindSafe for Isize<O>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn from(x: isize) -> Isize<O>

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

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

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

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

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

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

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

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

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

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

`impl<O: ByteOrder> Neg for Isize<O>`

fn neg(self: Self) -> Isize<O>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn from(x: I16<O>) -> Isize<P>

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

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

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

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

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

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

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

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