Struct EventPtrRaw

pub struct EventPtrRaw {
    pub rid: u32,
    pub token: Token,
    pub offset: usize,
    pub event: u32,
}

Raw EventPtr table row with unresolved event index

Represents the binary format of an EventPtr metadata table entry (table ID 0x13) as stored in the metadata tables stream. EventPtr entries provide indirection for event table access, primarily used in edit-and-continue scenarios where event ordering has been modified.

The EventPtr table serves as a mapping layer between logical event positions and physical event locations in the Event table, enabling non-contiguous event arrangements while maintaining consistent logical references.

Indirection Logic

EventPtr provides the following indirection pattern:

• Logical Index: Position in EventPtr table (used by referencing metadata)
• Physical Index: Value stored in EventPtr entry (actual Event table position)
• Resolution: Logical → EventPtr[Logical] → Event[Physical]

Edit-and-Continue Context

EventPtr tables are typically present only when needed for edit-and-continue scenarios:

• Original event ordering disrupted by code modifications
• Logical event references must remain stable across edit sessions
• Physical event locations may change but logical access remains consistent

Reference

• ECMA-335 II.22.14 - EventPtr table specification

Fields

rid: u32

Row identifier within the EventPtr metadata table

The 1-based index of this EventPtr row. Used for metadata token generation and logical event indexing in indirection scenarios.

token: Token

Metadata token for this EventPtr row

Combines the table identifier (0x13 for EventPtr) with the row ID to create a unique token. Format: 0x13000000 | rid

offset: usize

Byte offset of this row within the metadata tables stream

Physical location of the raw EventPtr data within the metadata binary format. Used for debugging and low-level metadata analysis.

event: u32

Event table index (unresolved)

1-based index into the Event table pointing to the actual event. This provides the physical location mapping for the logical event position represented by this EventPtr entry’s row ID.

Implementations

impl EventPtrRaw

pub fn to_owned(&self) -> Result<EventPtrRc>

Convert to owned EventPtr with validated data

This method converts the raw EventPtr entry into a fully validated EventPtr structure with owned data. Since EventPtr entries contain only a single event reference, the conversion is straightforward and primarily serves to establish the owned data pattern consistent with other metadata tables.

Returns

Returns EventPtrRc (Arc-wrapped EventPtr) on success, providing shared ownership of the validated EventPtr data.

Errors

Currently doesn’t fail, but returns Result for consistency with other table conversion methods and future validation requirements.

pub fn apply(&self) -> Result<()>

Apply this EventPtr entry during metadata loading

Processes the raw EventPtr entry as part of the metadata loading framework. Unlike other metadata tables, EventPtr entries don’t directly modify other metadata structures since they serve purely as an indirection mechanism.

Returns

Always returns Ok(()) since EventPtr entries don’t perform cross-table modifications during the initial loading phase.

Trait Implementations

impl Clone for EventPtrRaw

fn clone(&self) -> EventPtrRaw

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventPtrRaw

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

Formats the value using the given formatter.

impl<'a> RowDefinition<'a> for EventPtrRaw

fn row_size(sizes: &TableInfoRef) -> u32

Calculate the byte size of an EventPtr table row

Computes the total size in bytes required to store one EventPtr table row based on the table size information. The size depends on whether large table indexes are required for the Event table.

Row Structure

• event: 2 or 4 bytes (Event table index)

Arguments

• sizes - Table size information determining index byte sizes

Returns

Returns the total byte size required for one EventPtr table row.

fn read_row( data: &'a [u8], offset: &mut usize, rid: u32, sizes: &TableInfoRef, ) -> Result<Self>

Read an EventPtr row from the metadata tables stream

Parses one EventPtr table row from the binary metadata stream, handling variable-size indexes based on table size information. Advances the offset to point to the next row after successful parsing.

Arguments

• data - The metadata tables stream binary data
• offset - Current position in the stream (updated after reading)
• rid - Row identifier for this EventPtr entry (1-based)
• sizes - Table size information for determining index sizes

Returns

Returns a parsed EventPtrRaw instance with all fields populated from the binary data.

Errors

• The data stream is truncated or corrupted
• Event index values exceed expected ranges
• Binary parsing encounters invalid data