Trait noosphere_storage::BlockStore

source · 
pub trait BlockStore: Clone + BlockStoreSendSync {
    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;

    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> + BlockStoreSend + '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 + BlockStoreSend + '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 + BlockStoreSend + '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,
    { ... }
}
Expand description

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§

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

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

Provided Methods§

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.

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.

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.

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

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.

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

Implementors§