Struct ipfs_embed_core::Transaction

pub struct Transaction<S> { /* fields omitted */ }

An atomic store transaction.

Implementations

impl<S> Transaction<S> where
    S: StoreParams, 

pub fn new() -> Transaction<S>

Creates a new transaction.

pub fn with_capacity(capacity: usize) -> Transaction<S>

Creates a transaction with capacity.

pub fn is_empty(&self) -> bool

Is empty.

pub fn len(&self) -> usize

Len.

pub fn pin(&mut self, cid: Cid)

Increases the pin count of a block.

pub fn unpin(&mut self, cid: Cid)

Decreases the pin count of a block.

pub fn update(&mut self, old: Option<Cid>, new: Cid)

Update a block.

Pins the new block and unpins the old one.

pub fn import(&mut self, block: Block<S>) -> Result<(), Error> where
    Ipld: Decode<<S as StoreParams>::Codecs>, 

Imports a block.

This will add the block to the front of the transaction.

When importing blocks from a network, they'll be fetched in reverse order. This ensures that when inserting the block all it's references have been inserted.

pub fn insert(&mut self, block: Block<S>) -> Result<(), Error> where
    Ipld: Decode<<S as StoreParams>::Codecs>, 

Inserts a block.

This will add the block to the end of the transaction.

pub fn create<CE, T>(
    &mut self,
    codec: CE,
    hash: u64,
    value: &T
) -> Result<Cid, Error> where
    CE: Codec + Into<<S as StoreParams>::Codecs>,
    T: Encode<CE> + ?Sized,
    Ipld: Decode<<S as StoreParams>::Codecs>, 

Creates a block.

This will add the block to the end of the transaction.

When constructing blocks, the all references need to be created before the referrer.

Trait Implementations

impl<S> Default for Transaction<S> where
    S: StoreParams, 

fn default() -> Transaction<S>

Returns the "default value" for a type.

impl<S> IntoIterator for Transaction<S> where
    S: StoreParams, 

type Item = Op<S>

The type of the elements being iterated over.

type IntoIter = IntoIter<<Transaction<S> as IntoIterator>::Item>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <Transaction<S> as IntoIterator>::IntoIter

Creates an iterator from a value.

impl<'a, S> IntoIterator for &'a Transaction<S> where
    S: StoreParams, 

type Item = &'a Op<S>

The type of the elements being iterated over.

type IntoIter = Iter<'a, Op<S>>

Which kind of iterator are we turning this into?

fn into_iter(self) -> <&'a Transaction<S> as IntoIterator>::IntoIter

Creates an iterator from a value.