Struct crossbeam_epoch::Owned

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

An owned heap-allocated object.

This type is very similar to Box<T>.

The pointer must be properly aligned. Since it is aligned, a tag can be stored into the unused least significant bits of the address.

Methods

impl<T> Owned<T>

pub fn new(value: T) -> Owned<T>

Allocates value on the heap and returns a new owned pointer pointing to it.

Examples

use crossbeam_epoch::Owned;

let o = Owned::new(1234);

pub unsafe fn from_raw(raw: *mut T) -> Owned<T>

Returns a new owned pointer pointing to raw.

This function is unsafe because improper use may lead to memory problems. Argument raw must be a valid pointer. Also, a double-free may occur if the function is called twice on the same raw pointer.

Panics

Panics if raw is not properly aligned.

Examples

use crossbeam_epoch::Owned;

let o = unsafe { Owned::from_raw(Box::into_raw(Box::new(1234))) };

pub fn into_shared<'g>(self, _: &'g Guard) -> Shared<'g, T>

Converts the owned pointer into a Shared.

Examples

use crossbeam_epoch::{self as epoch, Owned};

let o = Owned::new(1234);
let guard = &epoch::pin();
let p = o.into_shared(guard);

Important traits for Box<R>

impl<R> Read for Box<R> where
    R: Read + ?Sized, impl<W> Write for Box<W> where
    W: Write + ?Sized, impl<I> Iterator for Box<I> where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;

pub fn into_box(self) -> Box<T>

Converts the owned pointer into a Box.

Examples

use crossbeam_epoch::{self as epoch, Owned};

let o = Owned::new(1234);
let b: Box<i32> = o.into_box();
assert_eq!(*b, 1234);

pub fn tag(&self) -> usize

Returns the tag stored within the pointer.

Examples

use crossbeam_epoch::Owned;

assert_eq!(Owned::new(1234).tag(), 0);

pub fn with_tag(self, tag: usize) -> Owned<T>

Returns the same pointer, but tagged with tag. tag is truncated to be fit into the unused bits of the pointer to T.

Examples

use crossbeam_epoch::Owned;

let o = Owned::new(0u64);
assert_eq!(o.tag(), 0);
let o = o.with_tag(2);
assert_eq!(o.tag(), 2);

Trait Implementations

impl<T> From<Owned<T>> for Atomic<T>

fn from(owned: Owned<T>) -> Self

Returns a new atomic pointer pointing to owned.

Examples

use crossbeam_epoch::{Atomic, Owned};

let a = Atomic::<i32>::from(Owned::new(1234));

impl<T> Pointer<T> for Owned<T>

fn into_usize(self) -> usize

Returns the machine representation of the pointer.

unsafe fn from_usize(data: usize) -> Self

Returns a new pointer pointing to the tagged pointer data.

Panics

Panics if the data is zero in debug mode.

impl<T> Drop for Owned<T>

fn drop(&mut self)

Executes the destructor for this type.

impl<T> Debug for Owned<T>

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

Formats the value using the given formatter.

impl<T: Clone> Clone for Owned<T>

fn clone(&self) -> Self

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T> Deref for Owned<T>

type Target = T

The resulting type after dereferencing.

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

fn deref(&self) -> &T

Dereferences the value.

impl<T> DerefMut for Owned<T>

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

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

Mutably dereferences the value.

impl<T> From<T> for Owned<T>

fn from(t: T) -> Self

Performs the conversion.

impl<T> From<Box<T>> for Owned<T>

fn from(b: Box<T>) -> Self

Returns a new owned pointer pointing to b.

Panics

Panics if the pointer (the Box) is not properly aligned.

Examples

use crossbeam_epoch::Owned;

let o = unsafe { Owned::from_raw(Box::into_raw(Box::new(1234))) };

impl<T> Borrow<T> for Owned<T>

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

fn borrow(&self) -> &T

Immutably borrows from an owned value.

impl<T> BorrowMut<T> for Owned<T>

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

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

Mutably borrows from an owned value.

impl<T> AsRef<T> for Owned<T>

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

fn as_ref(&self) -> &T

Performs the conversion.

impl<T> AsMut<T> for Owned<T>

Important traits for &'a mut I

impl<'a, I> Iterator for &'a mut I where
    I: Iterator + ?Sized,  type Item = <I as Iterator>::Item;impl<'a, R> Read for &'a mut R where
    R: Read + ?Sized, impl<'a, W> Write for &'a mut W where
    W: Write + ?Sized, 

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

Performs the conversion.