Struct corundum::cell::LogCell

pub struct LogCell<T: PSafe + ?Sized, A: MemPool> { /* fields omitted */ }

A persistent mutable memory location with recoverability

This is one of the safe ways to provide interior mutability for pointer wrappers. It takes a log, if it was not already taken, before updating the value.

Using get() function, you can obtain a copy of data. To update data, you can use set() which writes a log to the given journal before mutation.

It does not implement Sync, so it is not possible to share LogCell between threads. To provide thread-safe interior mutability, use Mutex.

PCell is a compact version of LogCell tha can be find in the pool module.

Implementations

impl<T: PSafe, A: MemPool> LogCell<T, A>

pub const fn new(value: T, _j: &Journal<A>) -> LogCell<T, A>

Creates a new LogCell containing the given value.

Examples

use corundum::alloc::*;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = LogCell::new(5, j);
}).unwrap();

pub fn set(&self, val: T, journal: &Journal<A>)

Sets the contained value.

Examples

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = Pbox::new(LogCell::new(5, j), j);
    c.set(10, j);
}).unwrap();

Errors

If LogCell is not in the persistent memory, it will raise an 'invalid address' error. To make sure that the LogCell is in the persistent memory, use dynamic allocation using Pbox as shown above.

pub fn swap(&self, other: &Self, journal: &Journal<A>)

Swaps the values of two Cells.

Difference with std::mem::swap is that this function doesn't require &mut reference. It takes a log of both sides, if required, and then swaps the values.

Examples

use corundum::default::*;
use corundum::cell::LogCell;

let _pool = BuddyAlloc::open_no_root("foo.pool", O_CF).unwrap();
     
BuddyAlloc::transaction(|j| {
    let c1 = Pbox::new(LogCell::new(5i32, j), j);
    let c2 = Pbox::new(LogCell::new(10i32, j), j);
    c1.swap(&c2, j);
    assert_eq!(10, c1.get());
    assert_eq!(5, c2.get());
}).unwrap();

pub fn replace(&self, val: T, journal: &Journal<A>) -> T

Replaces the contained value, and returns it.

Examples

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let cell = Pbox::new(LogCell::new(5, j), j);
    assert_eq!(cell.get(), 5);
    assert_eq!(cell.replace(10, j), 5);
    assert_eq!(cell.get(), 10);
}).unwrap();

pub fn into_inner(self) -> T

Unwraps the value.

Examples

use corundum::alloc::*;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = LogCell::new(5, j);
    let five = c.into_inner();

    assert_eq!(five, 5);
}).unwrap();

pub fn add(&self, val: T, journal: &Journal<A>) where
    T: AddAssign, 

Increments the contained value by val.

pub fn sub(&self, val: T, journal: &Journal<A>) where
    T: SubAssign, 

Subtracts the contained value by val.

pub fn mul(&self, val: T, journal: &Journal<A>) where
    T: MulAssign, 

Multiplies the contained value with val.

pub fn div(&self, val: T, journal: &Journal<A>) where
    T: DivAssign, 

Divides the contained value with val.

pub fn rem(&self, val: T, journal: &Journal<A>) where
    T: RemAssign, 

Divides the contained value with val and keeps the reminding.

impl<T: PSafe, A: MemPool> LogCell<T, A>

pub fn get(&self) -> T where
    T: Copy, 

Returns a copy of the contained value.

Examples

use corundum::alloc::*;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = LogCell::new(5, j);
    let five = c.get();
     
    assert_eq!(five, 5);
}).unwrap();

pub fn get_ref(&self) -> &T

pub fn update<F>(&self, journal: &Journal<A>, f: F) -> T where
    F: FnOnce(T) -> T,
    T: Copy, 

Updates the contained value using a function and returns the new value.

Examples

#![feature(cell_update)]

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = Pbox::new(LogCell::new(5, j), j);
    let new = c.update(j, |x| x + 1);

    assert_eq!(new, 6);
    assert_eq!(c.get(), 6);
}).unwrap();

pub fn update_inplace<F>(&self, f: F) where
    F: FnOnce(&T), 

Updates the contained value using an updater function with an immutable reference to the inner value

Examples

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = Pbox::new(LogCell::new(LogCell::new(5, j), j), j);
    c.update_inplace(|x| x.set(6, j));

    assert_eq!(c.get_ref().get(), 6);
}).unwrap();

pub fn update_inplace_mut<F>(&self, journal: &Journal<A>, f: F) where
    F: FnOnce(&mut T), 

