Struct UserStrings

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

The UserStrings object provides helper methods to access the data within the ‘#US’ heap. That heap contains all user defined Strings, and this object allows to interface with it, and parse and process it properly according to the standard.

Examples

use dotscope::metadata::streams::UserStrings;
let data = &[0u8, 65, 0, 0, 0];
let us = UserStrings::from(data).unwrap();
let s = us.get(1).unwrap();
assert_eq!(s.to_string_lossy(), "A");

Reference

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

Implementations

impl<'a> UserStrings<'a>

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

Create a UserStrings object from a sequence of bytes

Arguments

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

Errors

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

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

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

Panics

May panic if the underlying slice conversion fails due to memory alignment issues

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

Returns an iterator over all user strings in the heap

Provides zero-copy access to all UTF-16 user strings with length prefixes. Each iteration yields a Result<(usize, &U16CStr)> with the offset and string content.

Examples

use dotscope::metadata::streams::UserStrings;

let data = &[0u8, 0x05, 0x48, 0x00, 0x69, 0x00, 0x00]; // "Hi" in UTF-16
let user_strings = UserStrings::from(data).unwrap();

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

Trait Implementations

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

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

The type of the elements being iterated over.

type IntoIter = UserStringsIterator<'a>

Which kind of iterator are we turning this into?

fn into_iter(self) -> Self::IntoIter

Creates an iterator from a value.