Threading.hpp

Go to the documentation of this file.

//
//  CeresEngine - A game development framework
//
//  Created by Rogiel Sulzbach.
//  Copyright (c) 2018-2022 Rogiel Sulzbach. All rights reserved.
//
 
#pragma once
 
#include "CeresEngine/Macros.hpp"
 
#include <mutex>
#include <shared_mutex>
#include <thread>
#include <condition_variable>
 
#if defined(__cpp_lib_barrier)
#include <barrier>
#endif
 
#if defined(__cpp_lib_latch)
#include <latch>
#endif
 
#if defined(__cpp_lib_semaphore)
#include <semaphore>
#endif
 
#if __has_include(<stop_token>)
#include <stop_token>
#endif
 
namespace CeresEngine {
 
    using Thread = std::thread;
 
    using Mutex = std::mutex;
 
    using TimedMutex = std::timed_mutex;
 
    using RecursiveMutex = std::recursive_mutex;
 
    using RecursiveTimedMutex = std::recursive_timed_mutex;
 
    using SharedMutex = std::shared_mutex;
 
    using SharedTimedMutex = std::shared_timed_mutex;
 
    struct NullLockable final {
        inline constexpr void lock() noexcept {}
        inline constexpr bool try_lock() noexcept { return true; }
        inline constexpr void unlock() noexcept {}
        template<typename Duration> inline constexpr bool try_lock_for(Duration) noexcept { return try_lock(); }
        template<typename TimeLimit> inline constexpr bool try_lock_until(TimeLimit) noexcept { return try_lock(); }
    };
 
    using ConditionVariable = std::condition_variable;
 
    template<typename... Mutexes> class Lock final : public std::scoped_lock<Mutexes...> {
        using super = std::scoped_lock<Mutexes...>;
 
    public:
        using super::super;
    };
 
    template<typename Mutex> class UniqueLock final : public std::unique_lock<Mutex> {
        using super = std::unique_lock<Mutex>;
 
    public:
        using super::super;
    };
 
    template<typename Mutex> class SharedLock final : public std::shared_lock<Mutex> {
        using super = std::shared_lock<Mutex>;
 
    public:
        using super::super;
    };
 
    template<typename Lock> struct Relocker {
        Lock& mLock;
 
        explicit Relocker(Lock& lock) : mLock(lock) { lock.unlock(); }
 
        Relocker(const Relocker&) = delete;
        Relocker(Relocker&& other) noexcept = delete;
 
        Relocker& operator=(const Relocker&) = delete;
        Relocker& operator=(Relocker&& other) noexcept = delete;
 
        ~Relocker() {
            if(!mLock.owns_lock()) {
                mLock.lock();
            }
        }
 
        void lock() {
            if(!mLock.owns_lock()) {
                mLock.lock();
            }
        }
    };
 
#if defined(__cpp_lib_semaphore)
    template<std::ptrdiff_t LeastMaxValue = std::counting_semaphore<>::max()> using CountingSemaphore = std::counting_semaphore<LeastMaxValue>;
 
    using BinarySemaphore = std::binary_semaphore;
#endif
 
#if defined(__cpp_lib_latch)
    using Latch = std::latch;
#endif
 
#if defined(__cpp_lib_barrier)
    template<typename CompletionFunction = std::barrier<>::arrival_token> using Barrier = std::barrier<CompletionFunction>;
#endif
 
#if __has_include(<stop_token>)
    // using StopToken = std::stop_token;
 
    // using StopSource = std::stop_source;
 
    // template<typename Callback> using StopCallback = std::stop_callback<Callback>;
#endif
 
    template<typename T, typename Mutex> class LockedObject;
 
    template<typename T>
    concept CLockedObject = requires(T object) {
        std::is_same_v<std::remove_cv_t<T>, LockedObject<typename T::ValueType, typename T::MutexType>>;
    };
 