Updates the contained value using an updater function with a mutable reference to the inner value.

Examples

#![feature(cell_update)]

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = Pbox::new(LogCell::new(5, j), j);
    c.update_inplace_mut(j, |x| { *x = 6 });

    assert_eq!(c.get(), 6);
}).unwrap();

impl<T: PSafe + ?Sized, A: MemPool> LogCell<T, A>

pub fn get_mut(&mut self, journal: &Journal<A>) -> &mut T

Returns a mutable reference to the underlying data.

This call borrows LogCell mutably (at compile-time) which guarantees that we possess the only reference.

Examples

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let mut c = Pbox::new(LogCell::new(5, j), j);
    let mut n = c.get_mut(j);
    *n += 1;

    assert_eq!(c.get(), 6);
}).unwrap();

pub unsafe fn as_mut(&self) -> &mut T

Returns a mutable reference to the underlying data without taking a log

Safety

This function violates borrow rules as it allows multiple mutable references.

Examples

use corundum::default::*;
use corundum::cell::LogCell;
 
type P = BuddyAlloc;
 
let root = P::open::<LogCell<i32,P>>("foo.pool", O_CF).unwrap();
 
unsafe {
    let mut data = root.as_mut();
    *data = 20;
}
 

impl<T: PSafe + Default, A: MemPool> LogCell<T, A>

pub fn take(&self, journal: &Journal<A>) -> T

Takes the value of the cell, leaving Default::default() in its place.

Examples

use corundum::alloc::*;
use corundum::boxed::Pbox;
use corundum::cell::LogCell;

Heap::transaction(|j| {
    let c = Pbox::new(LogCell::new(5, j), j);
    let five = c.take(j);

    assert_eq!(five, 5);
    assert_eq!(c.get(), 0);
}).unwrap();

Trait Implementations

impl<T: Debug + PSafe, A: MemPool> Debug for LogCell<T, A>

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

Formats the value using the given formatter.

impl<T: PSafe + Default, A: MemPool> Default for LogCell<T, A>

pub fn default() -> Self

Returns the "default value" for a type.

impl<T: PSafe + Eq + Copy, A: MemPool> Eq for LogCell<T, A>

impl<T: PSafe + Ord + Copy, A: MemPool> Ord for LogCell<T, A>

pub fn cmp(&self, other: &LogCell<T, A>) -> Ordering

This method returns an Ordering between self and other.

#[must_use]pub fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

#[must_use]pub fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

#[must_use]pub fn clamp(self, min: Self, max: Self) -> Self

Restrict a value to a certain interval.

impl<T: PSafe + Logger<A> + Copy, A: MemPool> PClone<A> for LogCell<T, A>

pub fn pclone(&self, j: &Journal<A>) -> LogCell<T, A>

pub fn pclone_from(&mut self, source: &Self, journal: &Journal<A>)

Performs copy-assignment from source.

impl<T: PSafe + ?Sized, A: MemPool> PSafe for LogCell<T, A>

impl<T: PSafe + PartialEq + Copy, A: MemPool> PartialEq<LogCell<T, A>> for LogCell<T, A>

pub fn eq(&self, other: &LogCell<T, A>) -> bool

This method tests for self and other values to be equal, and is used by ==.

#[must_use]pub fn ne(&self, other: &Rhs) -> bool

This method tests for !=.

impl<T: PSafe + PartialOrd + Copy, A: MemPool> PartialOrd<LogCell<T, A>> for LogCell<T, A>

pub fn partial_cmp(&self, other: &LogCell<T, A>) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

pub fn lt(&self, other: &LogCell<T, A>) -> bool

This method tests less than (for self and other) and is used by the < operator.

pub fn le(&self, other: &LogCell<T, A>) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

pub fn gt(&self, other: &LogCell<T, A>) -> bool

This method tests greater than (for self and other) and is used by the > operator.

pub fn ge(&self, other: &LogCell<T, A>) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl<T: PSafe + ?Sized, A: MemPool> RefUnwindSafe for LogCell<T, A>

impl<T: PSafe + Send + ?Sized, A: MemPool> Send for LogCell<T, A>

impl<T: ?Sized, A: MemPool> !Sync for LogCell<T, A>

impl<T: PSafe + ?Sized, A: MemPool> TxInSafe for LogCell<T, A>

impl<T: ?Sized, A: MemPool> !TxOutSafe for LogCell<T, A>

impl<T: PSafe + ?Sized, A: MemPool> UnwindSafe for LogCell<T, A>