Struct EventMeta 

pub struct EventMeta {
    pub dispatch: u8,
    pub flags: u8,
    pub _pad: [u8; 2],
    pub origin_hash: u64,
    pub seq_or_ts: u64,
    pub checksum: u32,
}

Fixed 24-byte prefix on every payload appended through the CortEX adapter.

The in-memory layout is whatever the compiler chooses; the wire / on-disk format is produced by Self::to_bytes and consumed by Self::from_bytes.

Fields

dispatch: u8

Event classifier. 0x00..0x7F reserved for CortEX-internal dispatches; 0x80..0xFF for application / vendor use.

flags: u8

Causal / continuity / proof bits. See FLAG_* constants.

_pad: [u8; 2]

Reserved; must be zero on write, ignored on read.

origin_hash: u64

Producer identity — full EntityKeypair::origin_hash() value, not a truncation.

seq_or_ts: u64

Per-origin monotonic counter OR unix nanos. Application identity — orthogonal to the RedEX storage sequence.

checksum: u32

xxh3 truncation of the type-specific tail (the bytes after the 24-byte prefix in the RedEX payload).

Implementations

impl EventMeta

pub fn new( dispatch: u8, flags: u8, origin_hash: u64, seq_or_ts: u64, checksum: u32, ) -> Self

Build an EventMeta with zeroed pad bytes.

pub fn to_bytes(&self) -> [u8; 24]

Encode to the 24-byte little-endian wire format. The reserved _pad bytes are always written as zero regardless of what the caller stuffed into them — the wire contract says “zero on write, ignored on read.”

#[inline(always)] per perf #100 — mirrors the perf #70 fix on RedexEntry::to_bytes. The body is 4 copy_from_slice calls on u64/u32 little-endian bytes plus two byte stores: small enough that the optimizer fuses the writes (e.g. with the next byte that the caller is about to stream into a frame buffer) once the call disappears. Called in the inner loop of every CortEX RPC encode and every per-event checksum re-derive (for_checksum_bytes below), so the per-call overhead matters per-event.

pub fn from_bytes(bytes: &[u8]) -> Option<Self>

Decode from a 24-byte slice. Returns None if the slice is shorter than 24 bytes.

#[inline(always)] per perf #100 — same rationale as Self::to_bytes: small body (one length check + four little-endian field decodes) that’s called in the inner loop of CortEX inbound RPC decode and replication apply.

pub fn has_flag(&self, bits: u8) -> bool

True if flags & bits != 0.

Trait Implementations

impl Clone for EventMeta

fn clone(&self) -> EventMeta

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for EventMeta

impl Debug for EventMeta

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

Formats the value using the given formatter.

impl Eq for EventMeta

impl PartialEq for EventMeta

fn eq(&self, other: &EventMeta) -> bool

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

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 StructuralPartialEq for EventMeta