Struct scc::ebr::Owned

source ·

pub struct Owned<T> { /* private fields */ }

Expand description

Owned uniquely owns an instance.

The instance it passed to the EBR garbage collector when the Owned is dropped.

Implementations§

source §

impl<T: 'static> Owned<T>

source

pub fn new(t: T) -> Self

Creates a new instance of Owned.

The type of the instance must be determined at compile-time, must not contain non-static references, and must not be a non-static reference since the instance can, theoretically, survive the process. For instance, struct Disallowed<'l, T>(&'l T) is not allowed, because an instance of the type cannot outlive 'l whereas the garbage collector does not guarantee that the instance is dropped within 'l.

§Examples

use scc::ebr::Owned;

let owned: Owned<usize> = Owned::new(31);

source §

impl<T> Owned<T>

source

pub unsafe fn new_unchecked(t: T) -> Self

Creates a new Owned without checking the lifetime of T.

§Safety

T::drop can be run after the Owned is dropped, therefore it is safe only if T::drop does not access short-lived data or std::mem::needs_drop is false for T.

§Examples

use scc::ebr::Owned;

let hello = String::from("hello");
let owned: Owned<&str> = unsafe { Owned::new_unchecked(hello.as_str()) };

source

pub fn get_guarded_ptr<'g>(&self, _guard: &'g Guard) -> Ptr<'g, T>

Returns a Ptr to the instance that may live as long as the supplied Guard.

§Examples

use scc::ebr::{Guard, Owned};

let owned: Owned<usize> = Owned::new(37);
let guard = Guard::new();
let ptr = owned.get_guarded_ptr(&guard);
drop(owned);

assert_eq!(*ptr.as_ref().unwrap(), 37);

source

pub fn get_guarded_ref<'g>(&self, _guard: &'g Guard) -> &'g T

Returns a reference to the instance that may live as long as the supplied Guard.

§Examples

use scc::ebr::{Guard, Owned};

let owned: Owned<usize> = Owned::new(37);
let guard = Guard::new();
let ref_b = owned.get_guarded_ref(&guard);
drop(owned);

assert_eq!(*ref_b, 37);

source

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

Returns a mutable reference to the instance.

§Safety

The method is unsafe since there can be a Ptr to the instance.

§Examples

use scc::ebr::Owned;

let mut owned: Owned<usize> = Owned::new(38);
unsafe {
    *owned.get_mut() += 1;
}
assert_eq!(*owned, 39);

source

pub fn as_ptr(&self) -> *const T

Provides a raw pointer to the instance.

§Examples

use scc::ebr::Owned;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;

let owned: Owned<usize> = Owned::new(10);

assert_eq!(unsafe { *owned.as_ptr() }, 10);

source

pub fn release(self, guard: &Guard)

Releases the ownership by passing self to the given Guard.

§Examples

use scc::ebr::{Guard, Owned};

let owned: Owned<usize> = Owned::new(47);
let guard = Guard::new();
owned.release(&guard);

source

pub unsafe fn drop_in_place(self)

Drops the instance immediately.

§Safety

The caller must ensure that there is no Ptr pointing to the instance.

§Examples

use scc::ebr::Owned;
use std::sync::atomic::AtomicBool;
use std::sync::atomic::Ordering::Relaxed;

static DROPPED: AtomicBool = AtomicBool::new(false);
struct T(&'static AtomicBool);
impl Drop for T {
    fn drop(&mut self) {
        self.0.store(true, Relaxed);
    }
}

let owned: Owned<T> = Owned::new(T(&DROPPED));
assert!(!DROPPED.load(Relaxed));

unsafe {
    owned.drop_in_place();
}

assert!(DROPPED.load(Relaxed));