Struct Hamt

pub struct Hamt<K: CondSync, V: CondSync, H = Hasher>
where
    H: Hasher + CondSync,
{
    pub root: Arc<Node<K, V, H>>,
    pub version: Version,
}

Hash Array Mapped Trie (HAMT) is an implementation of an associative array that combines the characteristics of a hash table and an array mapped trie.

This type wraps the actual implementation which can be found in the Node.

Examples

use wnfs_hamt::Hamt;

let hamt = Hamt::<String, usize>::new();
println!("HAMT: {:?}", hamt);

Fields

root: Arc<Node<K, V, H>>

version: Version

Implementations

impl<K: CondSync, V: CondSync, H: Hasher + CondSync> Hamt<K, V, H>

pub fn new() -> Self

Creates a new empty HAMT.

Examples

use wnfs_hamt::Hamt;

let hamt = Hamt::<String, usize>::new();
println!("HAMT: {:?}", hamt);

pub fn with_root(root: Arc<Node<K, V, H>>) -> Self

Creates a new HAMT with the given root node.

Examples

use std::sync::Arc;
use wnfs_hamt::{Hamt, Node};

let hamt = Hamt::<String, usize>::with_root(Arc::new(Node::default()));

println!("HAMT: {:?}", hamt);

pub async fn diff( &self, other: &Self, store: &impl BlockStore, ) -> Result<Vec<KeyValueChange<K, V>>>

where K: Storable + Clone + Eq + Hash + AsRef<[u8]>, V: Storable + Clone + Eq, K::Serializable: Serialize + DeserializeOwned, V::Serializable: Serialize + DeserializeOwned,

Gets the difference between two HAMTs at the key-value level.

Examples

use std::sync::Arc;
use wnfs_hamt::{Hamt, Node};
use wnfs_common::MemoryBlockStore;

#[async_std::main]
async fn main() {
    let store = &MemoryBlockStore::default();

    let main_hamt = Hamt::<String, usize>::with_root({
        let mut node = Arc::new(Node::default());
        node.set("foo".into(), 400, store).await.unwrap();
        node.set("bar".into(), 500, store).await.unwrap();
        node
    });

    let other_hamt = Hamt::<String, usize>::with_root({
        let mut node = Arc::new(Node::default());
        node.set("foo".into(), 200, store).await.unwrap();
        node.set("qux".into(), 600, store).await.unwrap();
        node
    });

    let diff = main_hamt.diff(&other_hamt, store).await.unwrap();

    println!("diff: {:#?}", diff);
}

Trait Implementations

impl<K: Clone + CondSync, V: Clone + CondSync, H> Clone for Hamt<K, V, H>

where H: Hasher + CondSync + Clone,

fn clone(&self) -> Hamt<K, V, H>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<K: Debug + CondSync, V: Debug + CondSync, H> Debug for Hamt<K, V, H>

where H: Hasher + CondSync + Debug,

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

Formats the value using the given formatter.

impl<K: CondSync, V: CondSync, H: Hasher + CondSync> Default for Hamt<K, V, H>

fn default() -> Self

Returns the “default value” for a type.

impl<K, V, H> PartialEq for Hamt<K, V, H>

where K: Storable + PartialEq + CondSync, V: Storable + PartialEq + CondSync, K::Serializable: Serialize + DeserializeOwned, V::Serializable: Serialize + DeserializeOwned, H: Hasher + CondSync,

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

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<K, V, H> Storable for Hamt<K, V, H>

where K: Storable + CondSync, V: Storable + CondSync, K::Serializable: Serialize + DeserializeOwned, V::Serializable: Serialize + DeserializeOwned, H: Hasher + CondSync,

type Serializable = HamtSerializable<<K as Storable>::Serializable, <V as Storable>::Serializable>

The at-rest representation of this storable type.

async fn to_serializable( &self, store: &impl BlockStore, ) -> Result<Self::Serializable>

Turn the current type into the at-rest representation of this type.

async fn from_serializable( _cid: Option<&Cid>, serializable: Self::Serializable, ) -> Result<Self>

Take an at-rest representation of this type and turn it into the in-memory representation. You can use the cid parameter to populate a cache.

fn persisted_as(&self) -> Option<&OnceCell<Cid<64>>>

Return a serialization cache, if it exists. By default, this always returns None.

fn store( &self, store: &impl BlockStore, ) -> impl Future<Output = Result<Cid<64>, Error>> + CondSend

where Self: CondSync,

Store this data type in a given BlockStore.

fn load( cid: &Cid<64>, store: &impl BlockStore, ) -> impl Future<Output = Result<Self, Error>> + CondSend

Try to load a value of this type from a CID.