atomic_8hpp_source.html

#ifndef NEFORCE_CORE_ASYNC_ATOMIC_HPP__

#define NEFORCE_CORE_ASYNC_ATOMIC_HPP__


#include "NeForce/core/async/atomic_base.hpp"

NEFORCE_BEGIN_NAMESPACE__


template <typename T>


struct atomic {

    using value_type = T;


private:

    static constexpr int min_align = (sizeof(T) & (sizeof(T) - 1)) != 0U || sizeof(T) > 16 ? 0 : sizeof(T);

    static constexpr int align_inner = min_align > alignof(T) ? min_align : alignof(T);


    alignas(align_inner) T value_;


    static_assert(is_trivially_copyable_v<T>, "atomic requires a trivially copyable type");

    static_assert(is_complete_v<T>, "Incomplete or zero-sized types are not supported");

    static_assert(is_copy_constructible_v<T>, "atomic need copy constructible T");

    static_assert(is_move_constructible_v<T>, "atomic need move constructible T");

    static_assert(is_copy_assignable_v<T>, "atomic copy move assignable T");

    static_assert(is_move_assignable_v<T>, "atomic need move assignable T");


public:

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(T value) noexcept :

    value_(value) {}


    operator T() const noexcept { return load(); }


    operator T() const volatile noexcept { return load(); }


    T operator=(T value) noexcept {

        atomic::store(value);

        return value;

    }


    T operator=(T value) volatile noexcept {

        atomic::store(value);

        return value;

    }


    NEFORCE_NODISCARD bool is_lock_free() const noexcept {

        return _NEFORCE is_always_lock_free<sizeof(value_), align_inner>();

    }


    NEFORCE_NODISCARD bool is_lock_free() const volatile noexcept {

        return _NEFORCE is_always_lock_free<sizeof(value_), align_inner>();

    }


    void store(T value, const memory_order mo = memory_order_seq_cst) noexcept {

        _NEFORCE atomic_store_any(_NEFORCE addressof(value_), value, mo);

    }


    void store(T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        _NEFORCE atomic_store_any(_NEFORCE addressof(value_), value, mo);

    }


    T load(const memory_order mo = memory_order_seq_cst) const noexcept {

        return _NEFORCE atomic_load_any(_NEFORCE addressof(value_), mo);

    }


    T load(const memory_order mo = memory_order_seq_cst) const volatile noexcept {

        return _NEFORCE atomic_load_any(_NEFORCE addressof(value_), mo);

    }


    T exchange(T value, const memory_order mo = memory_order_seq_cst) noexcept {

        return _NEFORCE atomic_exchange_any(_NEFORCE addressof(value_), value, mo);

    }


    T exchange(T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return _NEFORCE atomic_exchange_any(_NEFORCE addressof(value_), value, mo);

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order success,

                               const memory_order failure) noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_weak_any(_NEFORCE addressof(value_), &expected, &desired, success, failure);

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order success,

                               const memory_order failure) volatile noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_weak_any(_NEFORCE addressof(value_), &expected, &desired, success, failure);

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order mo = memory_order_seq_cst) noexcept {

        return atomic::compare_exchange_weak(expected, desired, mo, cmpexch_failure_order(mo));

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return atomic::compare_exchange_weak(expected, desired, mo, cmpexch_failure_order(mo));

    }


    bool compare_exchange_strong(T& expected, T desired, const memory_order success,

                                 const memory_order failure) noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_strong_any(_NEFORCE addressof(value_), _NEFORCE addressof(expected),

                                                  _NEFORCE addressof(desired), success, failure);

    }


    bool compare_exchange_strong(T& expected, T desired, const memory_order success,

                                 const memory_order failure) volatile noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_strong_any(_NEFORCE addressof(value_), _NEFORCE addressof(expected),

                                                  _NEFORCE addressof(desired), success, failure);

    }


    bool compare_exchange_strong(T& expected, T value, const memory_order mo = memory_order_seq_cst) noexcept {

        return atomic::compare_exchange_strong(expected, value, mo, cmpexch_failure_order(mo));

    }


    bool compare_exchange_strong(T& expected, T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return atomic::compare_exchange_strong(expected, value, mo, cmpexch_failure_order(mo));

    }


};


template <typename T>


struct atomic<T*> : atomic_base<T*> {

    atomic() noexcept = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    explicit atomic(T* value) noexcept :

    atomic_base<T*>(value) {}


    using atomic_base<T*>::operator=;

};


template <typename T>


struct atomic<T&> : atomic_ref_base<T> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    explicit atomic(T& value) noexcept :

    atomic_ref_base<T>(value) {}


    using atomic_ref_base<T>::operator=;

};


template <>


struct atomic<bool> {

