Struct AtomicOwned

Source

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

Expand description

AtomicOwned owns the underlying instance, and allows users to perform atomic operations on the pointer to it.

Implementations§

Source §

impl<T: 'static> AtomicOwned<T>

Source

pub fn new(t: T) -> Self

Creates a new AtomicOwned from an instance of T.

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, live as long as 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 sdd::AtomicOwned;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(10);

Source §

impl<T> AtomicOwned<T>

Source

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

Creates a new AtomicOwned from an Owned of T.

§Examples

use sdd::{AtomicOwned, Owned};

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

Source

pub const fn null() -> Self

Creates a null AtomicOwned.

§Examples

use sdd::AtomicOwned;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::null();

Source

pub fn is_null(&self, order: Ordering) -> bool

Returns true if the AtomicOwned is null.

§Examples

use sdd::{AtomicOwned, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::null();
atomic_owned.update_tag_if(Tag::Both, |p| p.tag() == Tag::None, Relaxed, Relaxed);
assert!(atomic_owned.is_null(Relaxed));

Source

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

Loads a pointer value from the AtomicOwned.

§Examples

use sdd::{AtomicOwned, Guard};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(11);
let guard = Guard::new();
let ptr = atomic_owned.load(Relaxed, &guard);
assert_eq!(*ptr.as_ref().unwrap(), 11);

Source

pub fn swap( &self, new: (Option<Owned<T>>, Tag), order: Ordering, ) -> (Option<Owned<T>>, Tag)

Stores the given value into the AtomicOwned and returns the original value.

§Examples

use sdd::{AtomicOwned, Guard, Owned, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(14);
let guard = Guard::new();
let (old, tag) = atomic_owned.swap((Some(Owned::new(15)), Tag::Second), Relaxed);
assert_eq!(tag, Tag::None);
assert_eq!(*old.unwrap(), 14);
let (old, tag) = atomic_owned.swap((None, Tag::First), Relaxed);
assert_eq!(tag, Tag::Second);
assert_eq!(*old.unwrap(), 15);
let (old, tag) = atomic_owned.swap((None, Tag::None), Relaxed);
assert_eq!(tag, Tag::First);
assert!(old.is_none());

Source

pub fn tag(&self, order: Ordering) -> Tag

Returns its Tag.

§Examples

use sdd::{AtomicOwned, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::null();
assert_eq!(atomic_owned.tag(Relaxed), Tag::None);

Source

pub fn update_tag_if<F: FnMut(Ptr<'_, T>) -> bool>( &self, tag: Tag, condition: F, set_order: Ordering, fetch_order: Ordering, ) -> bool

Sets a new Tag if the given condition is met.

Returns true if the new Tag has been successfully set.

§Examples

use sdd::{AtomicOwned, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::null();
assert!(atomic_owned.update_tag_if(Tag::Both, |p| p.tag() == Tag::None, Relaxed, Relaxed));
assert_eq!(atomic_owned.tag(Relaxed), Tag::Both);

Source

pub fn compare_exchange<'g>( &self, current: Ptr<'g, T>, new: (Option<Owned<T>>, Tag), success: Ordering, failure: Ordering, _guard: &'g Guard, ) -> Result<(Option<Owned<T>>, Ptr<'g, T>), (Option<Owned<T>>, Ptr<'g, T>)>

Stores new into the AtomicOwned if the current value is the same as current.

Returns the previously held value and the updated Ptr.

§Errors

Returns Err with the supplied Owned and the current Ptr.

§Examples

use sdd::{AtomicOwned, Guard, Owned, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(17);
let guard = Guard::new();

let mut ptr = atomic_owned.load(Relaxed, &guard);
assert_eq!(*ptr.as_ref().unwrap(), 17);

atomic_owned.update_tag_if(Tag::Both, |_| true, Relaxed, Relaxed);
assert!(atomic_owned.compare_exchange(
    ptr, (Some(Owned::new(18)), Tag::First), Relaxed, Relaxed, &guard).is_err());

ptr.set_tag(Tag::Both);
let old: Owned<usize> = atomic_owned.compare_exchange(
    ptr, (Some(Owned::new(18)), Tag::First), Relaxed, Relaxed, &guard).unwrap().0.unwrap();
assert_eq!(*old, 17);
drop(old);

assert!(atomic_owned.compare_exchange(
    ptr, (Some(Owned::new(19)), Tag::None), Relaxed, Relaxed, &guard).is_err());
assert_eq!(*ptr.as_ref().unwrap(), 17);

Source

pub fn compare_exchange_weak<'g>( &self, current: Ptr<'g, T>, new: (Option<Owned<T>>, Tag), success: Ordering, failure: Ordering, _guard: &'g Guard, ) -> Result<(Option<Owned<T>>, Ptr<'g, T>), (Option<Owned<T>>, Ptr<'g, T>)>

Stores new into the AtomicOwned if the current value is the same as current.

This method is allowed to spuriously fail even when the comparison succeeds.

Returns the previously held value and the updated Ptr.

§Errors

Returns Err with the supplied Owned and the current Ptr.

§Examples

use sdd::{AtomicOwned, Owned, Guard, Tag};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(17);
let guard = Guard::new();

let mut ptr = atomic_owned.load(Relaxed, &guard);
assert_eq!(*ptr.as_ref().unwrap(), 17);

while let Err((_, actual)) = atomic_owned.compare_exchange_weak(
    ptr,
    (Some(Owned::new(18)), Tag::First),
    Relaxed,
    Relaxed,
    &guard) {
    ptr = actual;
}

let mut ptr = atomic_owned.load(Relaxed, &guard);
assert_eq!(*ptr.as_ref().unwrap(), 18);

Source

pub fn into_owned(self, order: Ordering) -> Option<Owned<T>>

Converts self into an Owned.

Returns None if self did not own an instance.

§Examples

use sdd::{AtomicOwned, Owned};
use std::sync::atomic::Ordering::Relaxed;

let atomic_owned: AtomicOwned<usize> = AtomicOwned::new(55);
let owned: Owned<usize> = atomic_owned.into_owned(Relaxed).unwrap();
assert_eq!(*owned, 55);