xct2cli 0.1.0

Library and CLI for transforming Xcode Instruments .trace bundles (hotspots, callgraphs, annotated disassembly, PMI counters, heap allocations). Apple Silicon.
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
89
90
91
92
93

use std::rc::Rc;

use serde::Serialize;

#[derive(Debug, Clone, Serialize)]
#[serde(tag = "kind")]
pub enum Cell {
    /// `<sentinel/>` - schema column present but no value for this row.
    Sentinel,
    Leaf(LeafCell),
    Composite(CompositeCell),
}

#[derive(Debug, Clone, Serialize)]
pub struct LeafCell {
    pub element: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fmt: Option<String>,
    pub text: String,
}

#[derive(Debug, Clone, Serialize)]
pub struct CompositeCell {
    pub element: String,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub id: Option<u64>,
    #[serde(skip_serializing_if = "Option::is_none")]
    pub fmt: Option<String>,
    pub children: Vec<Rc<Cell>>,
}

impl Cell {
    pub fn element(&self) -> Option<&str> {
        match self {
            Cell::Sentinel => None,
            Cell::Leaf(l) => Some(&l.element),
            Cell::Composite(c) => Some(&c.element),
        }
    }

    pub fn id(&self) -> Option<u64> {
        match self {
            Cell::Sentinel => None,
            Cell::Leaf(l) => l.id,
            Cell::Composite(c) => c.id,
        }
    }

    pub fn fmt(&self) -> Option<&str> {
        match self {
            Cell::Sentinel => None,
            Cell::Leaf(l) => l.fmt.as_deref(),
            Cell::Composite(c) => c.fmt.as_deref(),
        }
    }

    pub fn text(&self) -> Option<&str> {
        match self {
            Cell::Leaf(l) => Some(&l.text),
            _ => None,
        }
    }

    pub fn children(&self) -> &[Rc<Cell>] {
        match self {
            Cell::Composite(c) => &c.children,
            _ => &[],
        }
    }

    /// First descendant whose element name equals `tag`, including self.
    pub fn find(&self, tag: &str) -> Option<&Cell> {
        if self.element() == Some(tag) {
            return Some(self);
        }
        for child in self.children() {
            if let Some(hit) = child.find(tag) {
                return Some(hit);
            }
        }
        None
    }

    pub fn as_i64(&self) -> Option<i64> {
        self.text()?.trim().parse().ok()
    }

    pub fn as_u64(&self) -> Option<u64> {
        self.text()?.trim().parse().ok()
    }
}