call_once.hpp

浏览该文件的文档.

#ifndef NEFORCE_CORE_ASYNC_CALL_ONCE_HPP__
#define NEFORCE_CORE_ASYNC_CALL_ONCE_HPP__

 
#include "NeForce/core/async/atomic_futex.hpp"
#include "NeForce/core/functional/invoke.hpp"
NEFORCE_BEGIN_NAMESPACE__



class once_flag {
private:
    atomic_futex<> state_{0};
 
    template <typename Callable, typename... Args>
    friend void call_once(once_flag& flag, Callable&& func, Args&&... args);
 
public:
    constexpr once_flag() noexcept = default;
    once_flag(const once_flag&) = delete;
    once_flag& operator=(const once_flag&) = delete;
    once_flag(once_flag&&) = delete;
    once_flag& operator=(once_flag&&) = delete;
};

template <typename Callable, typename... Args>
void call_once(once_flag& flag, Callable&& func, Args&&... args) {
    if (flag.state_.load(memory_order_acquire) == 2) {
        return;
    }
 
    while (true) {
        const uint32_t state = flag.state_.load(memory_order_acquire);
        if (state == 2) {
            return;
        }
 
        if (state == 0) {
            uint32_t expected = 0;
            if (flag.state_.compare_exchange_strong(expected, 1, memory_order_acquire, memory_order_relaxed)) {
                try {
                    _NEFORCE invoke<Callable, Args...>(_NEFORCE forward<Callable>(func),
                                                       _NEFORCE forward<Args>(args)...);
                    flag.state_.store_notify_all(2, memory_order_release);
                    return;
                } catch (...) {
                    flag.state_.store_notify_all(0, memory_order_release);
                    throw;
                }
            }
            continue;
        }
 
        if (flag.state_.load_when_not_equal(1, memory_order_acquire) == 2) {
            return;
        }
    }
}
 // CallOnce
 // AsyncComponents
 
NEFORCE_END_NAMESPACE__
#endif // NEFORCE_CORE_ASYNC_CALL_ONCE_HPP__