Trait BucketSource 

pub trait BucketSource:
    Send
    + Sync
    + 'static {
    type Bucket: Send + Sync;
    type K: Send + Sync;
    type V: Send + Sync;
    type All: Stream<Item = Result<(Self::K, Self::V), Status>> + Send + Unpin + 'static;

    // Required method
    fn get_all_by_bucket<'life0, 'async_trait>(
        &'life0 self,
        b: Self::Bucket,
    ) -> Pin<Box<dyn Future<Output = Result<Self::All, Status>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait;
}

Source of buckets(a bucket has key/val pairs)

Required Associated Types

type Bucket: Send + Sync

type K: Send + Sync

type V: Send + Sync

type All: Stream<Item = Result<(Self::K, Self::V), Status>> + Send + Unpin + 'static

Required Methods

fn get_all_by_bucket<'life0, 'async_trait>( &'life0 self, b: Self::Bucket, ) -> Pin<Box<dyn Future<Output = Result<Self::All, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Gets all key/val pairs from a bucket Self::Bucket

Dyn Compatibility

This trait is dyn compatible.

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

Implementations on Foreign Types

impl<A> BucketSource for Arc<A>

where A: BucketSource,

type Bucket = <A as BucketSource>::Bucket

type K = <A as BucketSource>::K

type V = <A as BucketSource>::V

type All = <A as BucketSource>::All

fn get_all_by_bucket<'life0, 'async_trait>( &'life0 self, b: Self::Bucket, ) -> Pin<Box<dyn Future<Output = Result<Self::All, Status>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Implementors

impl<A, B, M> BucketSource for BucketMerge<A, B, M>

where A: BucketSource<Bucket = ()>, A::K: Ord, A::V: Clone, B: BucketSource<K = A::K>, M: Clone + Merge<A = A::V, B = B::V>,

type Bucket = <B as BucketSource>::Bucket

type K = <A as BucketSource>::K

type V = <M as Merge>::T

type All = ReceiverStream<Result<(<BucketMerge<A, B, M> as BucketSource>::K, <BucketMerge<A, B, M> as BucketSource>::V), Status>>

impl<B, C> BucketSource for ConvSource<B, C>

where B: BucketSource, B::K: Clone, C: Clone + Converter<Input = (B::K, B::V)>,

type Bucket = <B as BucketSource>::Bucket

type K = <B as BucketSource>::K

type V = <C as Converter>::Output

type All = ReceiverStream<Result<(<ConvSource<B, C> as BucketSource>::K, <ConvSource<B, C> as BucketSource>::V), Status>>

impl<M, B> BucketSource for BucketSrcMapd<M, B>

where M: Clone + Mapper, B: BucketSource<K = M::IK, V = M::IV>,

type Bucket = <B as BucketSource>::Bucket

type K = <M as Mapper>::OK

type V = <M as Mapper>::OV

type All = ReceiverStream<Result<(<BucketSrcMapd<M, B> as BucketSource>::K, <BucketSrcMapd<M, B> as BucketSource>::V), Status>>

impl<M, S> BucketSource for MergedSource<M, S>

where M: Merger + Clone, S::K: Clone, S: MemSource<Bucket = M::Bucket, K = M::K, V = M::T>,

type Bucket = (Vec<<S as MemSource>::K>, Vec<<S as MemSource>::Bucket>)

type K = <S as MemSource>::K

type V = <M as Merger>::U

type All = ReceiverStream<Result<(<MergedSource<M, S> as BucketSource>::K, <MergedSource<M, S> as BucketSource>::V), Status>>

impl<R> BucketSource for ReadSrc<R>

where R: ReadSource,

type Bucket = <R as ReadSource>::Bucket

type K = usize

type V = Vec<u8>

type All = ReceiverStream<Result<(<ReadSrc<R> as BucketSource>::K, <ReadSrc<R> as BucketSource>::V), Status>>