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.

Errors

This function never returns an error; it always returns Ok(()).

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 RowReadable for EventPtrRaw

fn row_read( data: &[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

const TABLE_ID: TableId = TableId::EventPtr

The table ID for this row type.

impl RowWritable for EventPtrRaw

fn row_write( &self, data: &mut [u8], offset: &mut usize, _rid: u32, sizes: &TableInfoRef, ) -> Result<()>

Write a EventPtr table row to binary data

Serializes one EventPtr table entry to the metadata tables stream format, handling variable-width table indexes based on the table size information.

Arguments

• data - Target binary buffer for metadata tables stream
• offset - Current write position (updated after writing)
• rid - Row identifier for this event pointer entry (unused for EventPtr)
• sizes - Table sizing information for writing table indexes

Returns

• Ok(()) - Successfully serialized event pointer row
• Err(crate::Error) - If buffer is too small or write fails

Binary Format

Fields are written in the exact order specified by ECMA-335:

1. Event table index (2/4 bytes, little-endian)

impl TableRow for EventPtrRaw

fn row_size(sizes: &TableInfoRef) -> u32

Calculate the binary size of one EventPtr table row

Computes the total byte size required for one EventPtr row based on the current metadata table sizes. The row size depends on whether the Event table uses 2-byte or 4-byte indices.

Arguments

• sizes - Table sizing information for calculating variable-width fields

Returns

Total byte size of one EventPtr table row