///
/// This type has the same in-memory representation as a [`bool`].
///
+/// **Note**: This type may not be available on some platforms.
+///
/// [`bool`]: ../../../std/primitive.bool.html
#[cfg(target_has_atomic_load_store = "8")]
#[stable(feature = "rust1", since = "1.0.0")]
/// A raw pointer type which can be safely shared between threads.
///
/// This type has the same in-memory representation as a `*mut T`.
+///
+/// **Note**: This type may not be available on some platforms. Its size depends
+/// on the target pointer's size.
#[cfg(target_has_atomic_load_store = "ptr")]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg_attr(target_pointer_width = "16", repr(C, align(2)))]
/// assert_eq!(some_bool.swap(false, Ordering::Relaxed), true);
/// assert_eq!(some_bool.load(Ordering::Relaxed), false);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "8")]
/// assert_eq!(some_bool.compare_and_swap(true, true, Ordering::Relaxed), false);
/// assert_eq!(some_bool.load(Ordering::Relaxed), false);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "8")]
/// Err(false));
/// assert_eq!(some_bool.load(Ordering::Relaxed), false);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "extended_compare_and_swap", since = "1.10.0")]
#[cfg(target_has_atomic = "8")]
/// }
/// }
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "extended_compare_and_swap", since = "1.10.0")]
#[cfg(target_has_atomic = "8")]
/// assert_eq!(foo.fetch_and(false, Ordering::SeqCst), false);
/// assert_eq!(foo.load(Ordering::SeqCst), false);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "8")]
/// assert_eq!(foo.fetch_nand(false, Ordering::SeqCst), false);
/// assert_eq!(foo.load(Ordering::SeqCst), true);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "8")]
/// assert_eq!(foo.fetch_or(false, Ordering::SeqCst), false);
/// assert_eq!(foo.load(Ordering::SeqCst), false);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "8")]
/// assert_eq!(foo.fetch_xor(false, Ordering::SeqCst), false);
/// assert_eq!(foo.load(Ordering::SeqCst), false);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "8")]
///
/// let value = some_ptr.swap(other_ptr, Ordering::Relaxed);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "ptr")]
///
/// let value = some_ptr.compare_and_swap(ptr, other_ptr, Ordering::Relaxed);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "rust1", since = "1.0.0")]
#[cfg(target_has_atomic = "ptr")]
/// let value = some_ptr.compare_exchange(ptr, other_ptr,
/// Ordering::SeqCst, Ordering::Relaxed);
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "extended_compare_and_swap", since = "1.10.0")]
#[cfg(target_has_atomic = "ptr")]
/// }
/// }
/// ```
+ ///
+ /// **Note**: This method may not be available on some platforms.
#[inline]
#[stable(feature = "extended_compare_and_swap", since = "1.10.0")]
#[cfg(target_has_atomic = "ptr")]
/// non-atomic types as well as information about the portability of
/// this type, please see the [module-level documentation].
///
+ /// **Note**: This type may not be available on some platforms.
+ ///
/// [module-level documentation]: index.html
#[$stable]
#[repr(C, align($align))]
let some_var = ", stringify!($atomic_type), "::new(5);
assert_eq!(some_var.swap(10, Ordering::Relaxed), 5);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
assert_eq!(some_var.compare_and_swap(6, 12, Ordering::Relaxed), 10);
assert_eq!(some_var.load(Ordering::Relaxed), 10);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
Ordering::Acquire),
Err(10));
assert_eq!(some_var.load(Ordering::Relaxed), 10);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable_cxchg]
#[$cfg_cas]
Err(x) => old = x,
}
}
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable_cxchg]
#[$cfg_cas]
let foo = ", stringify!($atomic_type), "::new(0);
assert_eq!(foo.fetch_add(10, Ordering::SeqCst), 0);
assert_eq!(foo.load(Ordering::SeqCst), 10);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
let foo = ", stringify!($atomic_type), "::new(20);
assert_eq!(foo.fetch_sub(10, Ordering::SeqCst), 20);
assert_eq!(foo.load(Ordering::SeqCst), 10);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
let foo = ", stringify!($atomic_type), "::new(0b101101);
assert_eq!(foo.fetch_and(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b100001);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
let foo = ", stringify!($atomic_type), "::new(0x13);
assert_eq!(foo.fetch_nand(0x31, Ordering::SeqCst), 0x13);
assert_eq!(foo.load(Ordering::SeqCst), !(0x13 & 0x31));
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable_nand]
#[$cfg_cas]
let foo = ", stringify!($atomic_type), "::new(0b101101);
assert_eq!(foo.fetch_or(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b111111);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
let foo = ", stringify!($atomic_type), "::new(0b101101);
assert_eq!(foo.fetch_xor(0b110011, Ordering::SeqCst), 0b101101);
assert_eq!(foo.load(Ordering::SeqCst), 0b011110);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[$stable]
#[$cfg_cas]
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(7));
assert_eq!(x.fetch_update(Ordering::SeqCst, Ordering::SeqCst, |x| Some(x + 1)), Ok(8));
assert_eq!(x.load(Ordering::SeqCst), 9);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[stable(feature = "no_more_cas", since = "1.45.0")]
#[$cfg_cas]
let bar = 42;
let max_foo = foo.fetch_max(bar, Ordering::SeqCst).max(bar);
assert!(max_foo == 42);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[stable(feature = "atomic_min_max", since = "1.45.0")]
#[$cfg_cas]
let bar = 12;
let min_foo = foo.fetch_min(bar, Ordering::SeqCst).min(bar);
assert_eq!(min_foo, 12);
-```"),
+```
+
+**Note**: This method may not be available on some platforms."),
#[inline]
#[stable(feature = "atomic_min_max", since = "1.45.0")]
#[$cfg_cas]