Struct VersionedMapIpld 

pub struct VersionedMapIpld<Key, Value>
where
    Key: VersionedMapKey,
    Value: VersionedMapValue,
{
    pub hamt: Cid,
    pub changelog: Cid,
    pub signature: PhantomData<(Key, Value)>,
}

A VersionedMapIpld pairs a Hamt and a ChangelogIpld to enable a data structure that contains its difference from a historical ancestor without requiring that a diff be performed.

Fields

hamt: Cid

A pointer to a Hamt root

changelog: Cid

A pointer to a ChangelogIpld

signature: PhantomData<(Key, Value)>

Implementations

impl<Key, Value> VersionedMapIpld<Key, Value>

where Key: VersionedMapKey, Value: VersionedMapValue,

pub async fn load_hamt<S: BlockStore>( &self, store: &S, ) -> Result<Hamt<S, Value, Key, Sha256>>

Load the Hamt root associated with this VersionedMapIpld

pub async fn load_changelog<S: BlockStore>( &self, store: &S, ) -> Result<ChangelogIpld<MapOperation<Key, Value>>>

Load the ChangelogIpld associated with this VersionedMapIpld

pub async fn empty<S: BlockStore>(store: &mut S) -> Result<Self>

Initialize an empty VersionedMapIpld, creating an empty Hamt root and ChangelogIpld as well

Trait Implementations

impl<Key, Value> Clone for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey + Clone, Value: VersionedMapValue + Clone,

fn clone(&self) -> VersionedMapIpld<Key, Value>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<Key, Value> Debug for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey + Debug, Value: VersionedMapValue + Debug,

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

Formats the value using the given formatter.

impl<Key, Value> Default for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey + Default, Value: VersionedMapValue + Default,

fn default() -> VersionedMapIpld<Key, Value>

Returns the “default value” for a type.

impl<'de, Key, Value> Deserialize<'de> for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey, Value: VersionedMapValue,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<Key, Value> PartialEq for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey + PartialEq, Value: VersionedMapValue + PartialEq,

fn eq(&self, other: &VersionedMapIpld<Key, Value>) -> 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<Key, Value> Serialize for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey, Value: VersionedMapValue,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<K, V> TryBundle for VersionedMapIpld<K, V>

where K: VersionedMapKey, V: VersionedMapValue + TryBundle,

fn extend_bundle<'life0, 'life1, 'life2, 'async_trait, S>( &'life0 self, bundle: &'life1 mut Bundle, store: &'life2 S, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn extend_bundle_with_cid<'life0, 'life1, 'life2, 'async_trait, S>( cid: &'life0 Cid, bundle: &'life1 mut Bundle, store: &'life2 S, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, 'life0: 'async_trait, 'life1: 'async_trait, 'life2: 'async_trait,

fn bundle<'life0, 'life1, 'async_trait, S>( &'life0 self, store: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Bundle>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: Sync + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

fn bundle_with_cid<'life0, 'life1, 'async_trait, S>( cid: &'life0 Cid, store: &'life1 S, ) -> Pin<Box<dyn Future<Output = Result<Bundle>> + Send + 'async_trait>>

where S: 'async_trait + BlockStore, Self: Send + 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

impl<Key, Value> Eq for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey + Eq, Value: VersionedMapValue + Eq,

impl<Key, Value> StructuralPartialEq for VersionedMapIpld<Key, Value>

where Key: VersionedMapKey, Value: VersionedMapValue,