Trait Source 

pub trait Source: Send + Sync {
    type Family: Family;
    type Digest: Digest;
    type Op;
    type Error: Error + Send + 'static;

    // Required method
    fn serve<'a>(
        &'a self,
        request: Request<Self::Family>,
    ) -> impl Future<Output = Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>> + Send + 'a;
}

A source for proofs and operations.

Required Associated Types

type Family: Family

The merkle family backing this source’s proofs.

type Digest: Digest

The digest type used in this source’s proofs.

type Op

The type of operations this source yields.

type Error: Error + Send + 'static

Why this source could not answer.

Required Methods

fn serve<'a>( &'a self, request: Request<Self::Family>, ) -> impl Future<Output = Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>> + Send + 'a

Serve a request.

Dyn Compatibility

This trait is not dyn compatible.

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

Implementations on Foreign Types

impl<T> Source for Arc<T>

where T: Source + ?Sized,

type Family = <T as Source>::Family

type Digest = <T as Source>::Digest

type Op = <T as Source>::Op

type Error = <T as Source>::Error

fn serve<'a>( &'a self, request: Request<Self::Family>, ) -> impl Future<Output = Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>> + Send + 'a

impl<T> Source for AsyncRwLock<T>

where T: Source,

type Family = <T as Source>::Family

type Digest = <T as Source>::Digest

type Op = <T as Source>::Op

type Error = <T as Source>::Error

async fn serve( &self, request: Request<Self::Family>, ) -> Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>

impl<T> Source for Option<T>

where T: Source, ServeError<T::Family>: From<T::Error>,

type Family = <T as Source>::Family

type Digest = <T as Source>::Digest

type Op = <T as Source>::Op

type Error = ServeError<<T as Source>::Family>

async fn serve( &self, request: Request<Self::Family>, ) -> Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>

impl<T> Source for TracedAsyncRwLock<T>

where T: Source,

type Family = <T as Source>::Family

type Digest = <T as Source>::Digest

type Op = <T as Source>::Op

type Error = <T as Source>::Error

async fn serve( &self, request: Request<Self::Family>, ) -> Result<(Response<Self::Family, Self::Op, Self::Digest>, FeedbackTx), Self::Error>

Implementors

impl<F, E, C, H, S> Source for Journal<F, E, C, H, S>

where F: Family, E: Context, C: Contiguous<Item: EncodeShared + Floored<F>>, H: Hasher, S: Strategy,

type Family = F

type Digest = <H as Hasher>::Digest

type Op = <C as Contiguous>::Item

type Error = Error<F>

impl<F, E, C, I, H, U, const N: usize, S> Source for commonware_storage::qmdb::any::db::Db<F, E, C, I, H, U, N, S>

where F: Family, E: Context, C: Mutable<Item = Operation<F, U>>, I: Unordered<Value = Location<F>>, H: Hasher, U: Update, S: Strategy, Operation<F, U>: Codec,

type Family = F

type Digest = <H as Hasher>::Digest

type Op = Operation<F, U>

type Error = Error<F>

impl<F, E, C, I, H, U, const N: usize, S> Source for commonware_storage::qmdb::current::db::Db<F, E, C, I, H, U, N, S>

where F: Graftable, E: Context, C: Mutable<Item = Operation<F, U>>, I: UnorderedIndex<Value = Location<F>>, H: Hasher, U: Update, S: Strategy, Operation<F, U>: Codec,

A current database serves proofs from the any database it wraps. The sync engine operates on the ops root, which is any’s root.

type Family = F

type Digest = <H as Hasher>::Digest

type Op = Operation<F, U>

type Error = Error<F>

impl<F, E, K, V, C, H, T, S> Source for Immutable<F, E, K, V, C, H, T, S>

where F: Family, E: Context, K: Key, V: ValueEncoding, C: Mutable<Item = Operation<F, K, V>>, C::Item: EncodeShared, H: Hasher, T: Translator, S: Strategy,

type Family = F

type Digest = <H as Hasher>::Digest

type Op = Operation<F, K, V>

type Error = Error<F>

impl<F, E, K, V, H, C, S> Source for commonware_storage::qmdb::immutable::CompactDb<F, E, K, V, H, C, S>

where F: Family, E: Context, K: Key, V: ValueEncoding, H: Hasher, Operation<F, K, V>: EncodeShared + Read<Cfg = C>, C: Clone + Send + Sync + 'static, S: Strategy,

type Family = F

type Digest = <H as Hasher>::Digest

type Op = Operation<F, K, V>

type Error = Error<F>

impl<F, E, V, C, H, S> Source for Keyless<F, E, V, C, H, S>

where F: Family, E: Context, V: ValueEncoding, C: Mutable<Item = Operation<F, V>>, H: Hasher, S: Strategy, Operation<F, V>: EncodeShared,

type Family = F

type Digest = <H as Hasher>::Digest

type Op = Operation<F, V>

type Error = Error<F>

impl<F, E, V, H, C, S> Source for commonware_storage::qmdb::keyless::CompactDb<F, E, V, H, C, S>

where F: Family, E: Context, V: ValueEncoding, H: Hasher, Operation<F, V>: EncodeShared + Read<Cfg = C>, C: Clone + Send + Sync + 'static, S: Strategy,

type Family = F

type Digest = <H as Hasher>::Digest

type Op = Operation<F, V>

type Error = Error<F>