Struct sharded_slab::pool::OwnedRef[][src]

pub struct OwnedRef<T, C = DefaultConfig> where
    T: Clear + Default,
    C: Config
{ /* fields omitted */ }

An owned guard that allows shared immutable access to an object in a pool.

While the guard exists, it indicates to the pool that the item the guard references is currently being accessed. If the item is removed from the pool while the guard exists, the removal will be deferred until all guards are dropped.

Unlike Ref, which borrows the pool, an OwnedRef clones the Arc around the pool. Therefore, it keeps the pool from being dropped until all such guards have been dropped. This means that an OwnedRef may be held for an arbitrary lifetime.

Examples

use std::sync::Arc;

let pool: Arc<Pool<String>> = Arc::new(Pool::new());
let key = pool.create_with(|item| item.push_str("hello world")).unwrap();

// Look up the created `Key`, returning an `OwnedRef`.
let value = pool.clone().get_owned(key).unwrap();

// Now, the original `Arc` clone of the pool may be dropped, but the
// returned `OwnedRef` can still access the value.
assert_eq!(value, String::from("hello world"));

Unlike Ref, an OwnedRef may be stored in a struct which must live for the 'static lifetime:

use sharded_slab::pool::OwnedRef;
use std::sync::Arc;

pub struct MyStruct {
    pool_ref: OwnedRef<String>,
    // ... other fields ...
}

// Suppose this is some arbitrary function which requires a value that
// lives for the 'static lifetime...
fn function_requiring_static<T: 'static>(t: &T) {
    // ... do something extremely important and interesting ...
}

let pool: Arc<Pool<String>> = Arc::new(Pool::new());
let key = pool.create_with(|item| item.push_str("hello world")).unwrap();

// Look up the created `Key`, returning an `OwnedRef`.
let pool_ref = pool.clone().get_owned(key).unwrap();
let my_struct = MyStruct {
    pool_ref,
    // ...
};

// We can use `my_struct` anywhere where it is required to have the
// `'static` lifetime:
function_requiring_static(&my_struct);

OwnedRefs may be sent between threads:

use std::{thread, sync::Arc};

let pool: Arc<Pool<String>> = Arc::new(Pool::new());
let key = pool.create_with(|item| item.push_str("hello world")).unwrap();

// Look up the created `Key`, returning an `OwnedRef`.
let value = pool.clone().get_owned(key).unwrap();

thread::spawn(move || {
    assert_eq!(value, String::from("hello world"));
    // ...
}).join().unwrap();

Implementations

impl<T, C> OwnedRef<T, C> where
    T: Clear + Default,
    C: Config
[src]

pub fn key(&self) -> usize[src]

Returns the key used to access this guard

Trait Implementations

impl<T, C> Debug for OwnedRef<T, C> where
    T: Debug + Clear + Default,
    C: Config
[src]

impl<T, C> Deref for OwnedRef<T, C> where
    T: Clear + Default,
    C: Config
[src]

type Target = T

The resulting type after dereferencing.

impl<T, C> Drop for OwnedRef<T, C> where
    T: Clear + Default,
    C: Config
[src]

impl<T, C> PartialEq<T> for OwnedRef<T, C> where
    T: PartialEq<T> + Clear + Default,
    C: Config
[src]

impl<T, C> Send for OwnedRef<T, C> where
    T: Sync + Clear + Default,
    C: Config
[src]

impl<T, C> Sync for OwnedRef<T, C> where
    T: Sync + Clear + Default,
    C: Config
[src]

Auto Trait Implementations

impl<T, C = DefaultConfig> !RefUnwindSafe for OwnedRef<T, C>

impl<T, C> Unpin for OwnedRef<T, C>

impl<T, C = DefaultConfig> !UnwindSafe for OwnedRef<T, C>

Blanket Implementations

impl<T> Any for T where
    T: 'static + ?Sized
[src]

impl<T> Borrow<T> for T where
    T: ?Sized
[src]

impl<T> BorrowMut<T> for T where
    T: ?Sized
[src]

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, 
[src]

impl<T, U> TryFrom<U> for T where
    U: Into<T>, 
[src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, 
[src]

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

The type returned in the event of a conversion error.