Struct Origin 

pub struct Origin {}

Trait Implementations

impl Allocatable<Origin> for Allocator

type Ok = Ok

type Error = Error

fn allocate(numerosity_of_bytes: usize) -> Result

Allocates memory according to the provided layout

fn deallocate(ptr: *mut Self, numerosity_of_bytes: usize) -> Result

Deallocates memory at the given pointer with the specified layout

fn allocate_zeroed(numerosity: usize) -> Result<Self::Ok, Self::Error>

Allocates zeroed memory according to the provided layout

impl<const N: usize> Bytes<Origin, Origin> for [(); N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [bool; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [char; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [f32; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [f64; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [i128; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 16usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [i16; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 2usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [i32; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [i64; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [i8; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [isize; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [u128; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 16usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [u16; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 2usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [u32; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [u64; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [u8; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<const N: usize> Bytes<Origin, Origin> for [usize; N]

const BYTES_SIZE: usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

where [(); { _ }]:,

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

where [(); { _ }]:,

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for ()

const BYTES_SIZE: usize = 0usize

const BYTES_ALIGN: usize = 1usize

fn from_bytes(_bytes: [u8; 0], _endianness: bool) -> Self

fn to_bytes(&self, _endianness: bool) -> [u8; 0]

fn from_bytes_pointer(_bytes_pointer: *const u8, _endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<B> Bytes<Origin, Origin> for *const B

where B: Bytes<Origin, Origin>,

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<B> Bytes<Origin, Origin> for *mut B

where B: Bytes<Origin, Origin>,

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; { _ }]

fn from_bytes(bytes: [u8; { _ }], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Addr

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Addr

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Addr

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Addr

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Allocator

const BYTES_SIZE: usize = 0usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 0]

fn from_bytes(bytes: [u8; 0], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Arch

const BYTES_SIZE: usize = 0usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 0]

fn from_bytes(bytes: [u8; 0], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for ArgumentNode

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for AtFlag

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Class

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Endianness

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Entry

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Entry

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Entry

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 32usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 32]

fn from_bytes(bytes: [u8; 32], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 32usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 32]

fn from_bytes(bytes: [u8; 32], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 40usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 40]

fn from_bytes(bytes: [u8; 40], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 32usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 32]

fn from_bytes(bytes: [u8; 32], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 40usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 40]

fn from_bytes(bytes: [u8; 40], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 48usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 48]

fn from_bytes(bytes: [u8; 48], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 56usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 56]

fn from_bytes(bytes: [u8; 56], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 64usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 64]

fn from_bytes(bytes: [u8; 64], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Error

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for File

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Flag

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Flag

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Half

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 2usize

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Half

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Half

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 2usize

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Half

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Identifier

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Index

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Information

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Magic

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Mode

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Null

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Null

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Null

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Null

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Off

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Off

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Off

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Off

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 32usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 32]

fn from_bytes(bytes: [u8; 32], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 32usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 32]

fn from_bytes(bytes: [u8; 32], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 40usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 40]

fn from_bytes(bytes: [u8; 40], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 32usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 32]

fn from_bytes(bytes: [u8; 32], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 40usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 40]

fn from_bytes(bytes: [u8; 40], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 48usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 48]

fn from_bytes(bytes: [u8; 48], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 56usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 56]

fn from_bytes(bytes: [u8; 56], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Ok

const BYTES_SIZE: usize = 24usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 24]

fn from_bytes(bytes: [u8; 24], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<()>

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<bool>

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 1usize

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<char>

const BYTES_SIZE: usize = 5usize

const BYTES_ALIGN: usize = 4usize

fn from_bytes(bytes: [u8; 5], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 5]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<f32>

const BYTES_SIZE: usize = 5usize

const BYTES_ALIGN: usize = 4usize

fn from_bytes(bytes: [u8; 5], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 5]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<f64>

const BYTES_SIZE: usize = 9usize

const BYTES_ALIGN: usize = 8usize

fn from_bytes(bytes: [u8; 9], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 9]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<i128>

const BYTES_SIZE: usize = 17usize

const BYTES_ALIGN: usize = 16usize

fn from_bytes(bytes: [u8; 17], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 17]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<i16>

const BYTES_SIZE: usize = 3usize

const BYTES_ALIGN: usize = 2usize

fn from_bytes(bytes: [u8; 3], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 3]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<i32>

const BYTES_SIZE: usize = 5usize

const BYTES_ALIGN: usize = 4usize

fn from_bytes(bytes: [u8; 5], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 5]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<i64>

const BYTES_SIZE: usize = 9usize

const BYTES_ALIGN: usize = 8usize

fn from_bytes(bytes: [u8; 9], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 9]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<i8>

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 1usize

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<isize>

const BYTES_SIZE: usize = 9usize

const BYTES_ALIGN: usize = 8usize

fn from_bytes(bytes: [u8; 9], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 9]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<u128>

const BYTES_SIZE: usize = 17usize

const BYTES_ALIGN: usize = 16usize

fn from_bytes(bytes: [u8; 17], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 17]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<u16>

const BYTES_SIZE: usize = 3usize

const BYTES_ALIGN: usize = 2usize

fn from_bytes(bytes: [u8; 3], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 3]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<u32>

const BYTES_SIZE: usize = 5usize

const BYTES_ALIGN: usize = 4usize

fn from_bytes(bytes: [u8; 5], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 5]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<u64>

const BYTES_SIZE: usize = 9usize

const BYTES_ALIGN: usize = 8usize

fn from_bytes(bytes: [u8; 9], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 9]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<u8>

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 1usize

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Option<usize>

const BYTES_SIZE: usize = 9usize

const BYTES_ALIGN: usize = 8usize

fn from_bytes(bytes: [u8; 9], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_bytes(&self, endianness: bool) -> [u8; 9]

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Origin

const BYTES_SIZE: usize = 0usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 0]

fn from_bytes(bytes: [u8; 0], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for OsABI

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Pair

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl<T> Bytes<Origin, Origin> for PhantomData<T>

const BYTES_SIZE: usize = 0usize

const BYTES_ALIGN: usize = 0usize

fn to_bytes(&self, _endianness: bool) -> [u8; { _ }]

fn from_bytes(_bytes: [u8; { _ }], _endianness: bool) -> Self

fn from_bytes_pointer(_bytes_pointer: *const u8, _endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Pointer

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Pointer

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Prot

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for SWord

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> SWord

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for SWord

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> SWord

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for SXWord

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> SXWord

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for SXWord

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> SXWord

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for StackNode

const BYTES_SIZE: usize = 12usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 12]

fn from_bytes(bytes: [u8; 12], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Type

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for TypeUnit

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for UChar

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> UChar

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for UChar

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> UChar

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Word

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Word

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for Word

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Word

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for XWord

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> XWord

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for XWord

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> XWord

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for bool

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, _endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], _endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, _endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for char

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for f32

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for f64

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for i128

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 16usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for i16

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 2usize

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for i32

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for i64

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for i8

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for isize

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for u128

const BYTES_SIZE: usize = 16usize

const BYTES_ALIGN: usize = 16usize

fn to_bytes(&self, endianness: bool) -> [u8; 16]

fn from_bytes(bytes: [u8; 16], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for u16

const BYTES_SIZE: usize = 2usize

const BYTES_ALIGN: usize = 2usize

fn to_bytes(&self, endianness: bool) -> [u8; 2]

fn from_bytes(bytes: [u8; 2], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for u32

const BYTES_SIZE: usize = 4usize

const BYTES_ALIGN: usize = 4usize

fn to_bytes(&self, endianness: bool) -> [u8; 4]

fn from_bytes(bytes: [u8; 4], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for u64

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for u8

const BYTES_SIZE: usize = 1usize

const BYTES_ALIGN: usize = 1usize

fn to_bytes(&self, endianness: bool) -> [u8; 1]

fn from_bytes(bytes: [u8; 1], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Bytes<Origin, Origin> for usize

const BYTES_SIZE: usize = 8usize

const BYTES_ALIGN: usize = 8usize

fn to_bytes(&self, endianness: bool) -> [u8; 8]

fn from_bytes(bytes: [u8; 8], endianness: bool) -> Self

fn from_bytes_pointer(bytes_pointer: *const u8, endianness: bool) -> Self

fn to_le_bytes(&self) -> [u8; { _ }]

fn to_be_bytes(&self) -> [u8; { _ }]

fn from_le_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

fn from_be_bytes(bytes: [u8; { _ }]) -> Self

where Self: Sized,

impl Clone for Origin

fn clone(&self) -> Self

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Origin

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

Formats the value using the given formatter.

impl Default for Origin

fn default() -> Self

Returns the “default value” for a type.

impl Labeled<Origin> for Class

fn description(&self) -> &str

fn acronym(&self) -> &str

impl Labeled<Origin> for Endianness

fn description(&self) -> &str

fn acronym(&self) -> &str

impl Labeled<Origin> for Index

fn description(&self) -> &str

fn acronym(&self) -> &str

impl Labeled<Origin> for Magic

fn description(&self) -> &str

fn acronym(&self) -> &str

impl Labeled<Origin> for OsABI

fn description(&self) -> &str

fn acronym(&self) -> &str

impl Labeled<Origin> for Type

fn description(&self) -> &str

fn acronym(&self) -> &str

impl Labeled<Origin> for TypeUnit

fn description(&self) -> &str

fn acronym(&self) -> &str

impl NonPrimitive<Origin> for Allocator

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Arch

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for ArgumentNode

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Entry

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Entry

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Entry

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for File

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Identifier

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Information

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Origin

const IS_PRIMITIVE: bool = false

impl NonPrimitive<Origin> for Pair

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for ()

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for Addr

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Addr

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Allocator

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Arch

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for ArgumentNode

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Entry

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Entry

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Entry

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for File

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Half

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Half

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Identifier

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Information

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Null

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Null

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Off

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Off

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Origin

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Pair

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for SWord

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for SWord

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for SXWord

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for SXWord

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for UChar

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for UChar

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Word

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for Word

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for XWord

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for XWord

const IS_PRIMITIVE: bool = false

impl Primitive<Origin> for bool

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for char

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for f32

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for f64

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for i128

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for i16

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for i32

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for i64

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for i8

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for isize

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for u128

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for u16

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for u32

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for u64

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for u8

const IS_PRIMITIVE: bool = true

impl Primitive<Origin> for usize

const IS_PRIMITIVE: bool = true

impl Copy for Origin