Struct RawEventRecord

pub struct RawEventRecord<'a> {
    pub record_type: RecordType,
    pub misc: u16,
    pub data: RawData<'a>,
    pub parse_info: RecordParseInfo,
}

An unparsed event record.

This can be converted into a parsed record by calling .parse().

The raw record also provides access to “common data” like the ID, timestamp, tid etc., i.e. the information that was requested with SampleFormat and AttrFlags::SAMPLE_ID_ALL.

Fields

record_type: RecordType

The record type. Must be a builtin type, i.e. not a user type.

misc: u16

The misc value on this record.

data: RawData<'a>

The raw bytes in the body of this record.

parse_info: RecordParseInfo

The parse info from our corresponding evnt’s attr.

Implementations

impl<'a> RawEventRecord<'a>

pub fn new( record_type: RecordType, misc: u16, data: RawData<'a>, parse_info: RecordParseInfo, ) -> Self

Create a new RawEventRecord. Must only be called if record_type.is_builtin_type() is true.

pub fn common_data(&self) -> Result<CommonData, Error>

Parse “common data” on this record, see CommonData.

The available information is determined by the event attr, specifically by the requested SampleFormat and by the presence of the AttrFlags::SAMPLE_ID_ALL flag: The SampleFormat determines the available fields, and the SAMPLE_ID_ALL flag determines the record types on which these fields are available. If SAMPLE_ID_ALL is set, the requested fields are available on all records, otherwise only on sample records (RecordType::SAMPLE).

pub fn timestamp(&self) -> Option<u64>

The record timestamp, if available.

pub fn id(&self) -> Option<u64>

The ID, if available.

pub fn parse(&self) -> Result<EventRecord<'a>, Error>

Parses this raw record into an EventRecord.

Trait Implementations

impl<'a> Clone for RawEventRecord<'a>

fn clone(&self) -> RawEventRecord<'a>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for RawEventRecord<'_>

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

Formats the value using the given formatter.

impl<'a> PartialEq for RawEventRecord<'a>

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

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

const 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> Eq for RawEventRecord<'a>

impl<'a> StructuralPartialEq for RawEventRecord<'a>