Struct core::cell::RefCell [] [src]

pub struct RefCell<T: ?Sized> {
    // some fields omitted
}

A mutable memory location with dynamically checked borrow rules

See the module-level documentation for more.

Methods

impl<T> RefCell<T>

fn new(value: T) -> RefCell<T>

Creates a new RefCell`RefCellcontaining` containing value`value`.

Examples

fn main() { use std::cell::RefCell; let c = RefCell::new(5); }
use std::cell::RefCell;

let c = RefCell::new(5);

fn into_inner(self) -> T

Consumes the RefCell`RefCell`, returning the wrapped value.

Examples

fn main() { use std::cell::RefCell; let c = RefCell::new(5); let five = c.into_inner(); }
use std::cell::RefCell;

let c = RefCell::new(5);

let five = c.into_inner();

impl<T: ?Sized> RefCell<T>

fn borrow_state(&self) -> BorrowState

Unstable

Query the current state of this RefCell`RefCell`

The returned value can be dispatched on to determine if a call to borrow`borrowor` or borrow_mut`borrow_mut` would succeed.

fn borrow<'a>(&'a self) -> Ref<'a, T>

Immutably borrows the wrapped value.

The borrow lasts until the returned Ref`Ref` exits scope. Multiple immutable borrows can be taken out at the same time.

Panics

Panics if the value is currently mutably borrowed.

Examples

fn main() { use std::cell::RefCell; let c = RefCell::new(5); let borrowed_five = c.borrow(); let borrowed_five2 = c.borrow(); }
use std::cell::RefCell;

let c = RefCell::new(5);

let borrowed_five = c.borrow();
let borrowed_five2 = c.borrow();

An example of panic:

fn main() { use std::cell::RefCell; use std::thread; let result = thread::spawn(move || { let c = RefCell::new(5); let m = c.borrow_mut(); let b = c.borrow(); // this causes a panic }).join(); assert!(result.is_err()); }
use std::cell::RefCell;
use std::thread;

let result = thread::spawn(move || {
   let c = RefCell::new(5);
   let m = c.borrow_mut();

   let b = c.borrow(); // this causes a panic
}).join();

assert!(result.is_err());

fn borrow_mut<'a>(&'a self) -> RefMut<'a, T>

Mutably borrows the wrapped value.

The borrow lasts until the returned RefMut`RefMut` exits scope. The value cannot be borrowed while this borrow is active.

Panics

Panics if the value is currently borrowed.

Examples

fn main() { use std::cell::RefCell; let c = RefCell::new(5); let borrowed_five = c.borrow_mut(); }
use std::cell::RefCell;

let c = RefCell::new(5);

let borrowed_five = c.borrow_mut();

An example of panic:

fn main() { use std::cell::RefCell; use std::thread; let result = thread::spawn(move || { let c = RefCell::new(5); let m = c.borrow(); let b = c.borrow_mut(); // this causes a panic }).join(); assert!(result.is_err()); }
use std::cell::RefCell;
use std::thread;

let result = thread::spawn(move || {
   let c = RefCell::new(5);
   let m = c.borrow();

   let b = c.borrow_mut(); // this causes a panic
}).join();

assert!(result.is_err());

unsafe fn as_unsafe_cell<'a>(&'a self) -> &'a UnsafeCell<T>

Unstable

Gets a reference to the underlying UnsafeCell`UnsafeCell`.

This can be used to circumvent RefCell`RefCell`'s safety checks.

This function is unsafe`unsafebecause` because UnsafeCell`UnsafeCell`'s field is public.

Trait Implementations

impl<T: ?Sized> Send for RefCell<T> where T: Send

impl<T: Clone> Clone for RefCell<T>

fn clone(&self) -> RefCell<T>

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

impl<T: Default> Default for RefCell<T>

fn default() -> RefCell<T>

impl<T: ?Sized + PartialEq> PartialEq for RefCell<T>

fn eq(&self, other: &RefCell<T>) -> bool

fn ne(&self, other: &Rhs) -> bool

impl<T: ?Sized + Debug> Debug for RefCell<T>

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