Struct BlockDefTransaction 

pub struct BlockDefTransaction { /* private fields */ }

A Transaction which replaces (or checks) the Block stored in a BlockDef.

Implementations

impl BlockDefTransaction

pub fn expect(old: Block) -> Self

Returns a transaction which fails if the current value of the BlockDef is not equal to old.

pub fn overwrite(new: Block) -> Self

Returns a transaction which replaces the current value of the BlockDef with new.

pub fn replace(old: Block, new: Block) -> Self

Returns a transaction which replaces the value of the BlockDef with new, if it is equal to old, and otherwise fails.

Trait Implementations

impl Clone for BlockDefTransaction

fn clone(&self) -> BlockDefTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BlockDefTransaction

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

Formats the value using the given formatter.

impl Default for BlockDefTransaction

fn default() -> BlockDefTransaction

Returns the “default value” for a type.

impl Hash for BlockDefTransaction

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Merge for BlockDefTransaction

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

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 BlockDefTransaction

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

type Target = BlockDef

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

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

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

fn check( &self, target: &BlockDef, 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, target: &mut BlockDef, 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 Eq for BlockDefTransaction

impl StructuralPartialEq for BlockDefTransaction