pub struct OwnedEntry<T, C = DefaultConfig>
where C: Config,
{ /* private fields */ }
Expand description

An owned reference to an occupied entry in a Slab.

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

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

§Examples

use std::sync::Arc;

let slab: Arc<Slab<&'static str>> = Arc::new(Slab::new());
let key = slab.insert("hello world").unwrap();

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

// Now, the original `Arc` clone of the slab may be dropped, but the
// returned `OwnedEntry` can still access the value.
assert_eq!(value, "hello world");

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

use sharded_slab::OwnedEntry;
use std::sync::Arc;

pub struct MyStruct {
    entry: OwnedEntry<&'static str>,
    // ... 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 slab: Arc<Slab<&'static str>> = Arc::new(Slab::new());
let key = slab.insert("hello world").unwrap();

// Look up the created key, returning an `OwnedEntry`.
let entry = slab.clone().get_owned(key).unwrap();
let my_struct = MyStruct {
    entry,
    // ...
};

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

OwnedEntrys may be sent between threads:

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

let slab: Arc<Slab<&'static str>> = Arc::new(Slab::new());
let key = slab.insert("hello world").unwrap();

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

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

Implementations§

source§

impl<T, C> OwnedEntry<T, C>
where C: Config,

source

pub fn key(&self) -> usize

Returns the key used to access this guard

Trait Implementations§

source§

impl<T, C> Debug for OwnedEntry<T, C>
where T: Debug, C: Config,

source§

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

Formats the value using the given formatter. Read more
source§

impl<T, C> Drop for OwnedEntry<T, C>
where C: Config,

source§

fn drop(&mut self)

Executes the destructor for this type. Read more
source§

impl<T, C> PartialEq<T> for OwnedEntry<T, C>
where T: PartialEq<T>, C: Config,

source§

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

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

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

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.
source§

impl<T, C> Deref for OwnedEntry<T, C>
where C: Config,

§

type Target = T

The resulting type after dereferencing.
source§

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

Dereferences the value.
source§

impl<T, C> Send for OwnedEntry<T, C>
where T: Sync, C: Config,

source§

impl<T, C> Sync for OwnedEntry<T, C>
where T: Sync, C: Config,

Auto Trait Implementations§

§

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

§

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

§

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

Blanket Implementations§

source§

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

source§

fn type_id(&self) -> TypeId

Gets the TypeId of self. Read more
source§

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

source§

fn borrow(&self) -> &T

Immutably borrows from an owned value. Read more
source§

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

source§

fn borrow_mut(&mut self) -> &mut T

Mutably borrows from an owned value. Read more
source§

impl<T> From<T> for T

source§

fn from(t: T) -> T

Returns the argument unchanged.

source§

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

source§

fn into(self) -> U

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

source§

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

§

type Error = Infallible

The type returned in the event of a conversion error.
source§

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

Performs the conversion.
source§

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.
source§

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

Performs the conversion.