Struct CubeTransaction 

pub struct CubeTransaction { /* private fields */ }

A modification to the contents of single cube of a Space.

To make use of this, insert it into a SpaceTransaction to specify which cube is modified. This type does not function directly as a Transaction (though it does implement Merge).

Implementations

impl CubeTransaction

pub fn at(self, cube: Cube) -> SpaceTransaction

Creates a SpaceTransaction that applies self to the given cube of the space.

pub fn replacing(old: Option<Block>, new: Option<Block>) -> Self

Construct a CubeTransaction that may check and may replace the block in the cube.

If old is not None, requires that the existing block is that block or the transaction will fail. If new is not None, replaces the existing block with new.

pub fn overwrite(&mut self, block: Block)

Sets the block to be placed at this cube, replacing any existing modification instruction This does not affect a precondition on the existing block, or the conservative option.

This is thus comparable to the effect of a direct Mutation::set() after the rest of the transaction.

pub fn fluff(fluff: Fluff) -> Self

Emit Fluff (sound/particle effects) at this cube when the transaction is committed.

pub fn add_fluff(&mut self, fluff: Fluff)

Emit Fluff (sound/particle effects) at this cube when the transaction is committed, in addition to its other effects.

Trait Implementations

impl Clone for CubeTransaction

fn clone(&self) -> CubeTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for CubeTransaction

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

Formats the value using the given formatter.

impl Default for CubeTransaction

fn default() -> CubeTransaction

Returns the “default value” for a type.

impl Merge for CubeTransaction

type MergeCheck = CubeMergeCheck

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

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 CubeTransaction

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

fn visit_handles(&self, visitor: &mut dyn HandleVisitor)

For each Handle contained within self that is reachable without traversing another Handle, call visitor with a reference to it.

impl Eq for CubeTransaction

impl StructuralPartialEq for CubeTransaction