Struct noosphere_core::data::VersionedMapIpld

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

Fields

hamt: Cid

A pointer to a HAMT

changelog: Cid

signature: PhantomData<(Key, Value)>

Implementations

impl<Key, Value> VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

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

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

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

Trait Implementations

impl<Key: Clone, Value: Clone> Clone for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<Key: Debug, Value: Debug> Debug for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

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

Formats the value using the given formatter.

impl<Key: Default, Value: Default> Default for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

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: PartialEq, Value: PartialEq> PartialEq<VersionedMapIpld<Key, Value>> for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

fn eq(&self, other: &VersionedMapIpld<Key, Value>) -> bool

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

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

This method 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,

fn try_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,
    'life0: 'async_trait,
    'life1: 'async_trait,
    'life2: 'async_trait,
    Self: 'async_trait,

fn try_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,
    Self: 'async_trait,

fn try_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,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Sync + 'async_trait,

fn try_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,
    'life0: 'async_trait,
    'life1: 'async_trait,
    Self: Send + 'async_trait,

impl<Key: Eq, Value: Eq> Eq for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

impl<Key, Value> StructuralEq for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,

impl<Key, Value> StructuralPartialEq for VersionedMapIpld<Key, Value>where
    Key: VersionedMapKey,
    Value: VersionedMapValue,