Struct corundum::AssertTxInSafe

pub struct AssertTxInSafe<T>(pub T);

A simple wrapper around a type to assert that it is safe to go in a transaction.

When using transaction it may be the case that some of the closed over variables are not TxInSafe safe. For example if &mut T is captured the compiler will generate a warning indicating that it is not TxInSafe. It may not be the case, however, that this is actually a problem due to the specific usage of transaction if transaction inward safety is specifically taken into account. This wrapper struct is useful for a quick and lightweight annotation that a variable is indeed TxInSafe at the programmer’s responsibilities. The Journal object cannot be wrapped by AssertTxInSafe to make sure no inter-pool pointer can be made.

Examples

You may wrap individual captures, as shown below. This ensures that if a new capture is added which is not TxInSafe, you will get a compilation error at that time, which will allow you to consider whether that new capture in fact represent a bug or not.

use corundum::alloc::heap::*;
use corundum::AssertTxInSafe;

let mut variable = 4;
let other_capture = 3;

let result = {
    let mut wrapper = AssertTxInSafe(&mut variable);
    Heap::transaction(move |_| {
        **wrapper += other_capture;
    })
};
 
assert_eq!(variable, 7);
// ...

Tuple Fields

0: T

Trait Implementations

impl<T: Debug + LooseTxInUnsafe> Debug for AssertTxInSafe<T>

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

Formats the value using the given formatter.

impl<T: LooseTxInUnsafe> Deref for AssertTxInSafe<T>

type Target = T

The resulting type after dereferencing.

fn deref(&self) -> &T

Dereferences the value.

impl<T: LooseTxInUnsafe> DerefMut for AssertTxInSafe<T>

fn deref_mut(&mut self) -> &mut T

Mutably dereferences the value.

impl<R, P: MemPool, F> FnOnce(&'static Journal<P>) for AssertTxInSafe<F> where
    R: TxOutSafe,
    F: FnOnce(&'static Journal<P>) -> R, 

type Output = R

The returned type after the call operator is used.

extern "rust-call" fn call_once(
    self,
    args: (&'static Journal<P>,)
) -> R

🔬 This is a nightly-only experimental API. (fn_traits)

Performs the call operation.

impl<F: Future + LooseTxInUnsafe> Future for AssertTxInSafe<F>

type Output = <F as Future>::Output

The type of value produced on completion.

fn poll(self: Pin<&mut Self>, cx: &mut Context<'_>) -> Poll<Self::Output>

Attempt to resolve the future to a final value, registering the current task for wakeup if the value is not yet available.

impl<T: LooseTxInUnsafe> RefUnwindSafe for AssertTxInSafe<T>

impl<T: LooseTxInUnsafe> TxInSafe for AssertTxInSafe<T>

impl<T: LooseTxInUnsafe> UnwindSafe for AssertTxInSafe<T>