Chris@102: /*
Chris@102:  * Distributed under the Boost Software License, Version 1.0.
Chris@102:  * (See accompanying file LICENSE_1_0.txt or copy at
Chris@102:  * http://www.boost.org/LICENSE_1_0.txt)
Chris@102:  *
Chris@102:  * Copyright (c) 2011 Helge Bahmann
Chris@102:  * Copyright (c) 2013 Tim Blechmann
Chris@102:  * Copyright (c) 2014 Andrey Semashev
Chris@102:  */
Chris@102: /*!
Chris@102:  * \file   atomic/detail/atomic_template.hpp
Chris@102:  *
Chris@102:  * This header contains interface definition of \c atomic template.
Chris@102:  */
Chris@102: 
Chris@102: #ifndef BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_
Chris@102: #define BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_
Chris@102: 
Chris@102: #include <cstddef>
Chris@102: #include <boost/cstdint.hpp>
Chris@102: #include <boost/assert.hpp>
Chris@102: #include <boost/type_traits/is_signed.hpp>
Chris@102: #include <boost/type_traits/is_integral.hpp>
Chris@102: #include <boost/atomic/detail/config.hpp>
Chris@102: #include <boost/atomic/detail/casts.hpp>
Chris@102: #include <boost/atomic/detail/operations_fwd.hpp>
Chris@102: 
Chris@102: #ifdef BOOST_HAS_PRAGMA_ONCE
Chris@102: #pragma once
Chris@102: #endif
Chris@102: 
Chris@102: #if defined(BOOST_MSVC)
Chris@102: #pragma warning(push)
Chris@102: // 'boost::atomics::atomic<T>' : multiple assignment operators specified
Chris@102: #pragma warning(disable: 4522)
Chris@102: #endif
Chris@102: 
Chris@102: /*
Chris@102:  * IMPLEMENTATION NOTE: All interface functions MUST be declared with BOOST_FORCEINLINE,
Chris@102:  *                      see comment for convert_memory_order_to_gcc in ops_gcc_atomic.hpp.
Chris@102:  */
Chris@102: 
Chris@102: namespace boost {
Chris@102: namespace atomics {
Chris@102: namespace detail {
Chris@102: 
Chris@102: BOOST_FORCEINLINE BOOST_CONSTEXPR memory_order deduce_failure_order(memory_order order) BOOST_NOEXCEPT
Chris@102: {
Chris@102:     return order == memory_order_acq_rel ? memory_order_acquire : (order == memory_order_release ? memory_order_relaxed : order);
Chris@102: }
Chris@102: 
Chris@102: BOOST_FORCEINLINE BOOST_CONSTEXPR bool cas_failure_order_must_not_be_stronger_than_success_order(memory_order success_order, memory_order failure_order) BOOST_NOEXCEPT
Chris@102: {
Chris@102:     // 15 == (memory_order_seq_cst | memory_order_consume), see memory_order.hpp
Chris@102:     // Given the enum values we can test the strength of memory order requirements with this single condition.
Chris@102:     return (failure_order & 15u) <= (success_order & 15u);
Chris@102: }
Chris@102: 
Chris@102: template< typename T, bool IsInt = boost::is_integral< T >::value >
Chris@102: struct classify
Chris@102: {
Chris@102:     typedef void type;
Chris@102: };
Chris@102: 
Chris@102: template< typename T >
Chris@102: struct classify< T, true > { typedef int type; };
Chris@102: 
Chris@102: template< typename T >
Chris@102: struct classify< T*, false > { typedef void* type; };
Chris@102: 
Chris@102: template< typename T, typename Kind >
Chris@102: class base_atomic;
Chris@102: 
Chris@102: //! Implementation for integers
Chris@102: template< typename T >
Chris@102: class base_atomic< T, int >
Chris@102: {
Chris@102: private:
Chris@102:     typedef T value_type;
Chris@102:     typedef T difference_type;
Chris@102:     typedef atomics::detail::operations< storage_size_of< value_type >::value, boost::is_signed< T >::value > operations;
Chris@102: 
Chris@102: protected:
Chris@102:     typedef value_type value_arg_type;
Chris@102: 
Chris@102: public:
Chris@102:     typedef typename operations::storage_type storage_type;
Chris@102: 
Chris@102: protected:
Chris@102:     storage_type m_storage;
Chris@102: 
Chris@102: public:
Chris@102:     BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
Chris@102:     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {}
Chris@102: 
Chris@102:     BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_consume);
Chris@102:         BOOST_ASSERT(order != memory_order_acquire);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         operations::store(m_storage, static_cast< storage_type >(v), order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_release);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         return static_cast< value_type >(operations::load(m_storage, order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return static_cast< value_type >(operations::fetch_add(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return static_cast< value_type >(operations::fetch_sub(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return static_cast< value_type >(operations::exchange(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = static_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_strong(m_storage, old_value, static_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = static_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = static_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_weak(m_storage, old_value, static_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = static_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_and(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return static_cast< value_type >(operations::fetch_and(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_or(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return static_cast< value_type >(operations::fetch_or(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_xor(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return static_cast< value_type >(operations::fetch_xor(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return operations::is_lock_free(m_storage);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(1);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(1) + 1;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(1);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(1) - 1;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(v) + v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(v) - v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator&=(value_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_and(v) & v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator|=(value_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_or(v) | v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator^=(value_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_xor(v) ^ v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
Chris@102: };
Chris@102: 
Chris@102: //! Implementation for bool
Chris@102: template< >
Chris@102: class base_atomic< bool, int >
Chris@102: {
Chris@102: private:
Chris@102:     typedef bool value_type;
Chris@102:     typedef atomics::detail::operations< 1u, false > operations;
Chris@102: 
Chris@102: protected:
Chris@102:     typedef value_type value_arg_type;
Chris@102: 
Chris@102: public:
Chris@102:     typedef operations::storage_type storage_type;
Chris@102: 
Chris@102: protected:
Chris@102:     storage_type m_storage;
Chris@102: 
Chris@102: public:
Chris@102:     BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
Chris@102:     BOOST_CONSTEXPR explicit base_atomic(value_type v) BOOST_NOEXCEPT : m_storage(v) {}
Chris@102: 
Chris@102:     BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_consume);
Chris@102:         BOOST_ASSERT(order != memory_order_acquire);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         operations::store(m_storage, static_cast< storage_type >(v), order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_release);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         return !!operations::load(m_storage, order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return !!operations::exchange(m_storage, static_cast< storage_type >(v), order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = static_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_strong(m_storage, old_value, static_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = !!old_value;
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = static_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_weak(m_storage, old_value, static_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = !!old_value;
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return operations::is_lock_free(m_storage);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
Chris@102: };
Chris@102: 
Chris@102: 
Chris@102: //! Implementation for user-defined types, such as structs and enums
Chris@102: template< typename T >
Chris@102: class base_atomic< T, void >
Chris@102: {
Chris@102: private:
Chris@102:     typedef T value_type;
Chris@102:     typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
Chris@102: 
Chris@102: protected:
Chris@102:     typedef value_type const& value_arg_type;
Chris@102: 
Chris@102: public:
Chris@102:     typedef typename operations::storage_type storage_type;
Chris@102: 
Chris@102: protected:
Chris@102:     storage_type m_storage;
Chris@102: 
Chris@102: public:
Chris@102:     BOOST_FORCEINLINE explicit base_atomic(value_type const& v = value_type()) BOOST_NOEXCEPT : m_storage(atomics::detail::memcpy_cast< storage_type >(v))
Chris@102:     {
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_consume);
Chris@102:         BOOST_ASSERT(order != memory_order_acquire);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         operations::store(m_storage, atomics::detail::memcpy_cast< storage_type >(v), order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_release);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         return atomics::detail::memcpy_cast< value_type >(operations::load(m_storage, order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::memcpy_cast< value_type >(operations::exchange(m_storage, atomics::detail::memcpy_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = atomics::detail::memcpy_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_strong(m_storage, old_value, atomics::detail::memcpy_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = atomics::detail::memcpy_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = atomics::detail::memcpy_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_weak(m_storage, old_value, atomics::detail::memcpy_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = atomics::detail::memcpy_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return operations::is_lock_free(m_storage);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
Chris@102: };
Chris@102: 
Chris@102: 
Chris@102: //! Implementation for pointers
Chris@102: template< typename T >
Chris@102: class base_atomic< T*, void* >
Chris@102: {
Chris@102: private:
Chris@102:     typedef T* value_type;
Chris@102:     typedef std::ptrdiff_t difference_type;
Chris@102:     typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
Chris@102: 
Chris@102: protected:
Chris@102:     typedef value_type value_arg_type;
Chris@102: 
Chris@102: public:
Chris@102:     typedef typename operations::storage_type storage_type;
Chris@102: 
Chris@102: protected:
Chris@102:     storage_type m_storage;
Chris@102: 
Chris@102: public:
Chris@102:     BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
Chris@102:     BOOST_FORCEINLINE explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : m_storage(atomics::detail::union_cast< storage_type >(v))
Chris@102:     {
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_consume);
Chris@102:         BOOST_ASSERT(order != memory_order_acquire);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         operations::store(m_storage, atomics::detail::union_cast< storage_type >(v), order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_release);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         return atomics::detail::union_cast< value_type >(operations::load(m_storage, order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::union_cast< value_type >(operations::fetch_add(m_storage, static_cast< storage_type >(v * sizeof(T)), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::union_cast< value_type >(operations::fetch_sub(m_storage, static_cast< storage_type >(v * sizeof(T)), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::union_cast< value_type >(operations::exchange(m_storage, atomics::detail::union_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = atomics::detail::union_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_strong(m_storage, old_value, atomics::detail::union_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = atomics::detail::union_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = atomics::detail::union_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_weak(m_storage, old_value, atomics::detail::union_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = atomics::detail::union_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return operations::is_lock_free(m_storage);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(1);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(1) + 1;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(1);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(1) - 1;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(v) + v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(v) - v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
Chris@102: };
Chris@102: 
Chris@102: 
Chris@102: //! Implementation for void pointers
Chris@102: template< >
Chris@102: class base_atomic< void*, void* >
Chris@102: {
Chris@102: private:
Chris@102:     typedef void* value_type;
Chris@102:     typedef std::ptrdiff_t difference_type;
Chris@102:     typedef atomics::detail::operations< storage_size_of< value_type >::value, false > operations;
Chris@102: 
Chris@102: protected:
Chris@102:     typedef value_type value_arg_type;
Chris@102: 
Chris@102: public:
Chris@102:     typedef operations::storage_type storage_type;
Chris@102: 
Chris@102: protected:
Chris@102:     storage_type m_storage;
Chris@102: 
Chris@102: public:
Chris@102:     BOOST_DEFAULTED_FUNCTION(base_atomic(), {})
Chris@102:     BOOST_FORCEINLINE explicit base_atomic(value_type const& v) BOOST_NOEXCEPT : m_storage(atomics::detail::union_cast< storage_type >(v))
Chris@102:     {
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE void store(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_consume);
Chris@102:         BOOST_ASSERT(order != memory_order_acquire);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         operations::store(m_storage, atomics::detail::union_cast< storage_type >(v), order);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type load(memory_order order = memory_order_seq_cst) const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(order != memory_order_release);
Chris@102:         BOOST_ASSERT(order != memory_order_acq_rel);
Chris@102: 
Chris@102:         return atomics::detail::union_cast< value_type >(operations::load(m_storage, order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_add(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::union_cast< value_type >(operations::fetch_add(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type fetch_sub(difference_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::union_cast< value_type >(operations::fetch_sub(m_storage, static_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type exchange(value_type v, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return atomics::detail::union_cast< value_type >(operations::exchange(m_storage, atomics::detail::union_cast< storage_type >(v), order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = atomics::detail::union_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_strong(m_storage, old_value, atomics::detail::union_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = atomics::detail::union_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_strong(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_strong(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order success_order, memory_order failure_order) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         BOOST_ASSERT(failure_order != memory_order_release);
Chris@102:         BOOST_ASSERT(failure_order != memory_order_acq_rel);
Chris@102:         BOOST_ASSERT(cas_failure_order_must_not_be_stronger_than_success_order(success_order, failure_order));
Chris@102: 
Chris@102:         storage_type old_value = atomics::detail::union_cast< storage_type >(expected);
Chris@102:         const bool res = operations::compare_exchange_weak(m_storage, old_value, atomics::detail::union_cast< storage_type >(desired), success_order, failure_order);
Chris@102:         expected = atomics::detail::union_cast< value_type >(old_value);
Chris@102:         return res;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool compare_exchange_weak(value_type& expected, value_type desired, memory_order order = memory_order_seq_cst) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return compare_exchange_weak(expected, desired, order, atomics::detail::deduce_failure_order(order));
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE bool is_lock_free() const volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return operations::is_lock_free(m_storage);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator++(int) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_add(1);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator++() volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return (char*)fetch_add(1) + 1;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator--(int) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return fetch_sub(1);
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator--() volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return (char*)fetch_sub(1) - 1;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator+=(difference_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return (char*)fetch_add(v) + v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator-=(difference_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return (char*)fetch_sub(v) - v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic(base_atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(base_atomic& operator=(base_atomic const&))
Chris@102: };
Chris@102: 
Chris@102: } // namespace detail
Chris@102: 
Chris@102: template< typename T >
Chris@102: class atomic :
Chris@102:     public atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type >
Chris@102: {
Chris@102: private:
Chris@102:     typedef T value_type;
Chris@102:     typedef atomics::detail::base_atomic< T, typename atomics::detail::classify< T >::type > base_type;
Chris@102:     typedef typename base_type::value_arg_type value_arg_type;
Chris@102: 
Chris@102: public:
Chris@102:     typedef typename base_type::storage_type storage_type;
Chris@102: 
Chris@102: public:
Chris@102:     BOOST_DEFAULTED_FUNCTION(atomic(), BOOST_NOEXCEPT {})
Chris@102: 
Chris@102:     // NOTE: The constructor is made explicit because gcc 4.7 complains that
Chris@102:     //       operator=(value_arg_type) is considered ambiguous with operator=(atomic const&)
Chris@102:     //       in assignment expressions, even though conversion to atomic<> is less preferred
Chris@102:     //       than conversion to value_arg_type.
Chris@102:     BOOST_FORCEINLINE explicit BOOST_CONSTEXPR atomic(value_arg_type v) BOOST_NOEXCEPT : base_type(v) {}
Chris@102: 
Chris@102:     BOOST_FORCEINLINE value_type operator= (value_arg_type v) volatile BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         this->store(v);
Chris@102:         return v;
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE operator value_type() volatile const BOOST_NOEXCEPT
Chris@102:     {
Chris@102:         return this->load();
Chris@102:     }
Chris@102: 
Chris@102:     BOOST_FORCEINLINE storage_type& storage() BOOST_NOEXCEPT { return this->m_storage; }
Chris@102:     BOOST_FORCEINLINE storage_type volatile& storage() volatile BOOST_NOEXCEPT { return this->m_storage; }
Chris@102:     BOOST_FORCEINLINE storage_type const& storage() const BOOST_NOEXCEPT { return this->m_storage; }
Chris@102:     BOOST_FORCEINLINE storage_type const volatile& storage() const volatile BOOST_NOEXCEPT { return this->m_storage; }
Chris@102: 
Chris@102:     BOOST_DELETED_FUNCTION(atomic(atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&))
Chris@102:     BOOST_DELETED_FUNCTION(atomic& operator= (atomic const&) volatile)
Chris@102: };
Chris@102: 
Chris@102: typedef atomic< char > atomic_char;
Chris@102: typedef atomic< unsigned char > atomic_uchar;
Chris@102: typedef atomic< signed char > atomic_schar;
Chris@102: typedef atomic< uint8_t > atomic_uint8_t;
Chris@102: typedef atomic< int8_t > atomic_int8_t;
Chris@102: typedef atomic< unsigned short > atomic_ushort;
Chris@102: typedef atomic< short > atomic_short;
Chris@102: typedef atomic< uint16_t > atomic_uint16_t;
Chris@102: typedef atomic< int16_t > atomic_int16_t;
Chris@102: typedef atomic< unsigned int > atomic_uint;
Chris@102: typedef atomic< int > atomic_int;
Chris@102: typedef atomic< uint32_t > atomic_uint32_t;
Chris@102: typedef atomic< int32_t > atomic_int32_t;
Chris@102: typedef atomic< unsigned long > atomic_ulong;
Chris@102: typedef atomic< long > atomic_long;
Chris@102: typedef atomic< uint64_t > atomic_uint64_t;
Chris@102: typedef atomic< int64_t > atomic_int64_t;
Chris@102: #ifdef BOOST_HAS_LONG_LONG
Chris@102: typedef atomic< boost::ulong_long_type > atomic_ullong;
Chris@102: typedef atomic< boost::long_long_type > atomic_llong;
Chris@102: #endif
Chris@102: typedef atomic< void* > atomic_address;
Chris@102: typedef atomic< bool > atomic_bool;
Chris@102: typedef atomic< wchar_t > atomic_wchar_t;
Chris@102: #if !defined(BOOST_NO_CXX11_CHAR16_T)
Chris@102: typedef atomic< char16_t > atomic_char16_t;
Chris@102: #endif
Chris@102: #if !defined(BOOST_NO_CXX11_CHAR32_T)
Chris@102: typedef atomic< char32_t > atomic_char32_t;
Chris@102: #endif
Chris@102: 
Chris@102: typedef atomic< int_least8_t > atomic_int_least8_t;
Chris@102: typedef atomic< uint_least8_t > atomic_uint_least8_t;
Chris@102: typedef atomic< int_least16_t > atomic_int_least16_t;
Chris@102: typedef atomic< uint_least16_t > atomic_uint_least16_t;
Chris@102: typedef atomic< int_least32_t > atomic_int_least32_t;
Chris@102: typedef atomic< uint_least32_t > atomic_uint_least32_t;
Chris@102: typedef atomic< int_least64_t > atomic_int_least64_t;
Chris@102: typedef atomic< uint_least64_t > atomic_uint_least64_t;
Chris@102: typedef atomic< int_fast8_t > atomic_int_fast8_t;
Chris@102: typedef atomic< uint_fast8_t > atomic_uint_fast8_t;
Chris@102: typedef atomic< int_fast16_t > atomic_int_fast16_t;
Chris@102: typedef atomic< uint_fast16_t > atomic_uint_fast16_t;
Chris@102: typedef atomic< int_fast32_t > atomic_int_fast32_t;
Chris@102: typedef atomic< uint_fast32_t > atomic_uint_fast32_t;
Chris@102: typedef atomic< int_fast64_t > atomic_int_fast64_t;
Chris@102: typedef atomic< uint_fast64_t > atomic_uint_fast64_t;
Chris@102: typedef atomic< intmax_t > atomic_intmax_t;
Chris@102: typedef atomic< uintmax_t > atomic_uintmax_t;
Chris@102: 
Chris@102: typedef atomic< std::size_t > atomic_size_t;
Chris@102: typedef atomic< std::ptrdiff_t > atomic_ptrdiff_t;
Chris@102: 
Chris@102: #if defined(BOOST_HAS_INTPTR_T)
Chris@102: typedef atomic< intptr_t > atomic_intptr_t;
Chris@102: typedef atomic< uintptr_t > atomic_uintptr_t;
Chris@102: #endif
Chris@102: 
Chris@102: } // namespace atomics
Chris@102: } // namespace boost
Chris@102: 
Chris@102: #if defined(BOOST_MSVC)
Chris@102: #pragma warning(pop)
Chris@102: #endif
Chris@102: 
Chris@102: #endif // BOOST_ATOMIC_DETAIL_ATOMIC_TEMPLATE_HPP_INCLUDED_