Trait crossbeam_epoch::Pointable[][src]

pub trait Pointable {
    type Init;

    const ALIGN: usize;

    unsafe fn init(init: Self::Init) -> usize;
unsafe fn deref<'a>(ptr: usize) -> &'a Self;
unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut Self;
unsafe fn drop(ptr: usize); }

Types that are pointed to by a single word.

In concurrent programming, it is necessary to represent an object within a word because atomic operations (e.g., reads, writes, read-modify-writes) support only single words. This trait qualifies such types that are pointed to by a single word.

The trait generalizes Box<T> for a sized type T. In a box, an object of type T is allocated in heap and it is owned by a single-word pointer. This trait is also implemented for [MaybeUninit<T>] by storing its size along with its elements and pointing to the pair of array size and elements.

Pointers to Pointable types can be stored in Atomic, Owned, and Shared. In particular, Crossbeam supports dynamically sized slices as follows.

use std::mem::MaybeUninit;
use crossbeam_epoch::Owned;

let o = Owned::<[MaybeUninit<i32>]>::init(10); // allocating [i32; 10]

Associated Types

type Init[src]

The type for initializers.

Loading content...

Associated Constants

const ALIGN: usize[src]

The alignment of pointer.

Loading content...

Required methods

unsafe fn init(init: Self::Init) -> usize[src]

Initializes a with the given initializer.


The result should be a multiple of ALIGN.

unsafe fn deref<'a>(ptr: usize) -> &'a Self[src]

Dereferences the given pointer.


unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut Self[src]

Mutably dereferences the given pointer.


unsafe fn drop(ptr: usize)[src]

Drops the object pointed to by the given pointer.


Loading content...

Implementations on Foreign Types

impl<T> Pointable for [MaybeUninit<T>][src]

type Init = usize

Loading content...


impl<T> Pointable for T[src]

type Init = T

Loading content...