Struct DefTransaction 

pub struct DefTransaction { /* private fields */ }

A Transaction which replaces (or checks) a SoundDef.

Implementations

impl DefTransaction

pub fn expect(old: SoundDef) -> Self

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

pub fn overwrite(new: SoundDef) -> Self

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

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

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

Trait Implementations

impl Clone for DefTransaction

fn clone(&self) -> DefTransaction

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for DefTransaction

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

Formats the value using the given formatter.

impl Hash for DefTransaction

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 DefTransaction

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

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 DefTransaction

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

type Target = SoundDef

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

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 Context<'a> = ReadTicket<'a>

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

type Output = Infallible

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

type Mismatch = Mismatch

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

fn check( &self, target: &SoundDef, _read_ticket: ReadTicket<'_>, ) -> 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 SoundDef, (): 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 DefTransaction

impl StructuralPartialEq for DefTransaction