jfrs 0.2.5

Java Flight Recorder reader for Rust
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

use crate::reader::type_descriptor::TypeDescriptor;
use crate::reader::value_descriptor::ValueDescriptor;
use crate::reader::{Chunk, Error, HeapByteStream, Result};
use crate::{EVENT_TYPE_CONSTANT_POOL, EVENT_TYPE_METADATA};

pub struct Event<'a> {
    pub byte_offset: u64,
    pub class: &'a TypeDescriptor,
    pub(crate) chunk: &'a Chunk,
    pub(crate) value: ValueDescriptor,
}

impl<'a> Event<'a> {
    pub fn value(&'a self) -> Accessor<'a> {
        Accessor {
            chunk: self.chunk,
            value: &self.value,
        }
    }
}

pub struct Accessor<'a> {
    chunk: &'a Chunk,
    pub value: &'a ValueDescriptor,
}

impl<'a> Accessor<'a> {
    pub fn new(chunk: &'a Chunk, value: &'a ValueDescriptor) -> Self {
        Self { chunk, value }
    }

    pub fn get_field(&self, name: &str) -> Option<Self> {
        self.value.get_field(name, self.chunk).map(|v| Self {
            chunk: self.chunk,
            value: v,
        })
    }

    pub fn get_field_raw(&self, name: &str) -> Option<Self> {
        self.value.get_field_raw(name, self.chunk).map(|v| Self {
            chunk: self.chunk,
            value: v,
        })
    }

    pub fn resolve(self) -> Option<Self> {
        match self.value {
            ValueDescriptor::ConstantPool {
                class_id,
                constant_index,
            } => self
                .chunk
                .constant_pool
                .get(class_id, constant_index)
                .map(|v| Self {
                    chunk: self.chunk,
                    value: v,
                }),
            _ => Some(self),
        }
    }

    pub fn as_iter(self) -> Option<impl Iterator<Item = Accessor<'a>>> {
        let array = match self.value {
            ValueDescriptor::Array(a) => a,
            ValueDescriptor::ConstantPool {
                class_id,
                constant_index,
            } => match self.chunk.constant_pool.get(class_id, constant_index) {
                Some(ValueDescriptor::Array(a)) => a,
                _ => return None,
            },
            _ => return None,
        };
        Some(array.iter().map(|v| Accessor {
            value: v,
            chunk: self.chunk,
        }))
    }
}

pub struct EventIterator<'a, 'b> {
    chunk: &'a Chunk,
    stream: &'b mut HeapByteStream,
    offset: u64,
}

impl<'a, 'b> EventIterator<'a, 'b> {
    pub fn new(chunk: &'a Chunk, stream: &'b mut HeapByteStream) -> Self {
        Self {
            chunk,
            stream,
            offset: 0,
        }
    }

    pub fn seek(&mut self, offset: u64) {
        self.offset = offset;
    }

    fn internal_next(&mut self) -> Result<Option<Event<'a>>> {
        let end_offset = self.chunk.header.chunk_body_size();

        while self.offset < end_offset {
            self.stream
                .seek(self.chunk.header.body_start_offset() + self.offset)?;
            let event_offset = self.offset;

            let size = self.stream.read_i32()?;
            let event_type = self.stream.read_i64()?;
            self.offset += size as u64;

            match event_type {
                EVENT_TYPE_METADATA | EVENT_TYPE_CONSTANT_POOL => {}
                _ => {
                    let type_desc = self
                        .chunk
                        .metadata
                        .type_pool
                        .get(event_type)
                        .ok_or(Error::ClassNotFound(event_type))?;
                    let value =
                        ValueDescriptor::try_new(self.stream, event_type, &self.chunk.metadata)?;

                    return Ok(Some(Event {
                        byte_offset: event_offset,
                        class: type_desc,
                        chunk: self.chunk,
                        value,
                    }));
                }
            }
        }
        Ok(None)
    }
}

impl<'a, 'b> Iterator for EventIterator<'a, 'b> {
    type Item = Result<Event<'a>>;

    fn next(&mut self) -> Option<Self::Item> {
        match self.internal_next() {
            Ok(Some(e)) => Some(Ok(e)),
            Ok(None) => None,
            Err(e) => Some(Err(e)),
        }
    }
}