AConditionVariable.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2024 Alex2772 and Contributors
 *
 * SPDX-License-Identifier: MPL-2.0
 *
 * This Source Code Form is subject to the terms of the Mozilla Public
 * License, v. 2.0. If a copy of the MPL was not distributed with this
 * file, You can obtain one at http://mozilla.org/MPL/2.0/.
 */
 
#pragma once
#include <condition_variable>
#include "AThread.h"
#include "AUI/Performance/APerformanceSection.h"
 
class AConditionVariable
{
private:
    std::condition_variable_any mImpl;
 
    struct WaitHelper {
        WaitHelper(AConditionVariable& var) {
            auto thread = AThread::current();
            std::unique_lock lock(thread->mCurrentCV.mutex);
            AThread::interruptionPoint();
            thread->mCurrentCV.cv = &var;
        }
        ~WaitHelper() noexcept(false) {
            auto thread = AThread::current();
            std::unique_lock lock(thread->mCurrentCV.mutex);
            thread->mCurrentCV.cv = nullptr;
        }
    };
 
    template<typename Predicate>
    struct PredicateHelper {
        Predicate predicate;
        _<AAbstractThread> thread;
 
        PredicateHelper(Predicate predicate) : predicate(std::move(predicate)), thread(AThread::current()) {}
        bool operator()() noexcept {
            if (thread->isInterrupted()) return true;
            return predicate();
        }
    };
 
public:
    void notify_all() noexcept { mImpl.notify_all(); }
 
    void notify_one() noexcept { mImpl.notify_one(); }
 
    template<typename Lock>
    void wait(Lock& lock) {
        APerformanceSection section("Conditional Variable");
        {
            WaitHelper w(*this);
            mImpl.wait(lock);
        }
        AThread::interruptionPoint();
    }
 
    template<typename Lock, typename Predicate>
    void wait(Lock& lock, Predicate&& predicate) {
        APerformanceSection section("Conditional Variable");
        {
            WaitHelper w(*this);
            mImpl.wait(lock, PredicateHelper(std::forward<Predicate>(predicate)));
        }
        AThread::interruptionPoint();
    }
 
    template<typename Lock, typename Duration>
    void wait_for(Lock& lock, Duration duration) {
        APerformanceSection section("Conditional Variable");
        {
            WaitHelper w(*this);
            mImpl.wait_for(lock, duration);
        }
        AThread::interruptionPoint();
    }
 
    template<typename Lock, typename Duration, typename Predicate>
    void wait_for(Lock& lock, Duration duration, Predicate&& predicate) {
        APerformanceSection section("Conditional Variable");
        {
            WaitHelper w(*this);
            mImpl.wait_for(lock, duration, PredicateHelper(std::forward<Predicate>(predicate)));
        }
        AThread::interruptionPoint();
    }
 
    template<typename Lock, typename Timepoint>
    void wait_until(Lock& lock, Timepoint timepoint) {
        APerformanceSection section("Conditional Variable");
        {
            WaitHelper w(*this);
            mImpl.wait_until(lock, timepoint);
        }
        AThread::interruptionPoint();
    }
 
    template<typename Lock, typename Duration, typename Predicate>
    void wait_until(Lock& lock, Duration duration, Predicate&& predicate) {
        APerformanceSection section("Conditional Variable");
        {
            WaitHelper w(*this);
            mImpl.wait_until(lock, duration, PredicateHelper(std::forward<Predicate>(predicate)));
        }
        AThread::interruptionPoint();
    }
};