Struct symbolic::common::Name

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

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::new("_ZN3foo3barEv");
assert_eq!(name.to_string(), "_ZN3foo3barEv");

Create a name with a language. Alternate formatting prints the language:

use symbolic_common::{Language, Name};

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

Implementations

impl<'a> Name<'a>

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

Constructs a new mangled name.

The language of this name is Language::Unknown.

Example

use symbolic_common::Name;

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

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

Constructs a new mangled name with a known Language.

Example

use symbolic_common::{Language, Name};

let name = Name::with_language("_ZN3foo3barEv", 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::Name;

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

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

use symbolic_common::Name;

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

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};

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

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

Converts this name into a Cow, dropping the language.

Example

use symbolic_common::Name;

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

pub fn into_string(self) -> String

Converts this name into a String, dropping the language.

Example

use symbolic_common::Name;

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

Trait Implementations

impl<'_> AsRef<str> for Name<'_>

fn as_ref(&self) -> &str

Performs the conversion.

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> Eq for Name<'a>

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

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

Performs the conversion.

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<'_> Into<String> for Name<'_>

fn into(self) -> String

Performs the conversion.

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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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: &Name<'a>) -> bool

This method tests for !=.

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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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 ==.

#[must_use]fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

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.