atomic.hpp

Go to the documentation of this file.

// Copyright (c) 2024 by ekxide IO GmbH. All rights reserved.
// Copyright (c) 2025 Contributors to the Eclipse Foundation
//
// See the NOTICE file(s) distributed with this work for additional
// information regarding copyright ownership.
//
// This program and the accompanying materials are made available under the
// terms of the Apache Software License 2.0 which is available at
// https://www.apache.org/licenses/LICENSE-2.0, or the MIT license
// which is available at https://opensource.org/licenses/MIT.
//
// SPDX-License-Identifier: Apache-2.0 OR MIT
 
#ifndef IOX2_BB_ATOMIC_HPP
#define IOX2_BB_ATOMIC_HPP
 
#include <atomic>
#include <cstdlib>
#include <iostream>
#include <type_traits>
 
namespace iox2 {
namespace legacy {
namespace concurrent {
using AtomicFlag = std::atomic_flag;
 
template <typename T>
class Atomic {
  private:
    template <typename U>
    using enable_if_integral_t = std::enable_if_t<std::is_same<T, U>::value && std::is_integral<U>::value, T>;
 
    template <typename U>
    using enable_if_pointer_t = std::enable_if_t<std::is_same<T, U>::value && std::is_pointer<U>::value, T>;
 
    template <typename U>
    using enable_if_integral_or_pointer_t =
        std::enable_if_t<std::is_same<T, U>::value && (std::is_integral<U>::value || std::is_pointer<U>::value), T>;
 
  public:
#if __cplusplus >= 201703L
    static_assert(
        std::atomic<T>::is_always_lock_free,
        "The 'iox2::legacy::Atomic' must work across process boundaries and must therefore be always lock-free!");
 
    static constexpr bool is_always_lock_free = std::atomic<T>::is_always_lock_free;
#endif
 
    constexpr Atomic() noexcept
        : m_value { T() } {
#if __cplusplus < 201703L
        if (!std::atomic_is_lock_free(&m_value)) {
            std::cerr << "The 'iox2::legacy::Atomic' must work across process boundaries and must therefore be always "
                         "lock-free!"
                      << std::endl;
            std::abort();
        }
#endif
    }
 
    explicit constexpr Atomic(T value) noexcept
        : m_value { value } {
    }
 
    Atomic(const Atomic& other) = delete;
    Atomic& operator=(const Atomic&) = delete;
 
    Atomic(Atomic&& rhs) noexcept = default;
    Atomic& operator=(Atomic&& rhs) noexcept = default;
 
    ~Atomic() = default;
 
    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature) This mimics the std::atomic copy assignment operator
    T operator=(T value) noexcept {
        m_value = value;
        return value;
    }
 
    // NOLINTNEXTLINE(cppcoreguidelines-c-copy-assignment-signature) This mimics the std::atomic copy assignment operator
    T operator=(T value) volatile noexcept {
        m_value = value;
        return value;
    }
 
    explicit operator T() const noexcept {
        return m_value.operator T();
    }
 
    explicit operator T() const volatile noexcept {
        return m_value.operator T();
    }
 
    bool is_lock_free() const noexcept {
        return m_value.is_lock_free();
    }
 
    bool is_lock_free() const volatile noexcept {
        return m_value.is_lock_free();
    }
 
    void store(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        m_value.store(value, order);
    }
 
    void store(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        m_value.store(value, order);
    }
 
    T load(std::memory_order order = std::memory_order_seq_cst) const noexcept {
        return m_value.load(order);
    }
 
    T load(std::memory_order order = std::memory_order_seq_cst) const volatile noexcept {
        return m_value.load(order);
    }
 
    T exchange(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.exchange(value, order);
    }
 
    T exchange(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.exchange(value, order);
    }
 
    bool compare_exchange_weak(T& expected, T desired, std::memory_order success, std::memory_order failure) noexcept {
        return m_value.compare_exchange_weak(expected, desired, success, failure);
    }
 
