Struct MemState 

pub struct MemState { /* private fields */ }

Implementations

impl MemState

pub fn debug_witnesses( &self, ) -> &Confined<BTreeMap<Txid, WitnessOrd>, amplify::::collection::confinement::LargeOrdMap::{constant#0}, amplify::::collection::confinement::LargeOrdMap::{constant#1}>

Method borrowing MemState::witnesses field.

pub fn debug_invalid_bundles( &self, ) -> &Confined<BTreeSet<BundleId>, amplify::::collection::confinement::LargeOrdSet::{constant#0}, amplify::::collection::confinement::LargeOrdSet::{constant#1}>

Method borrowing MemState::invalid_bundles field.

pub fn debug_contracts( &self, ) -> &Confined<BTreeMap<ContractId, MemContractState>, amplify::::collection::confinement::SmallOrdMap::{constant#0}, amplify::::collection::confinement::SmallOrdMap::{constant#1}>

Method borrowing MemState::contracts field.

impl MemState

pub fn in_memory() -> MemState

Trait Implementations

impl CloneNoPersistence for MemState

fn clone_no_persistence(&self) -> MemState

impl Debug for MemState

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

Formats the value using the given formatter.

impl PersistenceProvider<MemState> for FsBinStore

fn load(&self) -> Result<MemState, PersistenceError>

fn store(&self, object: &MemState) -> Result<(), PersistenceError>

impl Persisting for MemState

fn persistence(&self) -> Option<&Persistence<MemState>>

fn persistence_mut(&mut self) -> Option<&mut Persistence<MemState>>

fn as_mut_persistence(&mut self) -> &mut Option<Persistence<MemState>>

fn load( provider: impl PersistenceProvider<Self> + 'static, autosave: bool, ) -> Result<Self, PersistenceError>

fn is_persisted(&self) -> bool

fn is_dirty(&self) -> bool

fn mark_dirty(&mut self)

fn is_autosave(&self) -> bool

fn set_autosave(&mut self)

fn make_persistent( &mut self, provider: impl PersistenceProvider<Self> + 'static, autosave: bool, ) -> Result<bool, PersistenceError>

Returns whether the object was persisting before this method.

fn store(&mut self) -> Result<(), PersistenceError>

impl StateReadProvider for MemState

type ContractRead<'a> = MemContract<&'a MemContractState>

type Error = StateInconsistency

fn contract_state( &self, contract_id: ContractId, ) -> Result<<MemState as StateReadProvider>::ContractRead<'_>, <MemState as StateReadProvider>::Error>

fn witnesses( &self, ) -> Confined<BTreeMap<Txid, WitnessOrd>, amplify::::collection::confinement::LargeOrdMap::{constant#0}, amplify::::collection::confinement::LargeOrdMap::{constant#1}>

fn invalid_bundles( &self, ) -> Confined<BTreeSet<BundleId>, amplify::::collection::confinement::LargeOrdSet::{constant#0}, amplify::::collection::confinement::LargeOrdSet::{constant#1}>

impl StateWriteProvider for MemState

type ContractWrite<'a> = MemContractWriter<'a>

type Error = MemError

fn register_contract( &mut self, schema: &Schema, genesis: &Genesis, ) -> Result<<MemState as StateWriteProvider>::ContractWrite<'_>, <MemState as StateWriteProvider>::Error>

fn update_contract( &mut self, contract_id: ContractId, ) -> Result<Option<<MemState as StateWriteProvider>::ContractWrite<'_>>, <MemState as StateWriteProvider>::Error>

fn upsert_witness( &mut self, witness_id: Txid, witness_ord: WitnessOrd, ) -> Result<(), <MemState as StateWriteProvider>::Error>

fn update_bundle( &mut self, bundle_id: BundleId, valid: bool, ) -> Result<(), <MemState as StateWriteProvider>::Error>

impl StoreTransaction for MemState

type TransactionErr = MemError

fn begin_transaction( &mut self, ) -> Result<(), <MemState as StoreTransaction>::TransactionErr>

fn commit_transaction( &mut self, ) -> Result<(), <MemState as StoreTransaction>::TransactionErr>

fn rollback_transaction(&mut self)

impl StrictDecode for MemState

fn strict_decode(reader: &mut impl TypedRead) -> Result<MemState, DecodeError>

fn strict_read(reader: impl ReadRaw) -> Result<Self, DecodeError>

impl StrictDeserialize for MemState

fn from_strict_serialized<const MAX: usize>( ast_data: Confined<Vec<u8>, 0, MAX>, ) -> Result<Self, DeserializeError>

fn strict_deserialize_from_file<const MAX: usize>( path: impl AsRef<Path>, ) -> Result<Self, DeserializeError>

impl StrictDumb for MemState

fn strict_dumb() -> MemState

impl StrictEncode for MemState

fn strict_encode<W>(&self, writer: W) -> Result<W, Error>

where W: TypedWrite,

fn strict_write(&self, writer: impl WriteRaw) -> Result<(), Error>

impl StrictSerialize for MemState

fn strict_serialized_len<const MAX: usize>(&self) -> Result<usize, Error>

fn to_strict_serialized<const MAX: usize>( &self, ) -> Result<Confined<Vec<u8>, 0, MAX>, SerializeError>

fn strict_serialize_to_file<const MAX: usize>( &self, path: impl AsRef<Path>, ) -> Result<(), SerializeError>

impl StrictStruct for MemState

const ALL_FIELDS: &'static [&'static str]

fn strict_check_fields()

fn strict_type_info() -> TypeInfo<Self>

impl StrictType for MemState

const STRICT_LIB_NAME: &'static str = LIB_NAME_RGB_STORAGE

fn strict_name() -> Option<TypeName>

impl StateProvider for MemState

impl StrictProduct for MemState