Struct swym::tcell::TCell

#[repr(C)]
pub struct TCell<T> { /* fields omitted */ }

A transactional memory location.

TCell stores an extra usize representing the current version of the memory.

The current value is stored directly in the TCell meaning it's not Boxed, Arc'ed, etc.

Methods

impl<T> TCell<T>

pub const fn new(value: T) -> TCell<T>

Construct a new TCell from an initial value.

This does not perform any memory allocation or synchronization.

Examples

use swym::{tcell::TCell, thread_key};

static ZERO: TCell<i32> = TCell::new(0);
assert_eq!(
    thread_key::get().read(|tx| Ok(ZERO.get(tx, Default::default())?)),
    0
);

pub fn into_inner(self) -> T

Consumes this TCell, returning the underlying data.

Examples

use swym::tcell::TCell;

let x = TCell::new(42);
assert_eq!(x.into_inner(), 42);

pub fn borrow_mut(&mut self) -> &mut T

Returns a mutable reference to the underlying data.

Since this call borrows the TCell mutably, no synchronization needs to take place. The mutable borrow statically guarantees no other threads are accessing this data.

Examples

use swym::tcell::TCell;

let mut x = TCell::new("hello");
*x.borrow_mut() = "world";
assert_eq!(*x.borrow_mut(), "world");

pub fn view<'tcell, Tx>(&'tcell self, transaction: Tx) -> View<'tcell, T, Tx> where
    Tx: Deref,
    Tx::Target: Read<'tcell> + Sized, 

impl<T: Borrow> TCell<T>

pub fn borrow<'tx, 'tcell>(
    &'tcell self,
    tx: &'tx impl Read<'tcell>,
    ordering: Ordering
) -> Result<Ref<'tx, T>, Error>

Gets a reference to the contained value using the specified memory Ordering.

Statically requires that the TCell outlives the current transaction.

Errors

If another thread has written to this TCell during the current transaction, an error is returned.

Examples

use swym::{tcell::TCell, thread_key, tx::Ordering};

let x = TCell::new("hello");
let hello = thread_key::get().read(|tx| Ok(*x.borrow(tx, Ordering::Read)?));
assert_eq!(hello, "hello");

impl<T: Copy> TCell<T>

#[must_use = "Calling `TCell::get` without using the result unnecessarily increases the chance of transaction failure"]

pub fn get<'tcell>(
    &'tcell self,
    tx: &impl Read<'tcell>,
    ordering: Ordering
) -> Result<T, Error>

Gets a copy of the contained value using the specified memory Ordering.

Statically requires that the TCell outlives the current transaction.

Errors

If another thread has written to this TCell during the current transaction, an error is returned.

Examples

use swym::{tcell::TCell, thread_key, tx::Ordering};

let x = TCell::new("hello");
let hello = thread_key::get().read(|tx| Ok(x.get(tx, Ordering::Read)?));
assert_eq!(hello, "hello");

impl<T: 'static + Send> TCell<T>

pub fn set<'tcell>(
    &'tcell self,
    tx: &mut impl Write<'tcell>,
    value: T
) -> Result<(), SetError<T>>

Sets the contained value.

Statically requires that the TCell outlives the current transaction.

Errors

If another thread has written to this TCell during the current transaction, the value is not set, and an error is returned. It is typical to route this error back to ThreadKey::rw where the transaction will be retried, however, this is not required.

Examples

use swym::{tcell::TCell, thread_key};

let x = TCell::new("hello");
thread_key::get().rw(|tx| Ok(x.set(tx, "world")?));
assert_eq!(x.into_inner(), "world");

impl<T: 'static + Borrow + Clone + Send> TCell<T>

pub fn replace<'tcell, 'tx>(
    &'tcell self,
    tx: &'tx mut impl RW<'tcell>,
    value: T
) -> Result<T, SetError<T>>

Trait Implementations

impl<T: Send + Sync> Sync for TCell<T>

impl<T: Default> Default for TCell<T>

fn default() -> TCell<T>

Returns the "default value" for a type.

impl<T: Send> Send for TCell<T>

impl<T> From<T> for TCell<T>

fn from(value: T) -> TCell<T>

Performs the conversion.

impl<T: Borrow + Debug> Debug for TCell<T>

fn fmt(&self, formatter: &mut Formatter) -> Result

Formats the value using the given formatter.