Struct BlockStoreTap 

pub struct BlockStoreTap<S>
where
    S: BlockStore,
{ /* private fields */ }

Wraps any BlockStore and “taps” it by cloning any block successfully retrieved from the store and sending over an MPSC channel. This allows an observer to record all the blocks needed to load arbitrarily deep and complex DAGs into memory without orchestrating a dedicated callback for the DAG implementations to invoke.

Note that the Receiver end of the channel will consider the channel open (and thus will continue to await values) until all of its associated BlockStoreTap clones are dropped. If you expect a finite number of blocks to be sent to the Receiver, ensure that all BlockStoreTap clones are eventually dropped. Otherwise, the Receiver will continue waiting to receive blocks.

Implementations

impl<S> BlockStoreTap<S>

where S: BlockStore,

pub fn new(store: S, capacity: usize) -> (Self, Receiver<(Cid, Vec<u8>)>)

Trait Implementations

impl<S> BlockStore for BlockStoreTap<S>

where S: BlockStore,

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.

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

impl<S> Clone for BlockStoreTap<S>

where S: BlockStore + Clone,

fn clone(&self) -> BlockStoreTap<S>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.