Struct 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) -> Self

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 Self

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 Self

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

Formats the value using the given formatter.

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

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Display for Name<'_>

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

Formats the value using the given formatter.

impl From<Name<'_>> for String

fn from(name: Name<'_>) -> Self

Converts to this type from the input type.

impl<'a, S> From<S> for Name<'a>

where S: Into<Cow<'a, str>>,

fn from(string: S) -> Self

Converts to this type from the input type.

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

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

Feeds this value into the given Hasher.

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

where H: Hasher, Self: Sized,

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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 Cow<'b, str>

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

Tests for self and other values to be equal, and is used by ==.

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

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 String

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

Tests for self and other values to be equal, and is used by ==.

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

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

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

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

Tests for self and other values to be equal, and is used by ==.

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

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::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

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

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