RefCell in core::cell - Rust
Description: A mutable memory location with dynamically checked borrow rules
Keywords: rust, rustlang, rust-lang, RefCell

# Struct core::cell::RefCell
1.0.0[−][src]

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

Expand description

A mutable memory location with dynamically checked borrow rules

See the module-level documentation for more.

## Implementations

[src]

### impl<T> RefCell<T>

1.0.0 (const: 1.24.0)[src]

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

Creates a new `RefCell` containing `value`.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

Run
1.0.0 (const: unstable)[src]

#### pub fn into_inner(self) -> T

Consumes the `RefCell`, returning the wrapped value.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

    let five = c.into_inner();

Run
1.24.0[src]

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

Replaces the wrapped value with a new one, returning the old value, without deinitializing either one.

This function corresponds to `std::mem::replace`.

# Panics

Panics if the value is currently borrowed.

# Examples

    use std::cell::RefCell;
    let cell = RefCell::new(5);
    let old_value = cell.replace(6);
    assert_eq!(old_value, 5);
    assert_eq!(cell, RefCell::new(6));

Run
1.35.0[src]

#### pub fn replace_with<F: FnOnce(&mut T) -> T>(&self, f: F) -> T

Replaces the wrapped value with a new one computed from `f`, returning the old value, without deinitializing either one.

# Panics

Panics if the value is currently borrowed.

# Examples

    use std::cell::RefCell;
    let cell = RefCell::new(5);
    let old_value = cell.replace_with(|&mut old| old + 1);
    assert_eq!(old_value, 5);
    assert_eq!(cell, RefCell::new(6));

Run
1.24.0[src]

#### pub fn swap(&self, other: &Self)

Swaps the wrapped value of `self` with the wrapped value of `other`, without deinitializing either one.

This function corresponds to `std::mem::swap`.

# Panics

Panics if the value in either `RefCell` is currently borrowed.

# Examples

    use std::cell::RefCell;
    let c = RefCell::new(5);
    let d = RefCell::new(6);
    c.swap(&d);
    assert_eq!(c, RefCell::new(6));
    assert_eq!(d, RefCell::new(5));

Run
[src]

### impl<T: ?Sized> RefCell<T>

[src]

#### pub fn borrow(&self) -> Ref<'_, T>

Immutably borrows the wrapped value.

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

# Panics

Panics if the value is currently mutably borrowed. For a non-panicking variant, use `try_borrow`.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

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

Run

An example of panic:

ⓘ

    use std::cell::RefCell;

    let c = RefCell::new(5);

    let m = c.borrow_mut();
    let b = c.borrow(); // this causes a panic

Run
1.13.0[src]

#### pub fn try_borrow(&self) -> Result<Ref<'_, T>, BorrowError>

Immutably borrows the wrapped value, returning an error if the value is currently mutably borrowed.

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

This is the non-panicking variant of `borrow`.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

    {
        let m = c.borrow_mut();
        assert!(c.try_borrow().is_err());
    }

    {
        let m = c.borrow();
        assert!(c.try_borrow().is_ok());
    }

Run
[src]

#### pub fn borrow_mut(&self) -> RefMut<'_, T>

Mutably borrows the wrapped value.

The borrow lasts until the returned `RefMut` or all `RefMut`s derived from it exit scope. The value cannot be borrowed while this borrow is active.

# Panics

Panics if the value is currently borrowed. For a non-panicking variant, use `try_borrow_mut`.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new("hello".to_owned());

    *c.borrow_mut() = "bonjour".to_owned();

    assert_eq!(&*c.borrow(), "bonjour");

Run

An example of panic:

ⓘ

    use std::cell::RefCell;

    let c = RefCell::new(5);
    let m = c.borrow();

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

Run
1.13.0[src]

#### pub fn try_borrow_mut(&self) -> Result<RefMut<'_, T>, BorrowMutError>

Mutably borrows the wrapped value, returning an error if the value is currently borrowed.

The borrow lasts until the returned `RefMut` or all `RefMut`s derived from it exit scope. The value cannot be borrowed while this borrow is active.

This is the non-panicking variant of `borrow_mut`.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

    {
        let m = c.borrow();
        assert!(c.try_borrow_mut().is_err());
    }

    assert!(c.try_borrow_mut().is_ok());

Run
1.12.0[src]

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

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

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

    let ptr = c.as_ptr();

Run
1.11.0[src]

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

Returns a mutable reference to the underlying data.

This call borrows `RefCell` mutably (at compile-time) so there is no need for dynamic checks.

However be cautious: this method expects `self` to be mutable, which is generally not the case when using a `RefCell`. Take a look at the `borrow_mut` method instead if `self` isn’t mutable.

Also, please be aware that this method is only for special circumstances and is usually not what you want. In case of doubt, use `borrow_mut` instead.

# Examples

    use std::cell::RefCell;

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

    assert_eq!(c, RefCell::new(6));

Run
[src]

#### pub fn undo_leak(&mut self) -> &mut T