    template<typename T, typename Mutex = Mutex> class LockedObject {
        template<typename, typename> friend class LockedObject;
 
    public:
        using ValueType = T;
 
        using MutexType = Mutex;
 
    private:
        T mValue;
 
        mutable Mutex mMutex;
 
    public:
        template<typename... Args>
        CE_EXPLICIT(false) LockedObject(Args&&... args) // NOLINT
                : mValue(std::forward<Args>(args)...) {}
 
        template<typename OtherMutex>
        LockedObject(const LockedObject<T, OtherMutex>& other) // NOLINT
                : mValue(other.copy()) {}
 
        template<typename OtherMutex> LockedObject& operator=(const LockedObject<T, OtherMutex>& other) {
            lock([](T& self, const T& otherObject) { self->mValue = otherObject->mValue; }, *this, other);
            return *this;
        }
 
        LockedObject& operator=(const T& other) {
            with([&other](T& value) mutable { value->mValue = std::move(other); });
            return *this;
        }
 
        template<typename OtherMutex> LockedObject& operator=(LockedObject<T, OtherMutex>&& other) noexcept {
            lock([](T& self, T& otherObject) { self->mValue = std::move(otherObject->mValue); }, *this, other);
            return *this;
        }
 
        LockedObject& operator=(T&& other) noexcept {
            with([&other](T& value) mutable { value.mValue = std::move(other); });
            return *this;
        }
 
    public:
        template<CLockedObject... Ts, typename Func> friend decltype(auto) lock(Func&& func, Ts&... objects);
 
        template<typename Func> decltype(auto) with(Func&& func) {
            UniqueLock<Mutex> lock(mMutex);
            return func(mValue);
        }
 
        template<typename Func> decltype(auto) operator|(Func&& func) { return with(std::forward<Func>(func)); }
 
        template<typename Func> decltype(auto) operator()(Func&& func) { return with(std::forward<Func>(func)); }
 
        template<typename U> class TemporaryLock {
            LockedObject<T, Mutex>& mOwner;
 
            UniqueLock<Mutex> mLock;
 
        public:
            explicit TemporaryLock(LockedObject<T, Mutex>& owner) noexcept : mOwner(owner), mLock(owner.mMutex) {}
 
            U* operator->() const noexcept { return &mOwner.mValue; }
 
            U& operator*() const noexcept { return mOwner.mValue; }
 
            explicit operator bool() const noexcept { return mLock.owns_lock(); }
        };
 
        auto lock() { return TemporaryLock<T>(*this); }
 
        auto operator->() { return lock(); }
 
        auto operator*() { return lock(); }
 
        template<typename Func> decltype(auto) with(Func&& func) const {
            SharedLock<Mutex> lock(mMutex);
            return func(mValue);
        }
 
        template<typename Func> decltype(auto) operator|(Func&& func) const { return with(std::forward<Func>(func)); }
 
        template<typename Func> decltype(auto) operator()(Func&& func) const { return with(std::forward<Func>(func)); }
 
        auto lock() const {
            return TemporaryLock<const T>(*const_cast<LockedObject*>(this));
        }
 
        auto operator->() const { return lock(); }
 
        auto operator*() const { return lock(); }
 
        T copy() const {
            return with([](const T& value) { return T(value); });
        }
    };
 
    template<CLockedObject... Ts, typename Func> decltype(auto) lock(Func&& func, Ts&... objects) {
        Lock<typename Ts::MutexType...> lock(objects.mMutex...);
        return func(objects.mValue...);
    }
 
    template<typename T, typename Mutex, typename Func> decltype(auto) lock(LockedObject<T, Mutex>& object, Func&& func) {
        return object.with(std::forward<Func>(func));
    }
 
    template<typename T, typename Mutex, typename Func> decltype(auto) lock(const LockedObject<T, Mutex>& object, Func&& func) {
        return object.with(std::forward<Func>(func));
    }
 
} // namespace CeresEngine