Struct libipld::mem::MemStore

pub struct MemStore<S: StoreParams> { /* fields omitted */ }

A memory backed store

Implementations

impl<S: StoreParams> MemStore<S> where
    Ipld: Decode<S::Codecs>, 

pub fn new(global: Arc<GlobalStore<S>>) -> Self

Create a new empty MemStore

pub async fn blocks<'_>(&'_ self) -> Vec<Cid>

Returns a vec of all cid's in the store.

pub async fn status<'_, '_>(&'_ self, cid: &'_ Cid) -> Option<Status>

Returns the status of a block.

pub async fn info<'a>(&'a self, cid: &'a Cid) -> Option<BlockInfo<S>>

Returns the block info.

Trait Implementations

impl<S: StoreParams> AliasStore for MemStore<S> where
    Ipld: Decode<S::Codecs>, 

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

Creates an alias for a Cid with announces the alias on the public network.

fn unalias<'life0, 'life1, 'async_trait>(
    &'life0 self,
    alias: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Removes an alias for a Cid.

fn resolve<'life0, 'life1, 'async_trait>(
    &'life0 self,
    alias: &'life1 [u8]
) -> Pin<Box<dyn Future<Output = Result<Option<Cid>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Resolves an alias for a Cid.

impl<S: Clone + StoreParams> Clone for MemStore<S>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<S: StoreParams> Default for MemStore<S>

fn default() -> Self

Returns the "default value" for a type.

impl<S: StoreParams> Store for MemStore<S> where
    Ipld: Decode<S::Codecs>, 

type Params = S

Store parameters.

fn get<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cid: &'life1 Cid
) -> Pin<Box<dyn Future<Output = Result<Block<S>>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Returns a block from the store. If the store supports networking and the block is not in the store it fetches it from the network. Dropping the future cancels the request. This will not insert the block into the store.

fn commit<'life0, 'async_trait>(
    &'life0 self,
    tx: Transaction<S>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Commits a transaction to the store.

#[must_use]fn insert<'life0, 'async_trait>(
    &'life0 self,
    block: Block<Self::Params>
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    Ipld: Decode<<Self::Params as StoreParams>::Codecs>,
    'life0: 'async_trait,
    Self: 'async_trait, 

Inserts a block into the store.

#[must_use]fn unpin<'life0, 'life1, 'async_trait>(
    &'life0 self,
    cid: &'life1 Cid
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: 'async_trait, 

Unpins a block from the store.

#[must_use]fn query<'life0, 'life1, 'life2, 'async_trait>(
    &'life0 self,
    path: &'life1 DagPath<'life2>
) -> Pin<Box<dyn Future<Output = Result<Ipld>> + Send + 'async_trait>> where
    Ipld: Decode<<Self::Params as StoreParams>::Codecs>,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait, 

Resolves a path recursively and returns the ipld.

#[must_use]fn sync<'life0, 'async_trait>(
    &'life0 self,
    old: Option<Cid>,
    new: Cid
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    Ipld: Decode<<Self::Params as StoreParams>::Codecs>,
    'life0: 'async_trait,
    Self: 'async_trait, 

Recursively gets a block and all it's references, inserts them into the store, pins the root and unpins the old root.

#[must_use]fn flush<'life0, 'async_trait>(
    &'life0 self
) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>> where
    'life0: 'async_trait,
    Self: 'async_trait, 

Flushes the write buffer.