Struct EventStoreEntry 

pub struct EventStoreEntry {
    pub entry_hash: EntryHash,
    pub seq: u64,
    pub headers: Headers,
    pub topic: Topic,
    pub payload_type: PayloadType,
    pub payload: Bytes,
    pub ts_init: UnixNanos,
    pub ts_publish: UnixNanos,
}

One captured row in the event store: a state-affecting bus message plus metadata.

The fields cover the SPEC’s logical entry contract:

• seq is the per-run monotonic sequence assigned by the writer at commit time. It is the replay-order authority.
• ts_init is the domain timestamp; strictly monotonic and unique system-wide via the shared AtomicTime.
• ts_publish records when the writer received the entry (and, when populated by the bus, when the bus accepted it for fanout). Neither timestamp orders replay.
• topic and payload_type describe the logical message identity; the writer commits them verbatim.
• payload carries the canonical bytes produced by the registered encoder.
• headers carry first-class correlation metadata.
• entry_hash is the canonical hash recomputed on every read; mismatch quarantines the run.

Fields

entry_hash: EntryHash

The canonical hash over every preceding field.

seq: u64

The per-run monotonic sequence; replay-order authority.

headers: Headers

First-class correlation headers.

topic: Topic

The logical bus topic this entry was captured on.

payload_type: PayloadType

The canonical payload type tag chosen by the bus capture adapter.

payload: Bytes

The canonical encoded payload bytes.

ts_init: UnixNanos

The domain timestamp from AtomicTime.

ts_publish: UnixNanos

The bus-accepted or writer-receive timestamp.

Implementations

impl EventStoreEntry

pub fn new( entry_hash: EntryHash, seq: u64, headers: Headers, topic: Topic, payload_type: PayloadType, payload: Bytes, ts_init: UnixNanos, ts_publish: UnixNanos, ) -> Self

Creates a new EventStoreEntry with all fields supplied by the writer.

pub fn recompute_hash(&self) -> EntryHash

Recomputes the canonical hash for this entry from its current fields.

Backends call this on every read to validate entry_hash; mismatch quarantines the run.

Trait Implementations

impl Clone for EventStoreEntry

fn clone(&self) -> EventStoreEntry

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EventStoreEntry

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for EventStoreEntry

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for EventStoreEntry

impl PartialEq for EventStoreEntry

fn eq(&self, other: &EventStoreEntry) -> 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 Serialize for EventStoreEntry

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EventStoreEntry