Struct InventoryTransaction 

pub struct InventoryTransaction { /* private fields */ }

Transaction type for Inventory.

The output type is the change notification which should be passed on after commit, if any change is made.

Implementations

impl InventoryTransaction

pub fn insert<S: Into<Slot>, I: IntoIterator<Item = S>>(stacks: I) -> Self

Transaction to insert items/stacks into an inventory, which will fail if there is not sufficient space.

pub fn replace(slot: Ix, old: Slot, new: Slot) -> Self

Transaction to replace the contents of an existing slot in an inventory, which will fail if the existing slot is not as expected.

TODO: Right now, this requires an exact match. In the future, we should be able to compose multiple modifications like “add 1 item to stack” ×2 into “add 2 items”.

pub fn is_empty(&self) -> bool

Returns whether this transaction does nothing and checks nothing.

Example

use all_is_cubes::inv;

assert!(inv::InventoryTransaction::default().is_empty());

assert!(!inv::InventoryTransaction::insert([inv::Tool::Activate]).is_empty());

Trait Implementations

impl Clone for InventoryTransaction

fn clone(&self) -> InventoryTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for InventoryTransaction

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

Formats the value using the given formatter.

impl Default for InventoryTransaction

fn default() -> InventoryTransaction

Returns the “default value” for a type.

impl Merge for InventoryTransaction

type MergeCheck = ()

Type of a value passed from Merge::check_merge to Merge::commit_merge. This may be used to pass precalculated values to speed up the merge phase, but also makes it difficult to accidentally merge without checking.

type Conflict = InventoryConflict

Error type giving the reason why a merge was not possible.

fn check_merge(&self, other: &Self) -> Result<Self::MergeCheck, Self::Conflict>

Checks whether two transactions can be merged into a single transaction. If so, returns Ok containing data which may be passed to Self::commit_merge().

fn commit_merge(&mut self, other: Self, (): Self::MergeCheck)

Combines other into self so that it has both effects simultaneously. This operation must be commutative and have Default::default() as the identity.

fn merge(self, other: Self) -> Result<Self, Self::Conflict>

Combines two transactions into one which has both effects simultaneously, if possible.

fn merge_from(&mut self, other: Self) -> Result<(), Self::Conflict>

Combines two transactions into one which has both effects simultaneously, if possible.

impl PartialEq for InventoryTransaction

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

type Target = Inventory

Type of the transaction’s target (what it can be used to mutate).

type Context<'a> = ()

Data which must be passed when checking the transaction. Use () if none is needed.

type CommitCheck = Option<InventoryCheck>

Type of a value passed from Transaction::check to Transaction::commit. This may be used to pass precalculated values to speed up the commit phase, or even lock guards or similar, but also makes it slightly harder to accidentally call commit without check.

type Output = InventoryChange

The results of a Transaction::commit() or Transaction::execute(). Each commit may produce any number of these messages.

type Mismatch = InventoryMismatch

Error type describing a precondition not met, returned by Self::check().

fn check( &self, inventory: &Inventory, (): Self::Context<'_>, ) -> Result<Self::CommitCheck, Self::Mismatch>

Checks whether the target’s current state meets the preconditions and returns Err if it does not.

fn commit( self, inventory: &mut Inventory, check: Self::CommitCheck, outputs: &mut dyn FnMut(Self::Output), ) -> Result<(), CommitError>

Perform the mutations specified by this transaction. The check value should have been created by a prior call to Transaction::check().

fn execute( self, target: &mut Self::Target, context: Self::Context<'_>, outputs: &mut dyn FnMut(Self::Output), ) -> Result<(), ExecuteError<Self>>

Convenience method to execute a transaction in one step. Implementations should not need to override this. Equivalent to:

impl StructuralPartialEq for InventoryTransaction