    using value_type = bool;


private:

    atomic_base<bool> base_;


public:

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const bool value) noexcept :

    base_(value) {}


    bool operator=(const bool value) noexcept { return base_.operator=(value); }


    bool operator=(const bool value) volatile noexcept { return base_.operator=(value); }


    operator bool() const noexcept { return base_.load(); }


    operator bool() const volatile noexcept { return base_.load(); }


    NEFORCE_NODISCARD bool is_lock_free() const noexcept { return base_.is_lock_free(); }


    NEFORCE_NODISCARD bool is_lock_free() const volatile noexcept { return base_.is_lock_free(); }


    void store(const bool value, const memory_order mo = memory_order_seq_cst) noexcept { base_.store(value, mo); }


    void store(const bool value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        base_.store(value, mo);

    }


    NEFORCE_NODISCARD bool load(const memory_order mo = memory_order_seq_cst) const noexcept { return base_.load(mo); }


    NEFORCE_NODISCARD bool load(const memory_order mo = memory_order_seq_cst) const volatile noexcept {

        return base_.load(mo);

    }


    bool exchange(const bool value, const memory_order mo = memory_order_seq_cst) noexcept {

        return base_.exchange(value, mo);

    }


    bool exchange(const bool value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return base_.exchange(value, mo);

    }


    bool compare_exchange_weak(bool& value1, const bool value2, const memory_order success,

                               const memory_order failure) noexcept {

        return base_.compare_exchange_weak(value1, value2, success, failure);

    }


    bool compare_exchange_weak(bool& value1, const bool value2, const memory_order success,

                               const memory_order failure) volatile noexcept {

        return base_.compare_exchange_weak(value1, value2, success, failure);

    }


    bool compare_exchange_weak(bool& value1, const bool value2, const memory_order mo = memory_order_seq_cst) noexcept {

        return base_.compare_exchange_weak(value1, value2, mo);

    }


    bool compare_exchange_weak(bool& value1, const bool value2,

                               const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return base_.compare_exchange_weak(value1, value2, mo);

    }


    bool compare_exchange_strong(bool& value1, const bool value2, const memory_order success,

                                 const memory_order failure) noexcept {

        return base_.compare_exchange_strong(value1, value2, success, failure);

    }


    bool compare_exchange_strong(bool& value1, const bool value2, const memory_order success,

                                 const memory_order failure) volatile noexcept {

        return base_.compare_exchange_strong(value1, value2, success, failure);

    }


    bool compare_exchange_strong(bool& value1, const bool value2,

                                 const memory_order mo = memory_order_seq_cst) noexcept {

        return base_.compare_exchange_strong(value1, value2, mo);

    }


    bool compare_exchange_strong(bool& value1, const bool value2,

                                 const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return base_.compare_exchange_strong(value1, value2, mo);

    }


    void wait(const bool old, const memory_order mo = memory_order_seq_cst) const noexcept { base_.wait(old, mo); }


    void notify_one() noexcept { base_.notify_one(); }


    void notify_all() noexcept { base_.notify_all(); }

};


template <>


struct atomic<char> : atomic_base<char> {

    using integral_type = char;

