Struct SpaceTransaction 

pub struct SpaceTransaction { /* private fields */ }

A Transaction that modifies a Space.

Implementations

impl SpaceTransaction

pub fn at(&mut self, cube: Cube) -> &mut CubeTransaction

Allows modifying the part of this transaction which is a CubeTransaction at the given cube, creating it if necessary (as CubeTransaction::default()).

You can replace the transaction or use CubeTransaction::merge_from() to merge in another transaction.

This is for incremental construction of a complex transaction; to create a transaction affecting a single cube, CubeTransaction::at() will be more convenient.

pub fn filling<F>(region: GridAab, function: F) -> Self

where F: FnMut(Cube) -> CubeTransaction,

Construct a SpaceTransaction which modifies a volume by applying a CubeTransaction computed by function to each cube.

pub fn set_cube( cube: impl Into<Cube>, old: Option<Block>, new: Option<Block>, ) -> Self

Construct a SpaceTransaction for a single 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.

TODO: Consider replacing all uses of this with CubeTransaction::replacing().

pub fn draw_target<C>( &mut self, transform: Gridgid, ) -> DrawingPlane<'_, Self, C>

Provides an DrawTarget adapter for 2.5D drawing.

For more information on how to use this, see all_is_cubes::drawing.

pub fn nonconserved(self) -> Self

Marks all cube modifications in this transaction as non-conservative.

This means that two transactions which both place the same block in a given cube may be merged, whereas the default state is that they will conflict (on the principle that such a merge could cause there to be fewer total occurrences of that block than intended).

Also, the transaction will not fail if some of its cubes are outside the bounds of the Space.

pub fn behaviors(t: BehaviorSetTransaction<Space>) -> Self

Modify the space’s BehaviorSet.

pub fn add_behavior<B>(bounds: GridAab, behavior: B) -> Self

where B: Behavior<Space> + 'static,

Add a behavior to the Space. This is a shortcut for creating a BehaviorSetTransaction.

pub fn bounds_only_cubes(&self) -> Option<GridAab>

Computes the region of cubes directly affected by this transaction. Ignores behaviors.

Returns None if no cubes are affected.

TODO: Handle the case where the total volume is too large. (Maybe GridAab should lose that restriction.)

pub fn bounds(&self) -> Option<GridAab>

Computes the region affected by this transaction.

Returns None if no specific regions of the space are affected.

pub fn execute_m( self, target: &mut Mutation<'_, '_>, ) -> Result<(), ExecuteError<Self>>

As Transaction::execute(), but taking a Mutation instead of a Space.

Trait Implementations

impl Clone for SpaceTransaction

fn clone(&self) -> SpaceTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for SpaceTransaction

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

Formats the value using the given formatter.

impl Default for SpaceTransaction

fn default() -> SpaceTransaction

Returns the “default value” for a type.

impl<'a> From<&'a VoxelBrush<'a>> for SpaceTransaction

fn from(brush: &'a VoxelBrush<'a>) -> Self

Converts the brush into an equivalent transaction, as by VoxelBrush::paint_transaction at the origin.

impl<'a> From<VoxelBrush<'a>> for SpaceTransaction

fn from(brush: VoxelBrush<'a>) -> Self

Converts the brush into an equivalent transaction, as by VoxelBrush::paint_transaction at the origin.

impl Merge for SpaceTransaction

type MergeCheck = <BehaviorSetTransaction<Space> 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 = SpaceTransactionConflict

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, 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 SpaceTransaction

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

type Target = Space

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

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

fn check( &self, space: &Space, read_ticket: 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, space: &mut Space, 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 VisitHandles for SpaceTransaction

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 SpaceTransaction

impl StructuralPartialEq for SpaceTransaction