atomic.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
 
#ifndef FENNEC_THREADING_ATOMIC_H
#define FENNEC_THREADING_ATOMIC_H
 
#include <fennec/threading/detail/_atomic.h>
 
#include <fennec/lang/type_traits.h>
 
namespace fennec
{
 
using ::memory_order;
using ::memory_order_relaxed;
using ::memory_order_consume;
using ::memory_order_acquire;
using ::memory_order_release;
using ::memory_order_acq_rel;
using ::memory_order_seq_cst;
 
template<typename T>
struct atomic {
 
// Assertions ==========================================================================================================
public:
    static_assert(is_integral_v<T>, "fennec::atomic not defined for the provided type. Default implementation"
                                    "only supports integral types.");
 
 
 
// Definitions =========================================================================================================
public:
    using value_t = T;
 
 
 
// Constructors ========================================================================================================
 
    constexpr atomic() noexcept
        : _value(static_cast<T>(0)) {
    }
 
    constexpr atomic(const T value) noexcept
        : _value(value) {
    }
 
    atomic(const atomic&) = delete;
 
 
 
// Assignment ==========================================================================================================
 
    atomic& operator=(const atomic&)          = delete;
    atomic& operator=(const atomic&) volatile = delete;
 
    T operator=(const T x) noexcept {
        this->store(x);
        return x;
    }
 
    T operator=(const T x) volatile noexcept {
        this->store(x);
        return x;
    }
 
 
 
// Modifiers ===========================================================================================================
 
    void store(const T x, memory_order order = memory_order_seq_cst) noexcept {
        ::atomic_store_explicit(&_value, x, order);
    }
 
    void store(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        ::atomic_store_explicit(&_value, x, order);
    }
 
 
    T load(memory_order order = memory_order_seq_cst) const noexcept {
        return ::atomic_load_explicit(&_value, order);
    }
 
    T load(memory_order order = memory_order_seq_cst) const volatile noexcept {
        return ::atomic_load_explicit(&_value, order);
    }
 
 
    operator T() const noexcept {
        return load();
    }
 
    operator T() const volatile noexcept {
        return load();
    }
 
 
    T exchange(const T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_exchange_explicit(&_value, x, order);
    }
 
    T exchange(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_exchange_explicit(&_value, x, order);
    }
 
 
    bool compare_exchange_weak(T& exp, T x, memory_order succ, memory_order fail) noexcept {
        return ::atomic_compare_exchange_weak_explicit(&_value, &exp, x, succ, fail);
    }
 
    bool compare_exchange_weak(T& exp, T x, memory_order succ, memory_order fail) volatile noexcept {
        return ::atomic_compare_exchange_weak_explicit(&_value, &exp, x, succ, fail);
    }
 
    bool compare_exchange_weak(T& exp, T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_compare_exchange_weak_explicit(&_value, &exp, x, order, order);
    }
 
    bool compare_exchange_weak(T& exp, T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_compare_exchange_weak_explicit(&_value, &exp, x, order, order);
    }
 
 
    bool compare_exchange_strong(T& exp, T x, memory_order succ, memory_order fail) noexcept {
        return ::atomic_compare_exchange_strong_explicit(&_value, &exp, x, succ, fail);
    }
 
    bool compare_exchange_strong(T& exp, T x, memory_order succ, memory_order fail) volatile noexcept {
        return ::atomic_compare_exchange_strong_explicit(&_value, &exp, x, succ, fail);
    }
 
    bool compare_exchange_strong(T& exp, T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_compare_exchange_strong_explicit(&_value, &exp, x, order, order);
    }
 
    bool compare_exchange_strong(T& exp, T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_compare_exchange_strong_explicit(&_value, &exp, x, order, order);
    }
 
 
 
// Operations ==========================================================================================================
 
    T fetch_add(const T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_fetch_add_explicit(&_value, x, order);
    }
 
    T fetch_add(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_fetch_add_explicit(&_value, x, order);
    }
 
    T operator+=(const T x) noexcept {
        return this->fetch_add(x) + x;
    }
 
    T operator+=(const T x) volatile noexcept {
        return this->fetch_add(x) + x;
    }
 
 
 
    T operator++() noexcept {
        return this->fetch_add(1) + 1;
    }
 
    T operator++() volatile noexcept {
        return this->fetch_add(1) + 1;
    }
 
    T operator++(int) noexcept {
        return this->fetch_add(1);
    }
 
    T operator++(int) volatile noexcept {
        return this->fetch_add(1);
    }
 
 
    
    T fetch_sub(const T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_fetch_sub_explicit(&_value, x, order);
    }
 
    T fetch_sub(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_fetch_sub_explicit(&_value, x, order);
    }
 
    T operator-=(const T x) noexcept {
        return this->fetch_sub(x) - x;
    }
 
    T operator-=(const T x) volatile noexcept {
        return this->fetch_sub(x) - x;
    }
 
 
 
    T operator--() noexcept {
        return this->fetch_sub(1) - 1;
    }
 
    T operator--() volatile noexcept {
        return this->fetch_sub(1) - 1;
    }
 
    T operator--(int) noexcept {
        return this->fetch_sub(1);
    }
 
    T operator--(int) volatile noexcept {
        return this->fetch_sub(1);
    }
 
 
 
// Bit Operations ======================================================================================================
 
    T fetch_and(const T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_fetch_and_explicit(&_value, x, order);
    }
 
    T fetch_and(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_fetch_and_explicit(&_value, x, order);
    }
 
    T operator&=(const T x) noexcept {
        return this->fetch_and(x) & x;
    }
 
    T operator&=(const T x) volatile noexcept {
        return this->fetch_and(x) & x;
    }
 
 
 
    T fetch_or(const T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_fetch_or_explicit(&_value, x, order);
    }
 
    T fetch_or(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_fetch_or_explicit(&_value, x, order);
    }
 
    T operator|=(const T x) noexcept {
        return this->fetch_or(x) & x;
    }
 
    T operator|=(const T x) volatile noexcept {
        return this->fetch_or(x) & x;
    }
 
 
 
    T fetch_xor(const T x, memory_order order = memory_order_seq_cst) noexcept {
        return ::atomic_fetch_xor_explicit(&_value, x, order);
    }
 
    T fetch_xor(const T x, memory_order order = memory_order_seq_cst) volatile noexcept {
        return ::atomic_fetch_xor_explicit(&_value, x, order);
    }
 
    T operator^=(const T x) noexcept {
        return this->fetch_xor(x) & x;
    }
 
    T operator^=(const T x) volatile noexcept {
        return this->fetch_xor(x) & x;
    }
 
 
 
private:
    _Atomic T _value;
};
 
}
 
#endif // FENNEC_THREADING_ATOMIC_H