Trait BlockStore 

pub trait BlockStore: Clone + ConditionalSync {
    // Required methods
    fn put_block<'life0, 'life1, 'life2, 'async_trait>(
        &'life0 mut self,
        cid: &'life1 Cid,
        block: &'life2 [u8],
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait;
    fn get_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cid: &'life1 Cid,
    ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>
       where Self: 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait;

    // Provided methods
    fn put_links<'life0, 'life1, 'life2, 'async_trait, C>(
        &'life0 mut self,
        cid: &'life1 Cid,
        block: &'life2 [u8],
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where C: Codec + Default + 'async_trait,
             Ipld: References<C>,
             Self: Send + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait,
             'life2: 'async_trait { ... }
    fn put<'life0, 'async_trait, C, T>(
        &'life0 mut self,
        data: T,
    ) -> Pin<Box<dyn Future<Output = Result<Cid>> + Send + 'async_trait>>
       where C: Codec + Default + 'async_trait,
             T: Encode<C> + ConditionalSend + 'async_trait,
             Ipld: References<C>,
             Self: Send + 'async_trait,
             'life0: 'async_trait { ... }
    fn get<'life0, 'life1, 'async_trait, C, T>(
        &'life0 self,
        cid: &'life1 Cid,
    ) -> Pin<Box<dyn Future<Output = Result<Option<T>>> + Send + 'async_trait>>
       where C: Codec + Default + 'async_trait,
             T: Decode<C> + 'async_trait,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn save<'life0, 'async_trait, C, T>(
        &'life0 mut self,
        data: T,
    ) -> Pin<Box<dyn Future<Output = Result<Cid>> + Send + 'async_trait>>
       where C: Codec + Default + 'async_trait,
             T: Serialize + ConditionalSend + 'async_trait,
             Ipld: Encode<C> + References<C>,
             Self: Send + 'async_trait,
             'life0: 'async_trait { ... }
    fn load<'life0, 'life1, 'async_trait, C, T>(
        &'life0 self,
        cid: &'life1 Cid,
    ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>
       where C: Codec + Default + 'async_trait,
             T: DeserializeOwned + ConditionalSend + 'async_trait,
             u64: From<C>,
             Ipld: Decode<C>,
             Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn require_block<'life0, 'life1, 'async_trait>(
        &'life0 self,
        cid: &'life1 Cid,
    ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait,
             'life1: 'async_trait { ... }
    fn flush<'life0, 'async_trait>(
        &'life0 self,
    ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>
       where Self: Sync + 'async_trait,
             'life0: 'async_trait { ... }
}

An interface for storage backends that are suitable for storing blocks. A block is a chunk of bytes that can be addressed by a CID. Any backend that implements this trait should be able to reliably store and retrieve blocks given a Cid.

Required Methods

fn put_block<'life0, 'life1, 'life2, 'async_trait>( &'life0 mut self, cid: &'life1 Cid, block: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Given a block and its Cid, persist the block in storage.

fn get_block<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<Option<Vec<u8>>>> + Send + 'async_trait>>

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

Given the Cid of a block, retrieve the block bytes from storage.

Provided Methods

fn put_links<'life0, 'life1, 'life2, 'async_trait, C>( &'life0 mut self, cid: &'life1 Cid, block: &'life2 [u8], ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where C: Codec + Default + 'async_trait, Ipld: References<C>, Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

Given a CID and a block, store the links (any Cid that is part of the encoded data) in a suitable location for later retrieval. This method is optional, and its default implementation is a no-op. It should be implemented when possible to enable optimized traversal of a DAG given its root.

fn put<'life0, 'async_trait, C, T>( &'life0 mut self, data: T, ) -> Pin<Box<dyn Future<Output = Result<Cid>> + Send + 'async_trait>>

where C: Codec + Default + 'async_trait, T: Encode<C> + ConditionalSend + 'async_trait, Ipld: References<C>, Self: Send + 'async_trait, 'life0: 'async_trait,

Given some data structure that implements Encode for a given Codec, encode it as a block and persist it to storage for later retrieval by Cid.

fn get<'life0, 'life1, 'async_trait, C, T>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<Option<T>>> + Send + 'async_trait>>

where C: Codec + Default + 'async_trait, T: Decode<C> + 'async_trait, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given the Cid of a block that refers to a type that implements Decode for some Codec, retrieve the block, decode it as the type and return the result.

fn save<'life0, 'async_trait, C, T>( &'life0 mut self, data: T, ) -> Pin<Box<dyn Future<Output = Result<Cid>> + Send + 'async_trait>>

where C: Codec + Default + 'async_trait, T: Serialize + ConditionalSend + 'async_trait, Ipld: Encode<C> + References<C>, Self: Send + 'async_trait, 'life0: 'async_trait,

Given some data structure that implements Serialize, convert it to an IPLD-compatible representation, encode it as a block with the desired Codec and persist it to the storage backend by its Cid

fn load<'life0, 'life1, 'async_trait, C, T>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<T>> + Send + 'async_trait>>

where C: Codec + Default + 'async_trait, T: DeserializeOwned + ConditionalSend + 'async_trait, u64: From<C>, Ipld: Decode<C>, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Given a Cid that refers to some data structure that implements Deserialize, read the block bytes from storage, decode it as IPLD using the specified Codec and and deserialize it to the intended data structure, returning the result.

fn require_block<'life0, 'life1, 'async_trait>( &'life0 self, cid: &'life1 Cid, ) -> Pin<Box<dyn Future<Output = Result<Vec<u8>>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Same as load, but returns an error if no block is found locally for the given Cid

fn flush<'life0, 'async_trait>( &'life0 self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: Sync + 'async_trait, 'life0: 'async_trait,

Flushes pending writes if there are any

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<S> BlockStore for BlockStoreRetry<S>

where S: BlockStore,

impl<S> BlockStore for BlockStoreTap<S>

where S: BlockStore,

impl<S> BlockStore for SphereDb<S>

where S: Storage,

impl<S> BlockStore for S

where S: Store,