Struct BodyTransaction 

#[non_exhaustive]
pub struct BodyTransaction { /* private fields */ }

The Transaction type for Body.

TODO: Very incomplete; just a sketch of what eventually needs to exist.

Implementations

impl BodyTransaction

pub fn with_position(self, position: FreePoint) -> Self

pub fn with_look_direction(self, direction: FreeVector) -> Self

Trait Implementations

impl Clone for BodyTransaction

fn clone(&self) -> BodyTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BodyTransaction

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

Formats the value using the given formatter.

impl Default for BodyTransaction

fn default() -> BodyTransaction

Returns the “default value” for a type.

impl Merge for BodyTransaction

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

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 BodyTransaction

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

type Target = Body

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 = ()

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

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

fn check( &self, _body: &Body, (): 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, body: &mut Body, (): 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 BodyTransaction