Struct Isize

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

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

Trait Implementations

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

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

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

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

impl<O> Default for Isize<O>

fn default() -> Isize<O>

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

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

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

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

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

type PointerMetadata = ();

impl<O> Not for Isize<O>

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

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

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

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

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

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

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

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

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

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

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

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

fn add_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

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

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

fn bitand_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

fn bitor_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

fn bitxor_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

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

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

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

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

fn div_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

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

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

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

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

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

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

fn mul_assign(&mut self, rhs: isize)

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

type Output = Isize<O>;
fn neg(self) -> Isize<O>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn rem_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

fn shl_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

fn shr_assign(&mut self, rhs: isize)

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

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

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

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

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

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

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

fn sub_assign(&mut self, rhs: isize)

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

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

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

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

impl<O: Clone> Clone for Isize<O>

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

impl<O: Copy> Copy for Isize<O>

impl<O: Eq> Eq for Isize<O>

impl<O: Hash> Hash for Isize<O>

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

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

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

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

Auto Trait Implementations

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

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

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

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

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

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

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

Blanket Implementations

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

fn type_id(&self) -> TypeId

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

fn borrow(&self) -> &T

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

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

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

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

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

fn from(t: T) -> T

Returns the argument unchanged.

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

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

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

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