Trait Contiguous 

pub trait Contiguous: Send + Sync {
    type Item;

    // Required methods
    fn bounds(&self) -> Range<u64>;
    fn replay(
        &self,
        start_pos: u64,
        buffer: NonZeroUsize,
    ) -> impl Future<Output = Result<impl Stream<Item = Result<(u64, Self::Item), Error>> + Send + '_, Error>> + Send;
    fn read(
        &self,
        position: u64,
    ) -> impl Future<Output = Result<Self::Item, Error>> + Send;

    // Provided method
    fn size(&self) -> u64 { ... }
}

Core trait for contiguous journals supporting sequential append operations.

A contiguous journal maintains a consecutively increasing position counter where each appended item receives a unique position starting from 0.

Required Associated Types

type Item

The type of items stored in the journal.

Required Methods

fn bounds(&self) -> Range<u64>

Returns [start, end) where start and end - 1 are the indices of the oldest and newest retained operations respectively.

fn replay( &self, start_pos: u64, buffer: NonZeroUsize, ) -> impl Future<Output = Result<impl Stream<Item = Result<(u64, Self::Item), Error>> + Send + '_, Error>> + Send

Return a stream of all items in the journal starting from start_pos.

Each item is yielded as a tuple (position, item) where position is the item’s stable position in the journal.

Errors

Returns an error if start_pos exceeds the journal size or if any storage/decoding errors occur during replay.

fn read( &self, position: u64, ) -> impl Future<Output = Result<Self::Item, Error>> + Send

Read the item at the given position.

Errors

• Returns Error::ItemPruned if the item at position has been pruned.
• Returns Error::ItemOutOfRange if the item at position does not exist.

Provided Methods

fn size(&self) -> u64

Return the total number of items that have been appended to the journal.

This count is NOT affected by pruning. The next appended item will receive this position as its value.

Equivalent to bounds().end.

Dyn Compatibility

This trait is not dyn compatible.

In older versions of Rust, dyn compatibility was called "object safety", so this trait is not object safe.

Implementors

impl<E, C, H, S> Contiguous for commonware_storage::journal::authenticated::Journal<E, C, H, S>

where E: Storage + Clock + Metrics, C: MutableContiguous<Item: EncodeShared>, H: Hasher, S: State<DigestOf<H>> + Send + Sync,

type Item = <C as Contiguous>::Item

impl<E: Clock + Storage + Metrics, A: CodecFixedShared> Contiguous for commonware_storage::journal::contiguous::fixed::Journal<E, A>

type Item = A

impl<E: Clock + Storage + Metrics, V: CodecShared> Contiguous for commonware_storage::journal::contiguous::variable::Journal<E, V>

type Item = V