Struct ipld_amt::Amt

pub struct Amt<'db, V, BS> { /* fields omitted */ }

Array Mapped Trie allows for the insertion and persistence of data, serializable to a CID.

Amt is not threadsafe and can't be shared between threads.

Usage:

use ipld_amt::Amt;

let db = db::MemoryDB::default();
let mut amt = Amt::new(&db);

// Insert or remove any serializable values
amt.set(2, "foo".to_owned()).unwrap();
amt.set(1, "bar".to_owned()).unwrap();
amt.delete(2).unwrap();
assert_eq!(amt.count(), 1);
let bar: &String = amt.get(1).unwrap().unwrap();

// Generate cid by calling flush to remove cache
let cid = amt.flush().unwrap();

Implementations

impl<'db, V, BS> Amt<'db, V, BS> where
    V: DeserializeOwned + Serialize,
    BS: BlockStore, 

pub fn new(block_store: &'db BS) -> Self

Constructor for Root AMT node

pub fn load(cid: &Cid, block_store: &'db BS) -> Result<Self, Error>

Constructs an AMT with a blockstore and a Cid of the root of the AMT

pub fn height(&self) -> u64

Gets the height of the Amt.

pub fn count(&self) -> u64

Gets count of elements added in the Amt.

pub fn new_from_slice(block_store: &'db BS, vals: &[V]) -> Result<Cid, Error> where
    V: Clone, 

Generates an AMT with block store and array of cbor marshallable objects and returns Cid

pub fn get(&self, i: u64) -> Result<Option<&V>, Error>

Get value at index of AMT

pub fn set(&mut self, i: u64, val: V) -> Result<(), Error>

Set value at index

pub fn batch_set(&mut self, vals: &[V]) -> Result<(), Error> where
    V: Clone, 

Batch set (naive for now)

pub fn delete(&mut self, i: u64) -> Result<bool, Error>

Delete item from AMT at index

pub fn batch_delete(
    &mut self,
    iter: impl IntoIterator<Item = u64>
) -> Result<(), Error>

Deletes multiple items from AMT

pub fn flush(&mut self) -> Result<Cid, Error>

flush root and return Cid used as key in block store

pub fn for_each<F>(&self, f: F) -> Result<(), Box<dyn StdError>> where
    F: FnMut(u64, &V) -> Result<(), Box<dyn StdError>>, 

Iterates over each value in the Amt and runs a function on the values.

The index in the amt is a u64 and the value is the generic parameter V as defined in the Amt.

Examples

use ipld_amt::Amt;

let store = db::MemoryDB::default();

let mut map: Amt<String, _> = Amt::new(&store);
map.set(1, "One".to_owned()).unwrap();
map.set(4, "Four".to_owned()).unwrap();

let mut values: Vec<(u64, String)> = Vec::new();
map.for_each(|i, v| {
   values.push((i, v.clone()));
   Ok(())
}).unwrap();
assert_eq!(&values, &[(1, "One".to_owned()), (4, "Four".to_owned())]);

pub fn for_each_while<F>(&self, f: F) -> Result<(), Box<dyn StdError>> where
    F: FnMut(u64, &V) -> Result<bool, Box<dyn StdError>>, 

Iterates over each value in the Amt and runs a function on the values, for as long as that function keeps returning true.

pub fn for_each_mut<F>(&mut self, f: F) -> Result<(), Box<dyn StdError>> where
    V: Clone,
    F: FnMut(u64, &mut ValueMut<'_, V>) -> Result<(), Box<dyn StdError>>, 

Iterates over each value in the Amt and runs a function on the values that allows modifying each value.

pub fn for_each_while_mut<F>(&mut self, f: F) -> Result<(), Box<dyn StdError>> where
    V: Clone,
    F: FnMut(u64, &mut ValueMut<'_, V>) -> Result<bool, Box<dyn StdError>>, 

Iterates over each value in the Amt and runs a function on the values that allows modifying each value, for as long as that function keeps returning true.

Trait Implementations

impl<'db, V: Debug, BS: Debug> Debug for Amt<'db, V, BS>

pub fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'a, V: PartialEq, BS: BlockStore> PartialEq<Amt<'a, V, BS>> for Amt<'a, V, BS>

pub fn eq(&self, other: &Self) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.