Struct CharacterTransaction 

pub struct CharacterTransaction { /* private fields */ }

A Transaction that modifies a Character.

Implementations

impl CharacterTransaction

pub fn move_to_space(space: Handle<Space>) -> Self

Move the character to a different Space.

Note that this leaves the position within the spaces unchanged; use a body() transaction to also change that. TODO: Better API?

pub fn body(t: BodyTransaction) -> Self

Modify the character’s Body.

pub fn inventory(t: InventoryTransaction) -> Self

Modify the character’s Inventory.

Trait Implementations

impl Clone for CharacterTransaction

fn clone(&self) -> CharacterTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CharacterTransaction

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

Formats the value using the given formatter.

impl Default for CharacterTransaction

fn default() -> CharacterTransaction

Returns the “default value” for a type.

impl Merge for CharacterTransaction

type MergeCheck = (<BodyTransaction as Merge>::MergeCheck, <InventoryTransaction as Merge>::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 = CharacterTransactionConflict

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, (body_check, inventory_check): 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 CharacterTransaction

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

type Target = Character

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

type Context<'a> = ReadTicket<'a>

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

type CommitCheck = (<BodyTransaction as Transaction>::CommitCheck, <InventoryTransaction as Transaction>::CommitCheck)

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 = Infallible

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

type Mismatch = CharacterTransactionMismatch

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

fn check( &self, target: &Character, _: 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, target: &mut Character, (body_check, 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:

fn bind(self, target: Handle<Self::Target>) -> UniverseTransaction

where Self: Sized, Self::Target: UTransactional<Transaction = Self>,

Specify the target of this transaction as a Handle, and erase its type, so that it can be combined with other transactions in the same universe.

impl StructuralPartialEq for CharacterTransaction