Struct cpp_demangle::Symbol

pub struct Symbol<T> { /* fields omitted */ }

A mangled symbol that has been parsed into an AST.

This is generic over some storage type T which can be either owned or borrowed. See the OwnedSymbol and BorrowedSymbol type aliases.

Methods

impl<T> Symbol<T> where T: AsRef<[u8]>

fn new(raw: T) -> Result<Symbol<T>>

Given some raw storage, parse the mangled symbol from it.

use cpp_demangle::Symbol;

// First, something easy :)

let mangled = b"_ZN5space3fooEibc";

let sym = Symbol::new(&mangled[..])
    .expect("Could not parse mangled symbol!");

let demangled = format!("{}", sym);
assert_eq!(demangled, "space::foo(int, bool, char)");

// Now let's try something a little more complicated!

let mangled =
    b"__Z28JS_GetPropertyDescriptorByIdP9JSContextN2JS6HandleIP8JSObjectEENS2_I4jsidEENS1_13MutableHandleINS1_18PropertyDescriptorEEE";

let sym = Symbol::new(&mangled[..])
    .expect("Could not parse mangled symbol!");

let demangled = format!("{}", sym);
assert_eq!(
    demangled,
    "JS_GetPropertyDescriptorById(JSContext*, JS::Handle<JSObject*>, JS::Handle<jsid>, JS::MutableHandle<JS::PropertyDescriptor>)"
);

impl<T> Symbol<T>

fn with_tail(input: &[u8]) -> Result<(BorrowedSymbol, &[u8])>

Parse a mangled symbol from input and return it and the trailing tail of bytes that come after the symbol.

While Symbol::new will return an error if there is unexpected trailing bytes, with_tail simply returns the trailing bytes along with the parsed symbol.

use cpp_demangle::BorrowedSymbol;

let mangled = b"_ZN5space3fooEibc and some trailing junk";

let (sym, tail) = BorrowedSymbol::with_tail(&mangled[..])
    .expect("Could not parse mangled symbol!");

assert_eq!(tail, b" and some trailing junk");

let demangled = format!("{}", sym);
assert_eq!(demangled, "space::foo(int, bool, char)");

Trait Implementations

impl<T: Clone> Clone for Symbol<T>

fn clone(&self) -> Symbol<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Symbol<T>

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.

impl<T: PartialEq> PartialEq for Symbol<T>

fn eq(&self, __arg_0: &Symbol<T>) -> bool

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

fn ne(&self, __arg_0: &Symbol<T>) -> bool

This method tests for !=.

impl<T> Display for Symbol<T> where T: AsRef<[u8]>

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

Formats the value using the given formatter.