Enum goblin::container::Endian

pub enum Endian {
    Little,
    Big,
}

The endianness (byte order) of a stream of bytes

Variants

LittleBig

Methods

impl Endian

pub fn network() -> Endian

pub fn is_little(&self) -> bool

Trait Implementations

impl Eq for Endian

impl Default for Endian

fn default() -> Endian

Returns the "default value" for a type.

impl Copy for Endian

impl Clone for Endian

fn clone(&self) -> Endian

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Endian

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

Formats the value using the given formatter.

impl PartialEq<Endian> for Endian

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

This method tests for self and other values to be equal, and is used by ==.

#[must_use] fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl From<bool> for Endian

fn from(little_endian: bool) -> Endian

Performs the conversion.

impl From<Endian> for Ctx

fn from(le: Endian) -> Self

Performs the conversion.

impl FromCtx<Endian, [u8]> for Nhdr32

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Nhdr64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Section32

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Section64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SegmentCommand32

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SegmentCommand64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Fvmlib

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for FvmlibCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Dylib

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DylibCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SubFrameworkCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SubClientCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SubUmbrellaCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SubLibraryCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for PreboundDylibCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DylinkerCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for RoutinesCommand32

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for RoutinesCommand64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SymtabCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DysymtabCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DylibTableOfContents

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DylibModule

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DylibModule64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DylibReference

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for TwolevelHintsCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for TwolevelHint

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for PrebindCksumCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for UuidCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for RpathCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for LinkeditDataCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for EncryptionInfoCommand32

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for EncryptionInfoCommand64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for VersionMinCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for LinkerOptionCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SymsegCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for IdentCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for FvmfileCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for EntryPointCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for SourceVersionCommand

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for DataInCodeEntry

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Nlist32

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Nlist64

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for RelocationInfo

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for CoffHeader

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Symbol

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for AuxFunctionDefinition

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for AuxBeginAndEndFunction

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for AuxWeakExternal

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for AuxSectionDefinition

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl FromCtx<Endian, [u8]> for Relocation

fn from_ctx(src: &[u8], ctx: Endian) -> Self

impl<'a> TryFromCtx<'a, Endian, [u8]> for Header

type Error = Error

type Size = usize