    bool compare_exchange_weak(T& expected,
                               T desired,
                               std::memory_order success,
                               std::memory_order failure) volatile noexcept {
        return m_value.compare_exchange_weak(expected, desired, success, failure);
    }
 
    bool compare_exchange_weak(T& expected, T desired, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.compare_exchange_weak(expected, desired, order);
    }
 
    bool compare_exchange_weak(T& expected,
                               T desired,
                               std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.compare_exchange_weak(expected, desired, order);
    }
 
    bool
    compare_exchange_strong(T& expected, T desired, std::memory_order success, std::memory_order failure) noexcept {
        return m_value.compare_exchange_strong(expected, desired, success, failure);
    }
 
    bool compare_exchange_strong(T& expected,
                                 T desired,
                                 std::memory_order success,
                                 std::memory_order failure) volatile noexcept {
        return m_value.compare_exchange_strong(expected, desired, success, failure);
    }
 
    bool compare_exchange_strong(T& expected, T desired, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.compare_exchange_strong(expected, desired, order);
    }
 
    bool compare_exchange_strong(T& expected,
                                 T desired,
                                 std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.compare_exchange_strong(expected, desired, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_add(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_add(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_add(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_add(value, order);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> fetch_add(std::ptrdiff_t value,
                                     std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_add(value, order);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> fetch_add(std::ptrdiff_t value,
                                     std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_add(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_sub(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_sub(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_sub(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_sub(value, order);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> fetch_sub(std::ptrdiff_t value,
                                     std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_sub(value, order);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> fetch_sub(std::ptrdiff_t value,
                                     std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_sub(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator+=(T value) noexcept {
        return m_value.operator+=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator+=(T value) volatile noexcept {
        return m_value.operator+=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator-=(T value) noexcept {
        return m_value.operator-=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator-=(T value) volatile noexcept {
        return m_value.operator-=(value);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> operator+=(std::ptrdiff_t value) noexcept {
        return m_value.operator+=(value);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> operator+=(std::ptrdiff_t value) volatile noexcept {
        return m_value.operator+=(value);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> operator-=(std::ptrdiff_t value) noexcept {
        return m_value.operator-=(value);
    }
 
    template <typename U = T>
    enable_if_pointer_t<U> operator-=(std::ptrdiff_t value) volatile noexcept {
        return m_value.operator-=(value);
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator++() noexcept {
        return m_value.operator++();
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator++() volatile noexcept {
        return m_value.operator++();
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator++(int) noexcept {
        return m_value.operator++(0);
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator++(int) volatile noexcept {
        return m_value.operator++(0);
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator--() noexcept {
        return m_value.operator--();
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator--() volatile noexcept {
        return m_value.operator--();
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator--(int) noexcept {
        return m_value.operator--(0);
    }
 
    template <typename U = T>
    enable_if_integral_or_pointer_t<U> operator--(int) volatile noexcept {
        return m_value.operator--(0);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_and(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_and(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_and(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_and(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_or(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_or(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_or(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_or(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_xor(T value, std::memory_order order = std::memory_order_seq_cst) noexcept {
        return m_value.fetch_xor(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> fetch_xor(T value, std::memory_order order = std::memory_order_seq_cst) volatile noexcept {
        return m_value.fetch_xor(value, order);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator&=(T value) noexcept {
        return m_value.operator&=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator&=(T value) volatile noexcept {
        return m_value.operator&=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator|=(T value) noexcept {
        return m_value.operator|=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator|=(T value) volatile noexcept {
        return m_value.operator|=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator^=(T value) noexcept {
        return m_value.operator^=(value);
    }
 
    template <typename U = T>
    enable_if_integral_t<U> operator^=(T value) volatile noexcept {
        return m_value.operator^=(value);
    }
 
  private:
    std::atomic<T> m_value;
};
} // namespace concurrent
} // namespace legacy
} // namespace iox2
 
#endif // IOX2_BB_ATOMIC_HPP