Struct Strings

pub struct Strings<'a> { /* private fields */ }

‘#Strings’ hold various identifiers which are referenced form other tables within the CIL metadata. e.g. various strings for reflection: function names, 0xclass names, 0xvariables, 0x…

The Strings object provides helper methods to access the data within this blob, 0xand parse / process it properly according to the standard.

Examples

use dotscope::metadata::streams::Strings;
let data = &[0u8, b'H', b'e', b'l', b'l', b'o', 0u8];
let strings = Strings::from(data).unwrap();
let s = strings.get(1).unwrap();
assert_eq!(s, "Hello");

Reference

• ‘https://ecma-international.org/wp-content/uploads/ECMA-335_6th_edition_june_2012.pdf’ - II.24.2.3

Implementations

impl<'a> Strings<'a>

pub fn from(data: &[u8]) -> Result<Strings<'_>>

Create a Strings object from a sequence of bytes

Arguments

• ‘data’ - The byte slice from which this object shall be created

Errors

Returns an error if the string heap data is empty or malformed

pub fn get(&self, index: usize) -> Result<&'a str>

Get a view into the string contained at the provided location. This will process the heap information, and return a string slice which represents the object located there (if any)

Arguments

• ‘index’ - The offset within the heap to be accessed (comes from metadata tables)

Errors

Returns an error if the index is out of bounds or the string data is invalid UTF-8

pub fn iter(&self) -> StringsIterator<'_>

Returns an iterator over all strings in the heap

Provides zero-copy sequential access to all null-terminated UTF-8 strings. Each iteration yields a Result<(usize, &str)> with the offset and string content.

Examples

use dotscope::metadata::streams::Strings;

let data = &[0u8, b'H', b'e', b'l', b'l', b'o', 0u8, b'W', b'o', b'r', b'l', b'd', 0u8];
let strings = Strings::from(data).unwrap();

for result in strings.iter() {
    match result {
        Ok((offset, string)) => println!("String at {}: '{}'", offset, string),
        Err(e) => eprintln!("Error: {}", e),
    }
}

Trait Implementations

impl<'a> IntoIterator for &'a Strings<'a>

type Item = Result<(usize, &'a str), Error>

The type of the elements being iterated over.

type IntoIter = StringsIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.