Struct std::sync::atomic::AtomicPtr [] [src]

pub struct AtomicPtr<T> {
    // some fields omitted
}

A raw pointer type which can be safely shared between threads.

Methods

impl<T> AtomicPtr<T>

fn new(p: *mut T) -> AtomicPtr<T>

Creates a new AtomicPtr`AtomicPtr`.

Examples

fn main() { use std::sync::atomic::AtomicPtr; let ptr = &mut 5; let atomic_ptr = AtomicPtr::new(ptr); }
use std::sync::atomic::AtomicPtr;

let ptr = &mut 5;
let atomic_ptr  = AtomicPtr::new(ptr);

fn load(&self, order: Ordering) -> *mut T

Loads a value from the pointer.

load`loadtakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Panics

Panics if order`orderis` is Release`Releaseor` or AcqRel`AcqRel`.

Examples

fn main() { use std::sync::atomic::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let value = some_ptr.load(Ordering::Relaxed); }
use std::sync::atomic::{AtomicPtr, Ordering};

let ptr = &mut 5;
let some_ptr  = AtomicPtr::new(ptr);

let value = some_ptr.load(Ordering::Relaxed);

fn store(&self, ptr: *mut T, order: Ordering)

Stores a value into the pointer.

store`storetakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; some_ptr.store(other_ptr, Ordering::Relaxed); }
use std::sync::atomic::{AtomicPtr, Ordering};

let ptr = &mut 5;
let some_ptr  = AtomicPtr::new(ptr);

let other_ptr = &mut 10;

some_ptr.store(other_ptr, Ordering::Relaxed);

Panics

Panics if order`orderis` is Acquire`Acquireor` or AcqRel`AcqRel`.

fn swap(&self, ptr: *mut T, order: Ordering) -> *mut T

Stores a value into the pointer, returning the old value.

swap`swaptakes an` takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; let value = some_ptr.swap(other_ptr, Ordering::Relaxed); }
use std::sync::atomic::{AtomicPtr, Ordering};

let ptr = &mut 5;
let some_ptr  = AtomicPtr::new(ptr);

let other_ptr = &mut 10;

let value = some_ptr.swap(other_ptr, Ordering::Relaxed);

fn compare_and_swap(&self, old: *mut T, new: *mut T, order: Ordering) -> *mut T

Stores a value into the pointer if the current value is the same as the expected value.

The return value is always the previous value. If it is equal to old`old`, then the value was updated.

compare_and_swap`compare_and_swapalso takes an` also takes an Ordering`Ordering` argument which describes the memory ordering of this operation.

Examples

fn main() { use std::sync::atomic::{AtomicPtr, Ordering}; let ptr = &mut 5; let some_ptr = AtomicPtr::new(ptr); let other_ptr = &mut 10; let another_ptr = &mut 10; let value = some_ptr.compare_and_swap(other_ptr, another_ptr, Ordering::Relaxed); }
use std::sync::atomic::{AtomicPtr, Ordering};

let ptr = &mut 5;
let some_ptr  = AtomicPtr::new(ptr);

let other_ptr   = &mut 10;
let another_ptr = &mut 10;

let value = some_ptr.compare_and_swap(other_ptr, another_ptr, Ordering::Relaxed);

Trait Implementations

impl<T> Default for AtomicPtr<T>

fn default() -> AtomicPtr<T>

impl<T> Sync for AtomicPtr<T>