Struct symbolic::common::Name

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

The name of a potentially mangled symbol.

Debugging information often only contains mangled names in their symbol and debug information data. The mangling schema depends on the compiler and programming language. Name is a wrapper type for potentially mangled names and an optionally declared language. To demangle the name, see the demangle feature of symbolic.

Not all sources declare a programming language. In such a case, the language will be Unknown. However, it may still be inferred for demangling by inspecting the mangled string.

Names can refer either functions, types, fields, or virtual constructs. Their semantics are fully defined by the language and the compiler.

Examples

Create a name and print it:

use symbolic_common::Name;

let name = Name::from("_ZN3foo3barEv");
assert_eq!(name.to_string(), "_ZN3foo3barEv");

Create a name with a language and explicit mangling state. Alternate formatting prints the language:

use symbolic_common::{Language, Name, NameMangling};

let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp);
assert_eq!(format!("{:#}", name), "_ZN3foo3barEv [C++]");

Implementations

impl<'a> Name<'a>

pub fn new<S>(string: S, mangling: NameMangling, lang: Language) -> Name<'a>where
    S: Into<Cow<'a, str>>,

Constructs a new Name with given mangling and language.

In case both the mangling state and the language are unknown, a simpler alternative to use is Name::from.

Example

use symbolic_common::{Language, Name, NameMangling};

let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp);
assert_eq!(format!("{:#}", name), "_ZN3foo3barEv [C++]");

pub fn as_str(&self) -> &str

Returns the raw, mangled string of the name.

Example

use symbolic_common::{Language, Name, NameMangling};

let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp);
assert_eq!(name.as_str(), "_ZN3foo3barEv");

This is also available as an AsRef<str> implementation:

use symbolic_common::{Language, Name, NameMangling};

let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp);
assert_eq!(name.as_ref(), "_ZN3foo3barEv");

pub fn set_language(&mut self, language: Language) -> &mut Name<'a>

Set the Name’s language.

pub fn language(&self) -> Language

The language of the mangled symbol.

If the language is not declared in the source, this returns Language::Unknown. The language may still be inferred using detect_language, which is declared on the Demangle extension trait.

Example

use symbolic_common::{Language, Name, NameMangling};

let name = Name::new("_ZN3foo3barEv", NameMangling::Mangled, Language::Cpp);
assert_eq!(name.language(), Language::Cpp);

pub fn set_mangling(&mut self, mangling: NameMangling) -> &mut Name<'a>

Set the Name’s mangling state.

pub fn mangling(&self) -> NameMangling

Returns the Name’s mangling state.

Example

use symbolic_common::{Language, Name, NameMangling};

let unmangled = Name::new("foo::bar", NameMangling::Unmangled, Language::Unknown);
assert_eq!(unmangled.mangling(), NameMangling::Unmangled);

pub fn into_cow(self) -> Cow<'a, str>

Converts this name into a Cow.

Example

use symbolic_common::Name;

let name = Name::from("_ZN3foo3barEv");
assert_eq!(name.into_cow(), "_ZN3foo3barEv");

pub fn into_string(self) -> String

Converts this name into a String.

Example

use symbolic_common::Name;

let name = Name::from("_ZN3foo3barEv");
assert_eq!(name.into_string(), "_ZN3foo3barEv");

Trait Implementations

impl AsRef<str> for Name<'_>

fn as_ref(&self) -> &str

Converts this type into a shared reference of the (usually inferred) input type.

impl<'a> Clone for Name<'a>

fn clone(&self) -> Name<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for Name<'a>

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

Formats the value using the given formatter.

impl<'a> Demangle for Name<'a>

fn detect_language(&self) -> Language

Infers the language of a mangled name.

fn demangle(&self, opts: DemangleOptions) -> Option<String>

Demangles the name with the given options.

fn try_demangle(&self, opts: DemangleOptions) -> Cow<'_, str>

Tries to demangle the name and falls back to the original name.

impl<'de, 'a> Deserialize<'de> for Name<'a>

fn deserialize<__D>(
    __deserializer: __D
) -> Result<Name<'a>, <__D as Deserializer<'de>>::Error>where
    __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Name<'_>

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

Formats the value using the given formatter.

impl<'a, S> From<S> for Name<'a>where
    S: Into<Cow<'a, str>>,

fn from(string: S) -> Name<'a>

Converts to this type from the input type.

impl<'a> Hash for Name<'a>

fn hash<__H>(&self, state: &mut __H)where
    __H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)where
    H: Hasher,

Feeds a slice of this type into the given Hasher.

impl<'a, 'b> PartialEq<&'b str> for Name<'a>

fn eq(&self, other: &&'b str) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<Cow<'b, str>> for Name<'a>

fn eq(&self, other: &Cow<'b, str>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<Name<'a>> for &'b str

fn eq(&self, other: &Name<'a>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> PartialEq<Name<'a>> for Name<'a>

fn eq(&self, other: &Name<'a>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<Name<'a>> for str

fn eq(&self, other: &Name<'a>) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<String> for Name<'a>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a, 'b> PartialEq<str> for Name<'a>

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

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<'a> Serialize for Name<'a>

fn serialize<__S>(
    &self,
    __serializer: __S
) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>where
    __S: Serializer,

Serialize this value into the given Serde serializer.

impl<'a> Eq for Name<'a>

impl<'a> StructuralEq for Name<'a>

impl<'a> StructuralPartialEq for Name<'a>