Struct `I64`

struct I64<O>(_, _)

A 64-bit signed integer stored in a given byte order.

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

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

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

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

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

`impl<O> AsRef for I64<O>`

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

`impl<O> Default for I64<O>`

fn default() -> I64<O>

`impl<O> Freeze for I64<O>`

`impl<O> FromBytes for I64<O>`

`impl<O> FromZeros for I64<O>`

`impl<O> Immutable for I64<O>`

`impl<O> IntoBytes for I64<O>`

`impl<O> KnownLayout for I64<O>`

`impl<O> Not for I64<O>`

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

`impl<O> PartialEq for I64<O>`

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

`impl<O> RefUnwindSafe for I64<O>`

`impl<O> Send for I64<O>`

`impl<O> StructuralPartialEq for I64<O>`

`impl<O> Sync for I64<O>`

`impl<O> TryFromBytes for I64<O>`

`impl<O> Unaligned for I64<O>`

`impl<O> Unpin for I64<O>`

`impl<O> UnsafeUnpin for I64<O>`

`impl<O> UnwindSafe for I64<O>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn from(x: i64) -> I64<O>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

`impl<O: ByteOrder> TryFrom for I64<O>`

fn try_from(x: i128) -> Result<I64<O>, TryFromIntError>

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

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

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

fn from(x: I32<O>) -> I64

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

fn from(x: I16<O>) -> I64

`impl<O: ByteOrder, P: ByteOrder> TryFrom for I64<O>`

fn try_from(x: I128) -> Result<I64<O>, TryFromIntError>

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

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

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

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

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

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

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

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