Struct refpool::PoolRef

pub struct PoolRef<A, S> where
    S: PoolSyncType<A>,  { /* fields omitted */ }

A reference counted pointer to A.

Methods

impl<A, S> PoolRef<A, S> where
    S: PoolSyncType<A>, 

pub fn default(pool: &Pool<A, S>) -> Self where
    A: PoolDefault, 

Construct a PoolRef with a newly initialised value of A.

This uses PoolDefault::default_uninit() to initialise a default value, which may be faster than constructing a PoolRef from an existing value using PoolRef::new(), depending on the data type.

pub fn new(pool: &Pool<A, S>, value: A) -> Self

Wrap a value in a PoolRef.

This will copy the entire value into the memory handled by the PoolRef, which may be slower than using PoolRef::default(), so it's not recommended to use this to construct the default value.

pub fn clone_from(pool: &Pool<A, S>, value: &A) -> Self where
    A: PoolClone, 

Clone a value and return a new PoolRef to it.

This will use PoolClone::clone_uninit() to perform the clone, which may be more efficient than using PoolRef::new(value.clone()).

Examples

let mut pool: Pool<Vec<usize>> = Pool::new(1);
let vec = vec![1, 2, 3];
let ref1 = PoolRef::clone_from(&mut pool, &vec);
assert_eq!(vec, *ref1);

pub fn pin_default(pool: &Pool<A, S>) -> Pin<Self> where
    A: PoolDefault, 

Construct a Pinned PoolRef with a default value.

pub fn pin(pool: &Pool<A, S>, value: A) -> Pin<Self>

Construct a Pinned PoolRef with the given value.

pub fn cloned(&self, pool: &Pool<A, S>) -> Self where
    A: PoolClone, 

Clone the value inside a PoolRef and return a new PoolRef to it.

This will use PoolClone::clone_uninit() to perform the clone, which may be more efficient than using PoolRef::new((*this_ref).clone()).

pub fn make_mut<'a>(pool: &Pool<A, S>, this: &'a mut Self) -> &'a mut A where
    A: PoolClone, 

Get a mutable reference to the value inside a PoolRef, cloning it first if this PoolRef isn't a unique reference.

Examples

let mut pool: Pool<usize> = Pool::new(1);
let ref1 = PoolRef::new(&mut pool, 1);
let mut ref2 = ref1.clone();
*PoolRef::make_mut(&mut pool, &mut ref2) = 2;
assert_eq!(1, *ref1);
assert_eq!(2, *ref2);

pub fn get_mut(this: &mut Self) -> Option<&mut A>

Attempt to get a mutable reference to the value inside a PoolRef.

This will produce a None if this PoolRef isn't a unique reference to the value.

pub fn try_unwrap(this: Self) -> Result<A, Self>

Attempt to unwrap the value inside a PoolRef.

If this PoolRef isn't the only reference to the value, ownership of the PoolRef is passed back to you in the Err value.

Please note that the unwrapped value is not reclaimed by the pool when dropped.

Examples

let mut pool: Pool<usize> = Pool::new(1);
let ref1 = PoolRef::default(&mut pool);
let ref2 = ref1.clone();
let unwrap_result = PoolRef::try_unwrap(ref1);
assert!(unwrap_result.is_err());

let mut pool: Pool<usize> = Pool::new(1);
let ref1 = PoolRef::new(&mut pool, 1337);
if let Ok(number) = PoolRef::try_unwrap(ref1) {
    assert_eq!(1337, number);
} else {
    panic!("couldn't unwrap the number after all!");
}

pub fn unwrap_or_clone(this: Self) -> A where
    A: PoolClone, 

Unwrap the value inside a PoolRef, cloning if necessary.

If this PoolRef is a unique reference to the value, the value is unwrapped and returned, consuming the PoolRef. Otherwise, the value is cloned and the clone is returned.

Please note that the unwrapped value is not reclaimed by the pool when dropped.

pub fn ptr_eq(left: &Self, right: &Self) -> bool

Test two PoolRefs for pointer equality.

Examples

let mut pool: Pool<usize> = Pool::new(1);
let ref1 = PoolRef::default(&mut pool);
let ref2 = ref1.clone();
assert!(PoolRef::ptr_eq(&ref1, &ref2));

pub fn strong_count(this: &Self) -> usize

Get the current number of LocalRef references to the wrapped value.

Trait Implementations

impl<A, S> AsRef<A> for PoolRef<A, S> where
    S: PoolSyncType<A>, 

fn as_ref(&self) -> &A

Performs the conversion.

impl<A, S> Borrow<A> for PoolRef<A, S> where
    S: PoolSyncType<A>, 

fn borrow(&self) -> &A

Immutably borrows from an owned value.

impl<A, S> Clone for PoolRef<A, S> where
    S: PoolSyncType<A>, 

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A, S> Debug for PoolRef<A, S> where
    A: Debug,
    S: PoolSyncType<A>, 

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

Formats the value using the given formatter.

impl<A, S> Deref for PoolRef<A, S> where
    S: PoolSyncType<A>, 

type Target = A

The resulting type after dereferencing.

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

Dereferences the value.

impl<A, S> Display for PoolRef<A, S> where
    A: Display,
    S: PoolSyncType<A>, 

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

Formats the value using the given formatter.

impl<A, S> Drop for PoolRef<A, S> where
    S: PoolSyncType<A>, 

fn drop(&mut self)

Executes the destructor for this type.

impl<A, S> Eq for PoolRef<A, S> where
    A: Eq,
    S: PoolSyncType<A>, 

impl<A, S> Hash for PoolRef<A, S> where
    A: Hash,
    S: PoolSyncType<A>, 

fn hash<H: Hasher>(&self, hasher: &mut H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl<A, S> Ord for PoolRef<A, S> where
    A: Ord,
    S: PoolSyncType<A>, 

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

Compares and returns the minimum of two values.

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

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

Restrict a value to a certain interval.

impl<A, S> PartialEq<PoolRef<A, S>> for PoolRef<A, S> where
    A: PartialEq,
    S: PoolSyncType<A>, 

fn eq(&self, other: &Self) -> bool

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

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

This method tests for !=.

impl<A, S> PartialOrd<PoolRef<A, S>> for PoolRef<A, S> where
    A: PartialOrd,
    S: PoolSyncType<A>, 

fn partial_cmp(&self, other: &Self) -> Option<Ordering>

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

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

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

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

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

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

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

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

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

impl<A, S> Pointer for PoolRef<A, S> where
    S: PoolSyncType<A>, 

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

Formats the value using the given formatter.