Struct extendr_api::prelude::MathCell

source ·

#[repr(transparent)]
pub struct MathCell<T>(Cell<T>);

Expand description

A transparent wrapper of Cell<T> which is identical in every way, except it will implement arithmetic operators as well.

The purpose of MathCell is to be used from .cell_view(). The MathCell derefs to Cell, so all the cell’s methods are available.

Tuple Fields§

§0: Cell<T>

Implementations§

source §

impl<T> MathCell<T>

source

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

Create a new cell with the given value

source

pub fn into_inner(self) -> T

Return the inner value

source

pub fn swap(&self, other: &MathCell<T>)

Swap value with another cell

Methods from Deref<Target = Cell<T>>§

1.0.0 · source

pub fn set(&self, val: T)

Sets the contained value.

§Examples

use std::cell::Cell;

let c = Cell::new(5);

c.set(10);

1.17.0 · source

pub fn swap(&self, other: &Cell<T>)

Swaps the values of two Cells. Difference with std::mem::swap is that this function doesn’t require &mut reference.

§Panics

This function will panic if self and other are different Cells that partially overlap. (Using just standard library methods, it is impossible to create such partially overlapping Cells. However, unsafe code is allowed to e.g. create two &Cell<[i32; 2]> that partially overlap.)

§Examples

use std::cell::Cell;

let c1 = Cell::new(5i32);
let c2 = Cell::new(10i32);
c1.swap(&c2);
assert_eq!(10, c1.get());
assert_eq!(5, c2.get());

1.17.0 · source

pub fn replace(&self, val: T) -> T

Replaces the contained value with val, and returns the old contained value.

§Examples

use std::cell::Cell;

let cell = Cell::new(5);
assert_eq!(cell.get(), 5);
assert_eq!(cell.replace(10), 5);
assert_eq!(cell.get(), 10);

1.0.0 · source

pub fn get(&self) -> T

Returns a copy of the contained value.

§Examples

use std::cell::Cell;

let c = Cell::new(5);

let five = c.get();

source

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

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

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

§Examples

#![feature(cell_update)]

use std::cell::Cell;

let c = Cell::new(5);
let new = c.update(|x| x + 1);

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

1.12.0 · source

pub fn as_ptr(&self) -> *mut T

Returns a raw pointer to the underlying data in this cell.

§Examples

use std::cell::Cell;

let c = Cell::new(5);

let ptr = c.as_ptr();

1.11.0 · source

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

Returns a mutable reference to the underlying data.

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

However be cautious: this method expects self to be mutable, which is generally not the case when using a Cell. If you require interior mutability by reference, consider using RefCell which provides run-time checked mutable borrows through its borrow_mut method.

§Examples

use std::cell::Cell;

let mut c = Cell::new(5);
*c.get_mut() += 1;

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

1.17.0 · source

pub fn take(&self) -> T

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

§Examples

use std::cell::Cell;

let c = Cell::new(5);
let five = c.take();

assert_eq!(five, 5);
assert_eq!(c.into_inner(), 0);

1.37.0 · source

pub fn as_slice_of_cells(&self) -> &[Cell<T>]

Returns a &[Cell<T>] from a &Cell<[T]>

§Examples

use std::cell::Cell;

let slice: &mut [i32] = &mut [1, 2, 3];
let cell_slice: &Cell<[i32]> = Cell::from_mut(slice);
let slice_cell: &[Cell<i32>] = cell_slice.as_slice_of_cells();

assert_eq!(slice_cell.len(), 3);

source

pub fn as_array_of_cells(&self) -> &[Cell<T>; N]

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

Returns a &[Cell<T>; N] from a &Cell<[T; N]>

§Examples

#![feature(as_array_of_cells)]
use std::cell::Cell;

let mut array: [i32; 3] = [1, 2, 3];
let cell_array: &Cell<[i32; 3]> = Cell::from_mut(&mut array);
let array_cell: &[Cell<i32>; 3] = cell_array.as_array_of_cells();