Struct `I16`

struct I16<O>(_, _)

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

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

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

const fn from_bytes(bytes: [u8; 2]) -> I16<O>

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

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

Extracts the bytes of self without swapping the byte order.

The returned bytes will be in O byte order.

`impl<O: ByteOrder> I16<O>`

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

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

`impl<O> AsRef for I16<O>`

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

`impl<O> Default for I16<O>`

fn default() -> I16<O>

`impl<O> Freeze for I16<O>`

`impl<O> FromBytes for I16<O>`

`impl<O> FromZeros for I16<O>`

`impl<O> Immutable for I16<O>`

`impl<O> IntoBytes for I16<O>`

`impl<O> KnownLayout for I16<O>`

`impl<O> Not for I16<O>`

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

`impl<O> PartialEq for I16<O>`

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

`impl<O> RefUnwindSafe for I16<O>`

`impl<O> Send for I16<O>`

`impl<O> StructuralPartialEq for I16<O>`

`impl<O> Sync for I16<O>`

`impl<O> TryFromBytes for I16<O>`

`impl<O> Unaligned for I16<O>`

`impl<O> Unpin for I16<O>`

`impl<O> UnsafeUnpin for I16<O>`

`impl<O> UnwindSafe for I16<O>`

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn from(bytes: [u8; 2]) -> I16<O>

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

fn try_from(x: isize) -> Result<I16<O>, TryFromIntError>

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

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

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

fn try_from(x: i64) -> Result<I16<O>, TryFromIntError>

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

fn try_from(x: i32) -> Result<I16<O>, TryFromIntError>

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

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

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

fn try_from(x: Isize) -> Result<I16<O>, TryFromIntError>

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

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

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

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

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

fn try_from(x: I32) -> Result<I16<O>, TryFromIntError>

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

fn type_id(self: &Self) -> TypeId

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

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

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

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

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

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

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

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

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

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

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

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