🔬 This is a nightly-only experimental API. (`cell_leak` #69099)

Undo the effect of leaked guards on the borrow state of the `RefCell`.

This call is similar to `get_mut` but more specialized. It borrows `RefCell` mutably to ensure no borrows exist and then resets the state tracking shared borrows. This is relevant if some `Ref` or `RefMut` borrows have been leaked.

# Examples

    #![feature(cell_leak)]
    use std::cell::RefCell;

    let mut c = RefCell::new(0);
    std::mem::forget(c.borrow_mut());

    assert!(c.try_borrow().is_err());
    c.undo_leak();
    assert!(c.try_borrow().is_ok());

Run
1.37.0[src]

#### pub unsafe fn try_borrow_unguarded(&self) -> Result<&T, BorrowError>

Immutably borrows the wrapped value, returning an error if the value is currently mutably borrowed.

# Safety

Unlike `RefCell::borrow`, this method is unsafe because it does not return a `Ref`, thus leaving the borrow flag untouched. Mutably borrowing the `RefCell` while the reference returned by this method is alive is undefined behaviour.

# Examples

    use std::cell::RefCell;

    let c = RefCell::new(5);

    {
        let m = c.borrow_mut();
        assert!(unsafe { c.try_borrow_unguarded() }.is_err());
    }

    {
        let m = c.borrow();
        assert!(unsafe { c.try_borrow_unguarded() }.is_ok());
    }

Run
[src]

### impl<T: Default> RefCell<T>

1.50.0[src]

#### pub fn take(&self) -> T

Takes the wrapped value, leaving `Default::default()` in its place.

# Panics

Panics if the value is currently borrowed.

# Examples

    use std::cell::RefCell;

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

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

Run

## Trait Implementations

[src]

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

[src]

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

# Panics

Panics if the value is currently mutably borrowed.

[src]

#### fn clone_from(&mut self, other: &Self)

# Panics

Panics if `other` is currently mutably borrowed.

[src]

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

[src]

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

Formats the value using the given formatter. Read more

[src]

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

[src]

#### fn default() -> RefCell<T>

Creates a `RefCell<T>`, with the `Default` value for T.

1.12.0[src]

### impl<T> From<T> for RefCell<T>

[src]

#### fn from(t: T) -> RefCell<T>

Performs the conversion.

1.10.0[src]

### impl<T: ?Sized + Ord> Ord for RefCell<T>

[src]

#### fn cmp(&self, other: &RefCell<T>) -> Ordering

# Panics

Panics if the value in either `RefCell` is currently borrowed.

1.21.0[src]

#### fn max(self, other: Self) -> Self where
Self: Sized,

Compares and returns the maximum of two values. Read more

1.21.0[src]

#### fn min(self, other: Self) -> Self where
Self: Sized,

Compares and returns the minimum of two values. Read more

1.50.0[src]

#### fn clamp(self, min: Self, max: Self) -> Self where
Self: Sized,

Restrict a value to a certain interval. Read more

[src]

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

[src]

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

# Panics

Panics if the value in either `RefCell` is currently borrowed.

[src]

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

This method tests for `!=`.

1.10.0[src]

### impl<T: ?Sized + PartialOrd> PartialOrd<RefCell<T>> for RefCell<T>

[src]

#### fn partial_cmp(&self, other: &RefCell<T>) -> Option<Ordering>

# Panics

Panics if the value in either `RefCell` is currently borrowed.

[src]

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

# Panics

Panics if the value in either `RefCell` is currently borrowed.

[src]

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

# Panics

Panics if the value in either `RefCell` is currently borrowed.

[src]

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

# Panics

Panics if the value in either `RefCell` is currently borrowed.

[src]

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

# Panics

Panics if the value in either `RefCell` is currently borrowed.

[src]

### impl<T: CoerceUnsized<U>, U> CoerceUnsized<RefCell<U>> for RefCell<T>

1.2.0[src]

### impl<T: ?Sized + Eq> Eq for RefCell<T>

[src]

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

[src]

### impl<T: ?Sized> !Sync for RefCell<T>

## Auto Trait Implementations

### impl<T> !RefUnwindSafe for RefCell<T>

### impl<T: ?Sized> Unpin for RefCell<T> where
T: Unpin,

### impl<T: ?Sized> UnwindSafe for RefCell<T> where
T: UnwindSafe,

## Blanket Implementations

[src]

### impl<T> Any for T where
T: 'static + ?Sized,

[src]

#### pub fn type_id(&Self) -> TypeId

Gets the `TypeId` of `self`. Read more

[src]

### impl<T> Borrow<T> for T where
T: ?Sized,

[src]

#### pub fn borrow(&Self) -> &T

Immutably borrows from an owned value. Read more

[src]

### impl<T> BorrowMut<T> for T where
T: ?Sized,

[src]

#### pub fn borrow_mut(&mut Self) -> &mut T

Mutably borrows from an owned value. Read more

[src]

### impl<T> From<!> for T

[src]

#### pub fn from(!) -> T

Performs the conversion.

[src]

### impl<T> From<T> for T

[src]

#### pub fn from(T) -> T

Performs the conversion.

[src]

### impl<T, U> Into<U> for T where
U: From<T>,

[src]

#### pub fn into(Self) -> U

Performs the conversion.

[src]

### impl<T, U> TryFrom<U> for T where
U: Into<T>,

#### type Error = Infallible

The type returned in the event of a conversion error.

[src]

#### pub fn try_from(U) -> Result<T, <T as TryFrom<U>>::Error>

Performs the conversion.

[src]

### impl<T, U> TryInto<U> for T where
U: TryFrom<T>,

#### type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

[src]

#### pub fn try_into(Self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.