Enum AnyEventLog 

pub enum AnyEventLog {
    Memory(MemoryEventLog),
    File(FileEventLog),
    Sqlite(SqliteEventLog),
}

Variants

Memory(MemoryEventLog)

File(FileEventLog)

Sqlite(SqliteEventLog)

Implementations

impl AnyEventLog

pub async fn topics(&self) -> Result<Vec<Topic>, LogError>

pub async fn append_idempotent_by_header( &self, topic: &Topic, header: &str, value: &str, event: LogEvent, ) -> Result<AppendOutcome, LogError>

pub async fn append_idempotent_chained_by_header( &self, topic: &Topic, header: &str, value: &str, expected_head: Option<&str>, event: LogEvent, ) -> Result<AppendOutcome, LogError>

Append a new idempotent event only when the topic’s provenance-chain head still equals expected_head.

An existing (header, value) identity is returned before the head is compared, so a retry remains idempotent even after later events advance the chain. For a new identity, lookup, head comparison, and append are one backend-owned critical section. None requires an empty topic.

pub async fn verify_topic( &self, topic: &Topic, ) -> Result<EventLogVerificationReport, LogError>

Recompute and verify the complete provenance chain for one topic.

Verification starts at the topic genesis. A compacted prefix therefore cannot be reported as a complete verified chain without a future typed checkpoint contract that binds the retained first event to that prefix.

pub async fn verified_snapshot_by_header( &self, topic: &Topic, header: &str, value: &str, ) -> Result<VerifiedEventSnapshot, LogError>

Verify one retained topic snapshot and return only events matching a header projection. The topic is materialized once, so typed aggregate readers do not race or repeatedly rescan it between verification and filtering.

pub async fn read_idempotent_by_header( &self, topic: &Topic, header: &str, value: &str, ) -> Result<Option<(EventId, LogEvent)>, LogError>

Read the event previously appended under (header, value), the read counterpart of Self::append_idempotent_by_header. On the SQLite backend this is an indexed JOIN; the memory/file dev backends scan.

Trait Implementations

impl EventLog for AnyEventLog

fn describe(&self) -> EventLogDescription

async fn append( &self, topic: &Topic, event: LogEvent, ) -> Result<EventId, LogError>

async fn flush(&self) -> Result<(), LogError>

async fn read_range( &self, topic: &Topic, from: Option<EventId>, limit: usize, ) -> Result<Vec<(EventId, LogEvent)>, LogError>

Read events strictly after from. None starts from the beginning of the topic.

async fn read_range_bytes( &self, topic: &Topic, from: Option<EventId>, limit: usize, ) -> Result<Vec<(EventId, LogEventBytes)>, LogError>

async fn subscribe( self: Arc<Self>, topic: &Topic, from: Option<EventId>, ) -> Result<BoxStream<'static, Result<(EventId, LogEvent), LogError>>, LogError>

async fn keeps the ergonomic generic surface; the boxed stream preserves dyn-dispatch for callers that store Arc<dyn EventLog>.

async fn ack( &self, topic: &Topic, consumer: &ConsumerId, up_to: EventId, ) -> Result<(), LogError>

async fn consumer_cursor( &self, topic: &Topic, consumer: &ConsumerId, ) -> Result<Option<EventId>, LogError>

async fn latest(&self, topic: &Topic) -> Result<Option<EventId>, LogError>

async fn compact( &self, topic: &Topic, before: EventId, ) -> Result<CompactReport, LogError>