fn try_from_ctx(bytes: &'a [u8], _ctx: Endian) -> Result<(Self, Self::Size)>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Header

type Error = Error

type Size = usize

fn try_from_ctx(
    bytes: &'a [u8],
    _: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Header

type Error = Error

type Size = usize

fn try_from_ctx(
    bytes: &'a [u8],
    _: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for ProgramHeader where
    ProgramHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for ProgramHeader where
    ProgramHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SectionHeader where
    SectionHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SectionHeader where
    SectionHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for CompressionHeader where
    CompressionHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for CompressionHeader where
    CompressionHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Sym where
    Sym: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Sym where
    Sym: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Dyn where
    Dyn: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Dyn where
    Dyn: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Rela where
    Rela: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Rel where
    Rel: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Rela where
    Rela: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Rel where
    Rel: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Nhdr32 where
    Nhdr32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Nhdr64 where
    Nhdr64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Header32 where
    Header32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Header64 where
    Header64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for FatHeader where
    FatHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for FatArch where
    FatArch: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for LoadCommandHeader where
    LoadCommandHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Section32 where
    Section32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Section64 where
    Section64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SegmentCommand32 where
    SegmentCommand32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SegmentCommand64 where
    SegmentCommand64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Fvmlib where
    Fvmlib: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for FvmlibCommand where
    FvmlibCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Dylib where
    Dylib: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DylibCommand where
    DylibCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SubFrameworkCommand where
    SubFrameworkCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SubClientCommand where
    SubClientCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SubUmbrellaCommand where
    SubUmbrellaCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SubLibraryCommand where
    SubLibraryCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for PreboundDylibCommand where
    PreboundDylibCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DylinkerCommand where
    DylinkerCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for ThreadCommand

type Error = Error

type Size = usize

fn try_from_ctx(bytes: &'a [u8], le: Endian) -> Result<(Self, Self::Size)>

impl<'a> TryFromCtx<'a, Endian, [u8]> for RoutinesCommand32 where
    RoutinesCommand32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for RoutinesCommand64 where
    RoutinesCommand64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SymtabCommand where
    SymtabCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DysymtabCommand where
    DysymtabCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DylibTableOfContents where
    DylibTableOfContents: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DylibModule where
    DylibModule: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DylibModule64 where
    DylibModule64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DylibReference where
    DylibReference: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for TwolevelHintsCommand where
    TwolevelHintsCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for TwolevelHint where
    TwolevelHint: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for PrebindCksumCommand where
    PrebindCksumCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for UuidCommand where
    UuidCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for RpathCommand where
    RpathCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for LinkeditDataCommand where
    LinkeditDataCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for EncryptionInfoCommand32 where
    EncryptionInfoCommand32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for EncryptionInfoCommand64 where
    EncryptionInfoCommand64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for VersionMinCommand where
    VersionMinCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DyldInfoCommand where
    DyldInfoCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for LinkerOptionCommand where
    LinkerOptionCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SymsegCommand where
    SymsegCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for IdentCommand where
    IdentCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for FvmfileCommand where
    FvmfileCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for EntryPointCommand where
    EntryPointCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for SourceVersionCommand where
    SourceVersionCommand: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DataInCodeEntry where
    DataInCodeEntry: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for CommandVariant

type Error = Error

type Size = usize

fn try_from_ctx(bytes: &'a [u8], le: Endian) -> Result<(Self, Self::Size)>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Nlist32 where
    Nlist32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Nlist64 where
    Nlist64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for RelocationInfo where
    RelocationInfo: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for CoffHeader where
    CoffHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for StandardFields32 where
    StandardFields32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for StandardFields64 where
    StandardFields64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for WindowsFields32 where
    WindowsFields32: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for WindowsFields64 where
    WindowsFields64: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for OptionalHeader

type Error = Error

type Size = usize

fn try_from_ctx(bytes: &'a [u8], _: Endian) -> Result<(Self, Self::Size)>

impl<'a> TryFromCtx<'a, Endian, [u8]> for DataDirectory where
    DataDirectory: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for ExportDirectoryTable where
    ExportDirectoryTable: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Reexport<'a>

type Error = Error

type Size = usize

fn try_from_ctx(
    bytes: &'a [u8],
    _ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for ImportDirectoryEntry where
    ImportDirectoryEntry: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for ImageDebugDirectory where
    ImageDebugDirectory: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for RuntimeFunction where
    RuntimeFunction: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Symbol where
    Symbol: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for AuxFunctionDefinition where
    AuxFunctionDefinition: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for AuxBeginAndEndFunction where
    AuxBeginAndEndFunction: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for AuxWeakExternal where
    AuxWeakExternal: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for AuxSectionDefinition where
    AuxSectionDefinition: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for Relocation where
    Relocation: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> TryFromCtx<'a, Endian, [u8]> for MemberHeader where
    MemberHeader: 'a, 

type Error = Error

type Size = usize

fn try_from_ctx(
    src: &'a [u8],
    ctx: Endian
) -> Result<(Self, Self::Size), Self::Error>

impl<'a> IntoCtx<Endian, [u8]> for &'a Nhdr32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Nhdr32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Nhdr64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Nhdr64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Section32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Section32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Section64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Section64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SegmentCommand32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SegmentCommand32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SegmentCommand64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SegmentCommand64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Fvmlib

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Fvmlib

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a FvmlibCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for FvmlibCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Dylib

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Dylib

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DylibCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DylibCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SubFrameworkCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SubFrameworkCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SubClientCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SubClientCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SubUmbrellaCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SubUmbrellaCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SubLibraryCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SubLibraryCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a PreboundDylibCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for PreboundDylibCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DylinkerCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DylinkerCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a RoutinesCommand32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for RoutinesCommand32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a RoutinesCommand64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for RoutinesCommand64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SymtabCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SymtabCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DysymtabCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DysymtabCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DylibTableOfContents

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DylibTableOfContents

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DylibModule

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DylibModule

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DylibModule64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DylibModule64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DylibReference

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DylibReference

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a TwolevelHintsCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for TwolevelHintsCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a TwolevelHint

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for TwolevelHint

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a PrebindCksumCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for PrebindCksumCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a UuidCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for UuidCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a RpathCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for RpathCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a LinkeditDataCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for LinkeditDataCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a EncryptionInfoCommand32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for EncryptionInfoCommand32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a EncryptionInfoCommand64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for EncryptionInfoCommand64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a VersionMinCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for VersionMinCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a LinkerOptionCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for LinkerOptionCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SymsegCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SymsegCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a IdentCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for IdentCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a FvmfileCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for FvmfileCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a EntryPointCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for EntryPointCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a SourceVersionCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SourceVersionCommand

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a DataInCodeEntry

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for DataInCodeEntry

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Nlist32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Nlist32

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Nlist64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Nlist64

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a RelocationInfo

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for RelocationInfo

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a CoffHeader

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for CoffHeader

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for SectionTable

fn into_ctx(self, bytes: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Symbol

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Symbol

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a AuxFunctionDefinition

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for AuxFunctionDefinition

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a AuxBeginAndEndFunction

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for AuxBeginAndEndFunction

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a AuxWeakExternal

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for AuxWeakExternal

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a AuxSectionDefinition

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for AuxSectionDefinition

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl<'a> IntoCtx<Endian, [u8]> for &'a Relocation

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl IntoCtx<Endian, [u8]> for Relocation

fn into_ctx(self, dst: &mut [u8], ctx: Endian)

impl TryIntoCtx<Endian, [u8]> for Header

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    bytes: &mut [u8],
    _ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Header

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    bytes: &mut [u8],
    _endianness: Endian
) -> Result<Self::Size, Self::Error>

a Pwrite impl for Header: note we use the endianness value in the header, and not a parameter

impl TryIntoCtx<Endian, [u8]> for Header

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    bytes: &mut [u8],
    _endianness: Endian
) -> Result<Self::Size, Self::Error>

a Pwrite impl for Header: note we use the endianness value in the header, and not a parameter

impl<'a> TryIntoCtx<Endian, [u8]> for &'a ProgramHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for ProgramHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a ProgramHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for ProgramHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SectionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SectionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SectionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SectionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a CompressionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for CompressionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a CompressionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for CompressionHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Sym

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Sym

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Sym

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Sym

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Dyn

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Dyn

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Dyn

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Dyn

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Rela

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Rela

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Rel

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Rel

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Rela

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Rela

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Rel

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Rel

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Nhdr32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Nhdr32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Nhdr64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Nhdr64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Header32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Header32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Header64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Header64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a FatHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for FatHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a FatArch

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for FatArch

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a LoadCommandHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for LoadCommandHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Section32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Section32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Section64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Section64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SegmentCommand32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SegmentCommand32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SegmentCommand64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SegmentCommand64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Fvmlib

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Fvmlib

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a FvmlibCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for FvmlibCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Dylib

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Dylib

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DylibCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DylibCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SubFrameworkCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SubFrameworkCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SubClientCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SubClientCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SubUmbrellaCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SubUmbrellaCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SubLibraryCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SubLibraryCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a PreboundDylibCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for PreboundDylibCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DylinkerCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DylinkerCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a RoutinesCommand32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for RoutinesCommand32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a RoutinesCommand64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for RoutinesCommand64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SymtabCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SymtabCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DysymtabCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DysymtabCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DylibTableOfContents

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DylibTableOfContents

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DylibModule

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DylibModule

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DylibModule64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DylibModule64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DylibReference

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DylibReference

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a TwolevelHintsCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for TwolevelHintsCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a TwolevelHint

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for TwolevelHint

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a PrebindCksumCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for PrebindCksumCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a UuidCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for UuidCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a RpathCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for RpathCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a LinkeditDataCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for LinkeditDataCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a EncryptionInfoCommand32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for EncryptionInfoCommand32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a EncryptionInfoCommand64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for EncryptionInfoCommand64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a VersionMinCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for VersionMinCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DyldInfoCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DyldInfoCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a LinkerOptionCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for LinkerOptionCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SymsegCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SymsegCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a IdentCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for IdentCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a FvmfileCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for FvmfileCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a EntryPointCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for EntryPointCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a SourceVersionCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SourceVersionCommand

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DataInCodeEntry

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DataInCodeEntry

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Nlist32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Nlist32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Nlist64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Nlist64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a RelocationInfo

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for RelocationInfo

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a CoffHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for CoffHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a StandardFields32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for StandardFields32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a StandardFields64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for StandardFields64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a WindowsFields32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for WindowsFields32

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a WindowsFields64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for WindowsFields64

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for SectionTable

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    bytes: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a DataDirectory

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for DataDirectory

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a ExportDirectoryTable

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for ExportDirectoryTable

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a ImportDirectoryEntry

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for ImportDirectoryEntry

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a ImageDebugDirectory

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for ImageDebugDirectory

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a RuntimeFunction

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for RuntimeFunction

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Symbol

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Symbol

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a AuxFunctionDefinition

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for AuxFunctionDefinition

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a AuxBeginAndEndFunction

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for AuxBeginAndEndFunction

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a AuxWeakExternal

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for AuxWeakExternal

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a AuxSectionDefinition

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for AuxSectionDefinition

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a Relocation

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for Relocation

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl<'a> TryIntoCtx<Endian, [u8]> for &'a MemberHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl TryIntoCtx<Endian, [u8]> for MemberHeader

type Error = Error

type Size = usize

fn try_into_ctx(
    self,
    dst: &mut [u8],
    ctx: Endian
) -> Result<Self::Size, Self::Error>

impl SizeWith<Endian> for ProgramHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for ProgramHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SectionHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SectionHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for CompressionHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for CompressionHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Sym

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Sym

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Dyn

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Dyn

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Rela

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Rel

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Rela

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Rel

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Nhdr32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Nhdr64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Header32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Header64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for FatHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for FatArch

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for LoadCommandHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Section32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Section64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SegmentCommand32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SegmentCommand64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Fvmlib

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for FvmlibCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Dylib

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DylibCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SubFrameworkCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SubClientCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SubUmbrellaCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SubLibraryCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for PreboundDylibCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DylinkerCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for RoutinesCommand32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for RoutinesCommand64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SymtabCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DysymtabCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DylibTableOfContents

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DylibModule

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DylibModule64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DylibReference

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for TwolevelHintsCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for TwolevelHint

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for PrebindCksumCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for UuidCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for RpathCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for LinkeditDataCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for EncryptionInfoCommand32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for EncryptionInfoCommand64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for VersionMinCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DyldInfoCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for LinkerOptionCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SymsegCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for IdentCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for FvmfileCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for EntryPointCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SourceVersionCommand

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for DataInCodeEntry

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Nlist32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Nlist64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for RelocationInfo

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for CoffHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for StandardFields32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for StandardFields64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for WindowsFields32

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for WindowsFields64

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for SectionTable

type Units = usize

fn size_with(_ctx: &Endian) -> usize

impl SizeWith<Endian> for DataDirectory

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for ImportDirectoryEntry

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for ImageDebugDirectory

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Symbol

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for AuxFunctionDefinition

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for AuxBeginAndEndFunction

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for AuxWeakExternal

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for AuxSectionDefinition

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for Relocation

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units

impl SizeWith<Endian> for MemberHeader

type Units = usize

fn size_with(ctx: &Endian) -> Self::Units