# 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>`

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

Creates a new `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` takes an `Ordering` argument which describes the memory ordering of this operation.

# Panics

Panics if `order` is `Release` or `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` takes an `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` is `Acquire` or `AcqRel`.

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

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

`swap` takes an `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, current: *mut T, new: *mut T, order: Ordering) -> *mut T`

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

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

`compare_and_swap` also takes an `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> Send for AtomicPtr<T>`

### `impl<T> Sync for AtomicPtr<T>`

### `impl<T> Debug for AtomicPtr<T>`

#### `fn fmt(&self, f: &mut Formatter) -> Result<(), Error>`

# Help

## Keyboard Shortcuts

?
  Show this help dialog
S
  Focus the search field
⇤
  Move up in search results
⇥
  Move down in search results
⏎
  Go to active search result

## Search Tricks

Prefix searches with a type followed by a colon (e.g. `fn:`) to restrict the search to a given type.

Accepted types are: `fn`, `mod`, `struct`, `enum`, `trait`, `type`, `macro`, and `const`.

Search functions by type signature (e.g. `vec -> usize`)