Enum StorageFlags 

pub enum StorageFlags {
    SingleEpoch(u16),
    MultiEpoch(u16, BTreeMap<u16, u32>),
    SingleEpochOwned(u16, [u8; 32]),
    MultiEpochOwned(u16, BTreeMap<u16, u32>, [u8; 32]),
}

Storage flags

Variants

SingleEpoch(u16)

Single epoch represented as byte 0

MultiEpoch(u16, BTreeMap<u16, u32>)

Multi epoch represented as byte 1

SingleEpochOwned(u16, [u8; 32])

Single epoch owned represented as byte 2

MultiEpochOwned(u16, BTreeMap<u16, u32>, [u8; 32])

Multi epoch owned represented as byte 3

Implementations

impl StorageFlags

pub fn split_removal_bytes( flags: &mut Vec<u8>, removed_key_bytes: u32, removed_value_bytes: u32, ) -> Result<(StorageRemovedBytes, StorageRemovedBytes), StorageFlagsError>

impl StorageFlags

pub fn update_element_flags( cost: &StorageCost, old_flags: Option<Vec<u8>>, new_flags: &mut Vec<u8>, ) -> Result<bool, StorageFlagsError>

impl StorageFlags

pub fn new_single_epoch( epoch: u16, maybe_owner_id: Option<[u8; 32]>, ) -> StorageFlags

Create new single epoch storage flags

pub fn set_owner_id(&mut self, owner_id: [u8; 32])

Sets the owner id if we have owned storage flags

pub fn optional_combine_added_bytes( ours: Option<StorageFlags>, theirs: StorageFlags, added_bytes: u32, merging_owners_strategy: MergingOwnersStrategy, ) -> Result<StorageFlags, StorageFlagsError>

Optional combine added bytes

pub fn optional_combine_removed_bytes( ours: Option<StorageFlags>, theirs: StorageFlags, removed_bytes: &StorageRemovedBytes, merging_owners_strategy: MergingOwnersStrategy, ) -> Result<StorageFlags, StorageFlagsError>

Optional combine removed bytes

pub fn combine_added_bytes( self, rhs: StorageFlags, added_bytes: u32, merging_owners_strategy: MergingOwnersStrategy, ) -> Result<StorageFlags, StorageFlagsError>

Combine added bytes

pub fn combine_removed_bytes( self, rhs: StorageFlags, removed_bytes: &StorageRemovedBytes, merging_owners_strategy: MergingOwnersStrategy, ) -> Result<StorageFlags, StorageFlagsError>

Combine removed bytes

pub fn base_epoch(&self) -> &u16

Returns base epoch

pub fn owner_id(&self) -> Option<&[u8; 32]>

Returns owner id

pub fn epoch_index_map(&self) -> Option<&BTreeMap<u16, u32>>

Returns epoch index map

pub fn optional_default() -> Option<StorageFlags>

Returns optional default storage flags

pub fn optional_default_as_ref() -> Option<&'static StorageFlags>

Returns default optional storage flag as ref

pub fn optional_default_as_cow() -> Option<Cow<'static, StorageFlags>>

Returns default optional storage flag as ref

pub fn type_byte(&self) -> u8

Returns type byte

pub fn approximate_size( has_owner_id: bool, approximate_changes_and_bytes_count: Option<(u16, u8)>, ) -> u32

ApproximateSize

pub fn serialize(&self) -> Vec<u8>

Serialize storage flags

pub fn serialized_size(&self) -> u32

Serialize storage flags

pub fn deserialize_single_epoch( data: &[u8], ) -> Result<StorageFlags, StorageFlagsError>

Deserialize single epoch storage flags from bytes

pub fn deserialize_multi_epoch( data: &[u8], ) -> Result<StorageFlags, StorageFlagsError>

Deserialize multi epoch storage flags from bytes

pub fn deserialize_single_epoch_owned( data: &[u8], ) -> Result<StorageFlags, StorageFlagsError>

Deserialize single epoch owned storage flags from bytes

pub fn deserialize_multi_epoch_owned( data: &[u8], ) -> Result<StorageFlags, StorageFlagsError>

Deserialize multi epoch owned storage flags from bytes

pub fn deserialize( data: &[u8], ) -> Result<Option<StorageFlags>, StorageFlagsError>

Deserialize storage flags from bytes

pub fn from_slice( data: &[u8], ) -> Result<Option<StorageFlags>, StorageFlagsError>

Creates storage flags from a slice.

pub fn from_element_flags_ref( data: &Vec<u8>, ) -> Result<Option<StorageFlags>, StorageFlagsError>

Creates storage flags from element flags.

pub fn map_some_element_flags_ref( data: &Option<Vec<u8>>, ) -> Result<Option<StorageFlags>, StorageFlagsError>

Create Storage flags from optional element flags ref

pub fn map_cow_some_element_flags_ref( data: &Option<Vec<u8>>, ) -> Result<Option<Cow<'_, StorageFlags>>, StorageFlagsError>

Create Storage flags from optional element flags ref

pub fn map_owned_to_element_flags( maybe_storage_flags: Option<StorageFlags>, ) -> Vec<u8>

Map to owned optional element flags

pub fn map_to_some_element_flags( maybe_storage_flags: Option<&StorageFlags>, ) -> Option<Vec<u8>>

Map to optional element flags

pub fn map_cow_to_some_element_flags( maybe_storage_flags: Option<Cow<'_, StorageFlags>>, ) -> Option<Vec<u8>>

Map to optional element flags

pub fn map_borrowed_cow_to_some_element_flags( maybe_storage_flags: &Option<Cow<'_, StorageFlags>>, ) -> Option<Vec<u8>>

Map to optional element flags

pub fn to_some_element_flags(&self) -> Option<Vec<u8>>

Creates optional element flags

pub fn to_element_flags(&self) -> Vec<u8>

Creates element flags.

pub fn split_storage_removed_bytes( &self, removed_key_bytes: u32, removed_value_bytes: u32, ) -> (StorageRemovedBytes, StorageRemovedBytes)

split_storage_removed_bytes removes bytes as LIFO

pub fn into_optional_cow<'a>(self) -> Option<Cow<'a, StorageFlags>>

Wrap Storage Flags into optional owned cow

Trait Implementations

impl Clone for StorageFlags

fn clone(&self) -> StorageFlags

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for StorageFlags

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

Formats the value using the given formatter.

impl Display for StorageFlags

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

Formats the value using the given formatter.

impl PartialEq for StorageFlags

fn eq(&self, other: &StorageFlags) -> 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 Eq for StorageFlags

impl StructuralPartialEq for StorageFlags