Skip to main content

StreamProvider

acyclic_stream

Trait StreamProvider 

Source 
pub trait StreamProvider:
    Send
    + Sync
    + 'static {
    // Required methods
    fn inspect_idempotency<'life0, 'async_trait>(
        &'life0 self,
        idempotency_key: IdempotencyKey,
    ) -> Pin<Box<dyn Future<Output = Result<Option<IdempotencyObservation>, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn tail<'life0, 'async_trait>(
        &'life0 self,
        path: StreamPath,
    ) -> Pin<Box<dyn Future<Output = Result<u64, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn append<'life0, 'async_trait>(
        &'life0 self,
        request: AppendRequest,
    ) -> Pin<Box<dyn Future<Output = Result<AppendOutcome, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn fork<'life0, 'async_trait>(
        &'life0 self,
        request: ForkRequest,
    ) -> Pin<Box<dyn Future<Output = Result<ForkReceipt, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn trim<'life0, 'async_trait>(
        &'life0 self,
        path: StreamPath,
        before: u64,
        idempotency_key: IdempotencyKey,
    ) -> Pin<Box<dyn Future<Output = Result<TrimReceipt, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn delete<'life0, 'async_trait>(
        &'life0 self,
        path: StreamPath,
        idempotency_key: IdempotencyKey,
    ) -> Pin<Box<dyn Future<Output = Result<DeleteReceipt, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn read<'life0, 'async_trait>(
        &'life0 self,
        request: ReadRequest,
    ) -> Pin<Box<dyn Future<Output = Result<RecordStream, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn follow<'life0, 'async_trait>(
        &'life0 self,
        path: StreamPath,
        from: u64,
    ) -> Pin<Box<dyn Future<Output = Result<RecordStream, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn children<'life0, 'async_trait>(
        &'life0 self,
        request: ChildrenRequest,
    ) -> Pin<Box<dyn Future<Output = Result<ChildStream, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn commit<'life0, 'async_trait>(
        &'life0 self,
        request: CommitRequest,
    ) -> Pin<Box<dyn Future<Output = Result<CommitOutcome, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
    fn read_commit<'life0, 'async_trait>(
        &'life0 self,
        commit_id: CommitId,
    ) -> Pin<Box<dyn Future<Output = Result<CommittedEnvelope, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;

    // Provided method
    fn commit_before<'life0, 'async_trait>(
        &'life0 self,
        request: CommitRequest,
        deadline_unix_millis: u64,
    ) -> Pin<Box<dyn Future<Output = Result<CommitOutcome, StreamError>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait { ... }
}
Expand description

Canonical provider contract. Placement and transport remain invisible.

Required Methods§

Source

fn inspect_idempotency<'life0, 'async_trait>( &'life0 self, idempotency_key: IdempotencyKey, ) -> Pin<Box<dyn Future<Output = Result<Option<IdempotencyObservation>, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Reads the retained terminal result for one caller-owned retry identity.

Source

fn tail<'life0, 'async_trait>( &'life0 self, path: StreamPath, ) -> Pin<Box<dyn Future<Output = Result<u64, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Current next sequence.

Source

fn append<'life0, 'async_trait>( &'life0 self, request: AppendRequest, ) -> Pin<Box<dyn Future<Output = Result<AppendOutcome, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Atomic append or tail conflict.

Source

fn fork<'life0, 'async_trait>( &'life0 self, request: ForkRequest, ) -> Pin<Box<dyn Future<Output = Result<ForkReceipt, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Atomic immutable-prefix fork.

Source

fn trim<'life0, 'async_trait>( &'life0 self, path: StreamPath, before: u64, idempotency_key: IdempotencyKey, ) -> Pin<Box<dyn Future<Output = Result<TrimReceipt, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Monotonically advances a path’s logical trim point.

Source

fn delete<'life0, 'async_trait>( &'life0 self, path: StreamPath, idempotency_key: IdempotencyKey, ) -> Pin<Box<dyn Future<Output = Result<DeleteReceipt, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Permanently retires a path with no live descendants.

Source

fn read<'life0, 'async_trait>( &'life0 self, request: ReadRequest, ) -> Pin<Box<dyn Future<Output = Result<RecordStream, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Opens a bounded finite read.

Source

fn follow<'life0, 'async_trait>( &'life0 self, path: StreamPath, from: u64, ) -> Pin<Box<dyn Future<Output = Result<RecordStream, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Replays and then remains live without a handoff gap.

Source

fn children<'life0, 'async_trait>( &'life0 self, request: ChildrenRequest, ) -> Pin<Box<dyn Future<Output = Result<ChildStream, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Lists one fixed-snapshot direct-child page.

Source

fn commit<'life0, 'async_trait>( &'life0 self, request: CommitRequest, ) -> Pin<Box<dyn Future<Output = Result<CommitOutcome, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Executes one all-or-nothing optimistic commit.

Source

fn read_commit<'life0, 'async_trait>( &'life0 self, commit_id: CommitId, ) -> Pin<Box<dyn Future<Output = Result<CommittedEnvelope, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Reads one complete immutable successful envelope.

Provided Methods§

Source

fn commit_before<'life0, 'async_trait>( &'life0 self, request: CommitRequest, deadline_unix_millis: u64, ) -> Pin<Box<dyn Future<Output = Result<CommitOutcome, StreamError>> + Send + 'async_trait>>
where Self: 'async_trait, 'life0: 'async_trait,

Executes one coordinated commit only if the provider’s trusted clock is strictly before deadline_unix_millis at the linearization point.

Exact idempotent replay is resolved before the deadline. Providers that cannot enforce this atomically fail closed with StreamError::Unsupported.

Dyn Compatibility§

This trait is dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety".

Implementors§