atomic_shared_ptr.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2021-2025, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <atomic>
#include <memory>
 
namespace kcenon::thread {
 
template<typename T>
class atomic_shared_ptr {
public:
    atomic_shared_ptr() noexcept = default;
 
    explicit atomic_shared_ptr(std::shared_ptr<T> ptr) noexcept
        : ptr_(std::move(ptr)) {}
 
    atomic_shared_ptr(const atomic_shared_ptr& other)
        : ptr_(other.load()) {}
 
    atomic_shared_ptr& operator=(const atomic_shared_ptr& other) {
        if (this != &other) {
            store(other.load());
        }
        return *this;
    }
 
    atomic_shared_ptr(atomic_shared_ptr&& other) noexcept
        : ptr_(other.exchange(nullptr)) {}
 
    atomic_shared_ptr& operator=(atomic_shared_ptr&& other) noexcept {
        if (this != &other) {
            store(other.exchange(nullptr));
        }
        return *this;
    }
 
    atomic_shared_ptr& operator=(std::shared_ptr<T> ptr) noexcept {
        store(std::move(ptr));
        return *this;
    }
 
    void store(std::shared_ptr<T> ptr,
               std::memory_order order = std::memory_order_seq_cst) noexcept {
#if __cpp_lib_atomic_shared_ptr >= 201711L
        ptr_.store(std::move(ptr), order);
#else
        std::atomic_store_explicit(&ptr_, std::move(ptr), order);
#endif
    }
 
    [[nodiscard]] std::shared_ptr<T> load(
        std::memory_order order = std::memory_order_seq_cst) const noexcept {
#if __cpp_lib_atomic_shared_ptr >= 201711L
        return ptr_.load(order);
#else
        return std::atomic_load_explicit(&ptr_, order);
#endif
    }
 
    [[nodiscard]] std::shared_ptr<T> exchange(
        std::shared_ptr<T> ptr,
        std::memory_order order = std::memory_order_seq_cst) noexcept {
#if __cpp_lib_atomic_shared_ptr >= 201711L
        return ptr_.exchange(std::move(ptr), order);
#else
        return std::atomic_exchange_explicit(&ptr_, std::move(ptr), order);
#endif
    }
 
    bool compare_exchange_weak(
        std::shared_ptr<T>& expected,
        std::shared_ptr<T> desired,
        std::memory_order success = std::memory_order_seq_cst,
        std::memory_order failure = std::memory_order_seq_cst) noexcept {
#if __cpp_lib_atomic_shared_ptr >= 201711L
        return ptr_.compare_exchange_weak(expected, std::move(desired), success, failure);
#else
        return std::atomic_compare_exchange_weak_explicit(
            &ptr_, &expected, std::move(desired), success, failure);
#endif
    }
 
    bool compare_exchange_strong(
        std::shared_ptr<T>& expected,
        std::shared_ptr<T> desired,
        std::memory_order success = std::memory_order_seq_cst,
        std::memory_order failure = std::memory_order_seq_cst) noexcept {
#if __cpp_lib_atomic_shared_ptr >= 201711L
        return ptr_.compare_exchange_strong(expected, std::move(desired), success, failure);
#else
        return std::atomic_compare_exchange_strong_explicit(
            &ptr_, &expected, std::move(desired), success, failure);
#endif
    }
 
    [[nodiscard]] operator std::shared_ptr<T>() const noexcept {
        return load();
    }
 
    [[nodiscard]] T& operator*() const noexcept {
        return *load();
    }
 
    [[nodiscard]] T* operator->() const noexcept {
        return load().get();
    }
 
    [[nodiscard]] explicit operator bool() const noexcept {
        return load() != nullptr;
    }
 
    [[nodiscard]] T* get_unsafe() const noexcept {
        return load().get();
    }
 
    void reset() noexcept {
        store(nullptr);
    }
 
    void reset(T* ptr) noexcept {
        store(std::shared_ptr<T>(ptr));
    }
 
private:
#if __cpp_lib_atomic_shared_ptr >= 201711L
    std::atomic<std::shared_ptr<T>> ptr_{nullptr};
#else
    std::shared_ptr<T> ptr_{nullptr};
#endif
};
 
template<typename T, typename... Args>
[[nodiscard]] atomic_shared_ptr<T> make_atomic_shared(Args&&... args) {
    return atomic_shared_ptr<T>(std::make_shared<T>(std::forward<Args>(args)...));
}
 
}  // namespace kcenon::thread