sync_primitives.h

Go to the documentation of this file.

// BSD 3-Clause License
// Copyright (c) 2024, 🍀☀🌕🌥 🌊
// See the LICENSE file in the project root for full license information.
 
#pragma once
 
#include <mutex>
#include <condition_variable>
#include <atomic>
#include <chrono>
#include <memory>
 
namespace kcenon::thread::sync {
    template<typename Mutex>
    class scoped_lock_guard {
    public:
        explicit scoped_lock_guard(Mutex& mutex) 
            : mutex_(mutex), locked_(true) {
            mutex_.lock();
        }
 
        template<typename Rep, typename Period>
        scoped_lock_guard(Mutex& mutex, const std::chrono::duration<Rep, Period>& timeout)
            : mutex_(mutex), locked_(false) {
            if constexpr (std::is_same_v<Mutex, std::timed_mutex> || 
                         std::is_same_v<Mutex, std::recursive_timed_mutex>) {
                locked_ = mutex_.try_lock_for(timeout);
            } else {
                // Fallback for mutexes without timeout support
                locked_ = mutex_.try_lock();
            }
        }
 
        ~scoped_lock_guard() {
            if (locked_) {
                mutex_.unlock();
            }
        }
 
        // Non-copyable and non-movable
        scoped_lock_guard(const scoped_lock_guard&) = delete;
        scoped_lock_guard& operator=(const scoped_lock_guard&) = delete;
        scoped_lock_guard(scoped_lock_guard&&) = delete;
        scoped_lock_guard& operator=(scoped_lock_guard&&) = delete;
 
        [[nodiscard]] bool owns_lock() const noexcept {
            return locked_;
        }
 
        void unlock() {
            if (locked_) {
                mutex_.unlock();
                locked_ = false;
            }
        }
 
    private:
        Mutex& mutex_;
        bool locked_;
    };
 
    class condition_variable_wrapper {
    public:
        condition_variable_wrapper() = default;
        ~condition_variable_wrapper() = default;
 
        // Non-copyable but movable
        condition_variable_wrapper(const condition_variable_wrapper&) = delete;
        condition_variable_wrapper& operator=(const condition_variable_wrapper&) = delete;
        condition_variable_wrapper(condition_variable_wrapper&&) = default;
        condition_variable_wrapper& operator=(condition_variable_wrapper&&) = default;
 
        template<typename Lock>
        void wait(Lock& lock) {
            cv_.wait(lock);
        }
 
        template<typename Lock, typename Predicate>
        void wait(Lock& lock, Predicate predicate) {
            cv_.wait(lock, predicate);
        }
 
        template<typename Lock, typename Rep, typename Period>
        bool wait_for(Lock& lock, const std::chrono::duration<Rep, Period>& timeout) {
            return cv_.wait_for(lock, timeout) == std::cv_status::no_timeout;
        }
 
        template<typename Lock, typename Rep, typename Period, typename Predicate>
        bool wait_for(Lock& lock, const std::chrono::duration<Rep, Period>& timeout, Predicate predicate) {
            return cv_.wait_for(lock, timeout, predicate);
        }
 
        void notify_one() noexcept {
            cv_.notify_one();
        }
 
        void notify_all() noexcept {
            cv_.notify_all();
        }
 
    private:
        std::condition_variable cv_;
    };
 
    class atomic_flag_wrapper {
    public:
        atomic_flag_wrapper() noexcept : flag_(ATOMIC_FLAG_INIT) {}
        ~atomic_flag_wrapper() = default;
 
        // Non-copyable but movable
        atomic_flag_wrapper(const atomic_flag_wrapper&) = delete;
        atomic_flag_wrapper& operator=(const atomic_flag_wrapper&) = delete;
        atomic_flag_wrapper(atomic_flag_wrapper&&) = default;
        atomic_flag_wrapper& operator=(atomic_flag_wrapper&&) = default;
 
        bool test_and_set(std::memory_order order = std::memory_order_acq_rel) noexcept {
            return flag_.test_and_set(order);
        }
 
        void clear(std::memory_order order = std::memory_order_release) noexcept {
            flag_.clear(order);
        }
 
        bool test(std::memory_order order = std::memory_order_acquire) const noexcept {
            return flag_.test(order);
        }
 
        void wait(bool expected, std::memory_order order = std::memory_order_acquire) const noexcept {
            flag_.wait(expected, order);
        }
 
        void notify_one() noexcept {
            flag_.notify_one();
        }
 
        void notify_all() noexcept {
            flag_.notify_all();
        }
 
    private:
        std::atomic_flag flag_;
    };
 
    class shared_mutex_wrapper {
    public:
        shared_mutex_wrapper() = default;
        ~shared_mutex_wrapper() = default;
 
        // Non-copyable and non-movable
        shared_mutex_wrapper(const shared_mutex_wrapper&) = delete;
        shared_mutex_wrapper& operator=(const shared_mutex_wrapper&) = delete;
        shared_mutex_wrapper(shared_mutex_wrapper&&) = delete;
        shared_mutex_wrapper& operator=(shared_mutex_wrapper&&) = delete;
 
        void lock() {
            mutex_.lock();
        }
 
        bool try_lock() {
            return mutex_.try_lock();
        }
 
        void unlock() {
            mutex_.unlock();
        }
 
        void lock_shared() {
            mutex_.lock_shared();
        }
 
        bool try_lock_shared() {
            return mutex_.try_lock_shared();
        }
 
        void unlock_shared() {
            mutex_.unlock_shared();
        }
 
    private:
        std::shared_mutex mutex_;
    };
 
    // Convenience type aliases
    using unique_lock = std::unique_lock<std::mutex>;
    using shared_lock = std::shared_lock<shared_mutex_wrapper>;
    using scoped_mutex_lock = scoped_lock_guard<std::mutex>;
    using scoped_shared_mutex_lock = scoped_lock_guard<shared_mutex_wrapper>;
}