xentrace-parser 2.1.0

A XenTrace files parser with a study purpose
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
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116

use std::{
    fmt::{Debug, Formatter, Result},
    ops::BitAnd,
};

/// Contains the event code read as a 32-bit unsigned big-endian integer.
#[repr(transparent)]
#[derive(Clone, Copy, PartialEq, Eq)]
pub struct EventCode(u32);

impl EventCode {
    /// Returns the complete event code.
    pub fn value(&self) -> u32 {
        self.0
    }

    /// Returns the event class, can be used to filter events.
    pub fn main(&self) -> u32 {
        (self.0 & 0x0FFF0000) >> 16
    }

    /// Returns the event subclass, can also be used to filter events.
    pub fn sub(&self) -> u32 {
        (self.0 & 0x0000F000) >> 12
    }

    /// Returns the event minor, identifies the event in its class and subclass.
    pub fn minor(&self) -> u32 {
        self.0 & 0x00000FFF
    }
}

impl From<u32> for EventCode {
    fn from(value: u32) -> Self {
        Self(value)
    }
}

impl From<EventCode> for u32 {
    fn from(value: EventCode) -> Self {
        value.0
    }
}

impl From<&EventCode> for u32 {
    fn from(value: &EventCode) -> Self {
        value.0
    }
}

impl PartialEq<u32> for EventCode {
    fn eq(&self, other: &u32) -> bool {
        u32::from(*self).eq(other)
    }
}

impl PartialEq<EventCode> for u32 {
    fn eq(&self, other: &EventCode) -> bool {
        u32::from(*other).eq(self)
    }
}

impl BitAnd<u32> for EventCode {
    type Output = EventCode;

    fn bitand(self, rhs: u32) -> Self::Output {
        Self(self.0.bitand(rhs))
    }
}

impl BitAnd<EventCode> for u32 {
    type Output = EventCode;

    fn bitand(self, rhs: EventCode) -> Self::Output {
        EventCode(rhs.0.bitand(self))
    }
}

impl Debug for EventCode {
    fn fmt(&self, f: &mut Formatter<'_>) -> Result {
        f.debug_struct("EventCode")
            .field("value", &format_args!("{:#010X}", self.0))
            .field("main", &format_args!("{:#06X}", self.main()))
            .field("sub", &format_args!("{:#03X}", self.sub()))
            .field("minor", &format_args!("{:#05X}", self.minor()))
            .finish()
    }
}

#[cfg(test)]
mod tests {
    use super::EventCode;

    #[test]
    fn full_equality_test() {
        let ecode1 = EventCode::from(0x00015003);
        let ecode2 = EventCode::from(0x00015003);

        assert_eq!(ecode1, ecode2);
        assert_eq!(ecode1.main(), ecode2.main());
        assert_eq!(ecode1.sub(), ecode2.sub());
        assert_eq!(ecode1.minor(), ecode2.minor());
    }

    #[test]
    fn equality_test() {
        let ecode1 = EventCode::from(0x00015003);
        let ecode2 = EventCode::from(0x01015003);

        assert_ne!(ecode1, ecode2);
        assert_ne!(ecode1.main(), ecode2.main());

        assert_eq!(ecode1.sub(), ecode2.sub());
        assert_eq!(ecode1.minor(), ecode2.minor());
    }
}