deflect 0.1.0

Reflection in Rust via DWARF debug info.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88

use std::{borrow::Cow, fmt};

/// The name associated with a debuginfo entry.
#[derive(Clone)]
pub struct Name<R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    name: R,
}

impl<R> Name<R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    /// Constructs a `Name` from the [`DW_AT_name`][crate::gimli::DW_AT_name]
    /// attribute of the given `entry`.
    pub(crate) fn from_die(
        dwarf: &crate::gimli::Dwarf<R>,
        unit: &crate::gimli::Unit<R, usize>,
        entry: &crate::gimli::DebuggingInformationEntry<'_, '_, R>,
    ) -> Result<Self, crate::Error> {
        let name = crate::get(entry, crate::gimli::DW_AT_name)?;
        let name = dwarf.attr_string(unit, name)?;
        Ok(Self { name })
    }

    /// Constructs a `Name` from the [`DW_AT_name`][crate::gimli::DW_AT_name]
    /// attribute of the given `entry`.
    pub(crate) fn from_die_opt(
        dwarf: &crate::gimli::Dwarf<R>,
        unit: &crate::gimli::Unit<R, usize>,
        entry: &crate::gimli::DebuggingInformationEntry<'_, '_, R>,
    ) -> Result<Option<Self>, crate::Error> {
        let name = crate::get_opt(entry, crate::gimli::DW_AT_name)?;
        Ok(if let Some(name) = name {
            let name = dwarf.attr_string(unit, name)?;
            Some(Self { name })
        } else {
            None
        })
    }

    /// Convert all remaining data to a clone-on-write string.
    ///
    /// The string will be borrowed where possible, but some readers may always
    /// return an owned string.
    ///
    /// Returns an error if the data contains invalid characters.
    pub fn to_string(&self) -> Result<Cow<'_, str>, crate::Error> {
        Ok(self.name.to_string()?)
    }

    /// Convert all remaining data to a clone-on-write string, including invalid
    /// characters.
    ///
    /// The string will be borrowed where possible, but some readers may always
    /// return an owned string.
    pub fn to_string_lossy(&self) -> Result<Cow<'_, str>, crate::Error> {
        Ok(self.name.to_string_lossy()?)
    }

    /// Return all remaining data as a clone-on-write slice of bytes.
    ///
    /// The slice will be borrowed where possible, but some readers may always
    /// return an owned vector.
    pub fn to_slice(&self) -> Result<Cow<'_, [u8]>, crate::Error> {
        Ok(self.name.to_slice()?)
    }
}

impl<R> fmt::Debug for Name<R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.to_string_lossy().map_err(crate::fmt_err)?.fmt(f)
    }
}

impl<R> fmt::Display for Name<R>
where
    R: crate::gimli::Reader<Offset = usize>,
{
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        self.to_string_lossy().map_err(crate::fmt_err)?.fmt(f)
    }
}