    using base_type = atomic_base<char>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<signed char> : atomic_base<signed char> {

    using integral_type = signed char;

    using base_type = atomic_base<signed char>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned char> : atomic_base<unsigned char> {

    using integral_type = unsigned char;

    using base_type = atomic_base<unsigned char>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<short> : atomic_base<short> {

    using integral_type = short;

    using base_type = atomic_base<short>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned short> : atomic_base<unsigned short> {

    using integral_type = unsigned short;

    using base_type = atomic_base<unsigned short>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<int> : atomic_base<int> {

    using integral_type = int;

    using base_type = atomic_base<int>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned int> : atomic_base<unsigned int> {

    using integral_type = unsigned int;

    using base_type = atomic_base<unsigned int>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<long> : atomic_base<long> {

    using integral_type = long;

    using base_type = atomic_base<long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned long> : atomic_base<unsigned long> {

    using integral_type = unsigned long;

    using base_type = atomic_base<unsigned long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<long long> : atomic_base<long long> {

    using integral_type = long long;

    using base_type = atomic_base<long long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned long long> : atomic_base<unsigned long long> {

    using integral_type = unsigned long long;

    using base_type = atomic_base<unsigned long long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<wchar_t> : atomic_base<wchar_t> {

    using integral_type = wchar_t;

    using base_type = atomic_base<wchar_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


#ifdef NEFORCE_STANDARD_20

template <>


struct atomic<char8_t> : atomic_base<char8_t> {

    using integral_type = char8_t;

    using base_type = atomic_base<char8_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


#endif


template <>


struct atomic<char16_t> : atomic_base<char16_t> {

    using integral_type = char16_t;

    using base_type = atomic_base<char16_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<char32_t> : atomic_base<char32_t> {

    using integral_type = char32_t;

    using base_type = atomic_base<char32_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<float> : atomic_float_base<float> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const float value) noexcept :

    atomic_float_base<float>(value) {}


    using atomic_float_base<float>::operator=;

};


template <>


struct atomic<double> : atomic_float_base<double> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const double value) noexcept :

    atomic_float_base<double>(value) {}


    using atomic_float_base<double>::operator=;

};


template <>


struct atomic<long double> : atomic_float_base<long double> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const long double value) noexcept :

    atomic_float_base<long double>(value) {}


    using atomic_float_base<long double>::operator=;

};


 // AtomicOperations

 // AsyncComponents


NEFORCE_END_NAMESPACE__

#endif // NEFORCE_CORE_ASYNC_ATOMIC_HPP__

atomic_base.hpp
原子操作基本工具

neforce::addressof
constexpr T * addressof(T &x) noexcept
获取对象的地址
定义 type_traits.hpp:3084

neforce::atomic_load_any
remove_volatile_t< T > atomic_load_any(const T *ptr, memory_order mo) noexcept
通用原子加载操作
定义 atomic_base.hpp:1130

neforce::atomic_cmpexch_weak_any
bool atomic_cmpexch_weak_any(volatile T *ptr, remove_volatile_t< T > *expected, remove_volatile_t< T > *desired, const memory_order success, const memory_order failure) noexcept
通用弱比较交换操作
定义 atomic_base.hpp:952

neforce::is_always_lock_free
constexpr bool is_always_lock_free() noexcept
检查是否支持无锁操作
定义 atomic_base.hpp:1254

neforce::atomic_cmpexch_strong_any
bool atomic_cmpexch_strong_any(volatile T *ptr, remove_volatile_t< T > *expected, remove_volatile_t< T > *desired, const memory_order success, const memory_order failure) noexcept
通用强比较交换操作
定义 atomic_base.hpp:1073

neforce::atomic_store_any
void atomic_store_any(T *ptr, remove_volatile_t< T > value, const memory_order mo) noexcept
通用原子存储操作
定义 atomic_base.hpp:1110

neforce::atomic_exchange_any
remove_volatile_t< T > atomic_exchange_any(T *ptr, remove_volatile_t< T > desired, memory_order mo) noexcept
通用原子交换操作
定义 atomic_base.hpp:1158

neforce::cv_status::success
@ success
等待成功
定义 condition_variable.hpp:34

NEFORCE_CONSTEXPR_ASSERT
#define NEFORCE_CONSTEXPR_ASSERT(COND)
编译时常量断言
定义 debug.hpp:47

neforce::memory_order_seq_cst
constexpr auto memory_order_seq_cst
顺序一致性内存顺序常量
定义 memory_order.hpp:183

neforce::cmpexch_failure_order
constexpr memory_order cmpexch_failure_order(const memory_order mo) noexcept
获取原子比较交换操作失败时的内存顺序
定义 memory_order.hpp:273

neforce::memory_order
memory_order
内存顺序
定义 memory_order.hpp:163

neforce::is_valid_cmpexch_failure_order
constexpr bool is_valid_cmpexch_failure_order(const memory_order mo) noexcept
检查比较交换失败内存顺序是否有效
定义 memory_order.hpp:297

neforce::is_move_constructible_v
constexpr bool is_move_constructible_v
is_move_constructible的便捷变量模板
定义 type_traits.hpp:2462

neforce::is_move_assignable_v
constexpr bool is_move_assignable_v
is_move_assignable的便捷变量模板
定义 type_traits.hpp:2522

neforce::is_copy_assignable_v
constexpr bool is_copy_assignable_v
is_copy_assignable的便捷变量模板
定义 type_traits.hpp:2502

neforce::is_trivially_copyable_v
constexpr bool is_trivially_copyable_v
is_trivially_copyable的便捷变量模板
定义 type_traits.hpp:2337

neforce::is_copy_constructible_v
constexpr bool is_copy_constructible_v
is_copy_constructible的便捷变量模板
定义 type_traits.hpp:2392

neforce::atomic< bool >::store
void store(const bool value, const memory_order mo=memory_order_seq_cst) noexcept
原子存储操作
定义 atomic.hpp:351

neforce::atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) noexcept
简化版弱比较交换操作
定义 atomic.hpp:419

neforce::atomic< bool >::operator=
bool operator=(const bool value) noexcept
赋值运算符
定义 atomic.hpp:317

neforce::atomic< bool >::load
bool load(const memory_order mo=memory_order_seq_cst) const noexcept
原子加载操作
定义 atomic.hpp:365

neforce::atomic< bool >::exchange
bool exchange(const bool value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子交换操作
定义 atomic.hpp:387

neforce::atomic< bool >::store
void store(const bool value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子存储操作
定义 atomic.hpp:356

neforce::atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) noexcept
简化版强比较交换操作
定义 atomic.hpp:459

neforce::atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版强比较交换操作
定义 atomic.hpp:467

neforce::atomic< bool >::load
bool load(const memory_order mo=memory_order_seq_cst) const volatile noexcept
volatile版本的原子加载操作
定义 atomic.hpp:370

neforce::atomic< bool >::value_type
bool value_type
值类型
定义 atomic.hpp:291

neforce::atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版弱比较交换操作
定义 atomic.hpp:426

neforce::atomic< bool >::is_lock_free
bool is_lock_free() const noexcept
检查是否支持无锁操作
定义 atomic.hpp:339

neforce::atomic< bool >::notify_one
void notify_one() noexcept
通知一个等待线程
定义 atomic.hpp:482

neforce::atomic< bool >::exchange
bool exchange(const bool value, const memory_order mo=memory_order_seq_cst) noexcept
原子交换操作
定义 atomic.hpp:380

neforce::atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的弱比较交换操作
定义 atomic.hpp:407

neforce::atomic< bool >::operator=
bool operator=(const bool value) volatile noexcept
volatile版本的赋值运算符
定义 atomic.hpp:322

neforce::atomic< bool >::wait
void wait(const bool old, const memory_order mo=memory_order_seq_cst) const noexcept
等待值改变
定义 atomic.hpp:477

neforce::atomic< bool >::notify_all
void notify_all() noexcept
通知所有等待线程
定义 atomic.hpp:487

neforce::atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order success, const memory_order failure) noexcept
强比较交换操作
定义 atomic.hpp:439

neforce::atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order success, const memory_order failure) noexcept
弱比较交换操作
定义 atomic.hpp:399

neforce::atomic< bool >::is_lock_free
bool is_lock_free() const volatile noexcept
volatile版本的检查是否支持无锁操作
定义 atomic.hpp:344

neforce::atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的强比较交换操作
定义 atomic.hpp:447

neforce::atomic_base
原子类型基础模板类
定义 atomic_base.hpp:1451

neforce::atomic_ref_base
原子引用基础模板类
定义 atomic_base.hpp:2654

neforce::atomic::load
T load(const memory_order mo=memory_order_seq_cst) const volatile noexcept
volatile版本的原子加载操作
定义 atomic.hpp:138

neforce::atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order mo=memory_order_seq_cst) noexcept
简化版弱比较交换操作
定义 atomic.hpp:189

neforce::atomic::operator=
T operator=(T value) volatile noexcept
volatile版本的赋值运算符
定义 atomic.hpp:90

neforce::atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T value, const memory_order mo=memory_order_seq_cst) noexcept
简化版强比较交换操作
定义 atomic.hpp:232

neforce::atomic< block * >::load
block * load(const memory_order mo=memory_order_seq_cst) const noexcept
定义 atomic.hpp:131

neforce::atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版弱比较交换操作
定义 atomic.hpp:196

neforce::atomic::store
void store(T value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子存储操作
定义 atomic.hpp:122

neforce::atomic::operator=
T operator=(T value) noexcept
赋值运算符
定义 atomic.hpp:82

neforce::atomic::exchange
T exchange(T value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子交换操作
定义 atomic.hpp:155

neforce::atomic::value_type
T value_type
值类型
定义 atomic.hpp:35

neforce::atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T desired, const memory_order success, const memory_order failure) noexcept
强比较交换操作
定义 atomic.hpp:208

neforce::atomic::is_lock_free
bool is_lock_free() const volatile noexcept
volatile版本的检查是否支持无锁操作
定义 atomic.hpp:106

neforce::atomic::exchange
T exchange(T value, const memory_order mo=memory_order_seq_cst) noexcept
原子交换操作
定义 atomic.hpp:148

neforce::atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order success, const memory_order failure) noexcept
弱比较交换操作
定义 atomic.hpp:167

neforce::atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的弱比较交换操作
定义 atomic.hpp:176

neforce::atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版强比较交换操作
定义 atomic.hpp:239

neforce::atomic::store
void store(T value, const memory_order mo=memory_order_seq_cst) noexcept
原子存储操作
定义 atomic.hpp:115

neforce::atomic::is_lock_free
bool is_lock_free() const noexcept
检查是否支持无锁操作
定义 atomic.hpp:99

neforce::atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T desired, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的强比较交换操作
定义 atomic.hpp:218