Struct metagoblin::elf::sym::sym32::Symtab

pub struct Symtab<'a> { /* fields omitted */ }

An ELF symbol table, allowing lazy iteration over symbols

Implementations

impl<'a> Symtab<'a>

pub fn parse(
    bytes: &'a [u8],
    offset: usize,
    count: usize,
    ctx: Ctx
) -> Result<Symtab<'a>, Error>

Parse a table of count ELF symbols from offset.

pub fn get(&self, index: usize) -> Option<Sym>

Try to parse a single symbol from the binary, at index.

pub fn len(&self) -> usize

The number of symbols in the table.

pub fn is_empty(&self) -> bool

Returns true if table has no symbols.

pub fn iter(&self) -> SymIterator<'a>

Iterate over all symbols.

pub fn to_vec(&self) -> Vec<Sym, Global>

Parse all symbols into a vector.

Trait Implementations

impl<'a> Debug for Symtab<'a>

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

Formats the value using the given formatter.

impl<'a> Default for Symtab<'a>

pub fn default() -> Symtab<'a>

Returns the "default value" for a type.

impl<'a, 'b> IntoIterator for &'b Symtab<'a>

type Item = <SymIterator<'a> as Iterator>::Item

The type of the elements being iterated over.

type IntoIter = SymIterator<'a>

Which kind of iterator are we turning this into?

pub fn into_iter(self) -> <&'b Symtab<'a> as IntoIterator>::IntoIter

Creates an iterator from a value.