Struct massa_models::ledger::LedgerChanges

pub struct LedgerChanges(pub PreHashMap<Address, LedgerChange>);

Map an address to a LedgerChange

Tuple Fields

0: PreHashMap<Address, LedgerChange>

Implementations

impl LedgerChanges

pub fn get_involved_addresses(&self) -> PreHashSet<Address>

addresses that are impacted by these ledger changes

pub fn apply(&mut self, addr: &Address, change: &LedgerChange) -> Result<()>

applies a LedgerChange

pub fn chain(&mut self, other: &LedgerChanges) -> Result<()>

chain with another LedgerChange

pub fn sync_from(&mut self, addrs: &PreHashSet<Address>, other: LedgerChanges)

merge another ledger changes into self, overwriting existing data addresses that are in not other are removed from self

pub fn clone_subset(&self, addrs: &PreHashSet<Address>) -> Self

clone subset

Trait Implementations

impl Clone for LedgerChanges

fn clone(&self) -> LedgerChanges

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for LedgerChanges

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

Formats the value using the given formatter.

impl Default for LedgerChanges

fn default() -> LedgerChanges

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for LedgerChanges

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Deserializer<LedgerChanges> for LedgerChangesDeserializer

fn deserialize<'a, E: ParseError<&'a [u8]> + ContextError<&'a [u8]>>( &self, buffer: &'a [u8], ) -> IResult<&'a [u8], LedgerChanges, E>

Example

use massa_models::ledger::{LedgerChange, LedgerChanges, LedgerChangesDeserializer, LedgerChangeSerializer, LedgerChangesSerializer};
let mut serialized = Vec::new();
let ledger_change_serializer = LedgerChangeSerializer::new();
LedgerChangesSerializer::new().serialize(&ledger_changes, &mut serialized).unwrap();
let (_, res) = LedgerChangesDeserializer::new(10000).deserialize::<DeserializeError>(&serialized).unwrap();
for (address, data) in &ledger_changes.0 {
   let mut data_serialized = Vec::new();
   ledger_change_serializer.serialize(data, &mut data_serialized).unwrap();
   assert!(res.0.iter().filter(|(addr, dta)| {
     let mut dta_serialized = Vec::new();
     ledger_change_serializer.serialize(dta, &mut dta_serialized).unwrap();
     &address == addr && dta_serialized == data_serialized
    }).count() == 1);
   data_serialized = Vec::new();
}
assert_eq!(ledger_changes.0.len(), res.0.len());

impl Serialize for LedgerChanges

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Serializer<LedgerChanges> for LedgerChangesSerializer

fn serialize( &self, value: &LedgerChanges, buffer: &mut Vec<u8>, ) -> Result<(), SerializeError>

Serialize a value T into a buffer of u8.