Struct FlagCell 

pub struct FlagCell<T>(/* private fields */);

带标记+引用计数+内部可变性的智能容器 逻辑上是唯一所有权持有者，逻辑禁用后可通过FlagRef::resurrect复活

确保在安全使用时，Cell存在即内部数据存在。 正常使用时，逻辑上是不会有人再访问已经释放的数据的，因为确保访问者死完了数据才会释放。

Implementations

impl<T> FlagCell<T>

pub fn ref_count(&self) -> isize

获取当前 FlagRef 引用数量

pub fn is_enabled(&self) -> bool

获取数据是否逻辑启用

pub fn enable(&self) -> Option<()>

将数据逻辑启用

pub fn disable(&self) -> Option<()>

将数据逻辑禁用

这将禁止所有对应 FlagRef 使用内部数据，直到调用 [enable]

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.

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

Mutably borrows the wrapped value.

The borrow lasts until the returned RefMut or all RefMuts 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.

pub fn try_borrow(&self) -> Option<Ref<'_, T>>

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.

pub fn try_borrow_mut(&self) -> Option<RefMut<'_, T>>

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

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

This is the non-panicking variant of borrow_mut.

pub fn new(value: T) -> Self

Creates a new FlagCell containing value.

pub fn as_ref_cell_ref(&self) -> &RefCell<ManuallyDrop<T>>

得到内部RefCell的引用

pub fn as_ref_cell_ptr(&self) -> *const RefCell<ManuallyDrop<T>>

得到内部RefCell的指针

pub fn flag_borrow(&self) -> FlagRef<T>

生成一个 FlagRef

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

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

This function corresponds to mem::replace.

Panics

Panics if the value is currently borrowed.

For non-panicking variant , see try_replace.

pub fn try_replace(&self, value: T) -> Result<T, T>

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

This function corresponds to mem::replace.

如果当前存在引用，返回Err返还传入值

This is the non-panicking variant of replace.

pub fn unwrap(self) -> T

消费自身，返回内部数据，同时禁用

Panics

若当前存在任何引用（包括FlagRef），或被异常禁用，panic。

For non-panicking variant , see try_unwrap.

pub fn try_unwrap(self) -> Result<T, Self>

消费自身，返回内部数据，同时禁用

若当前存在任何引用（包括FlagRef），或被异常禁用，返还Self

This is the non-panicking variant of unwrap.

Methods from Deref<Target = RefCell<ManuallyDrop<T>>>

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));

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

where F: FnOnce(&mut T) -> 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));

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

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, or if self and other point to the same RefCell.

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));

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();

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

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());
}

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

Mutably borrows the wrapped value.

The borrow lasts until the returned RefMut or all RefMuts 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");

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

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 RefMuts 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());

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();

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 behavior.

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());
}

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);

Trait Implementations

impl<T: Debug> Debug for FlagCell<T>

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

Formats the value using the given formatter.

impl<T> Deref for FlagCell<T>

type Target = RefCell<ManuallyDrop<T>>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<T> Drop for FlagCell<T>

fn drop(&mut self)

Executes the destructor for this type.