AThread.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 <thread>
#include <utility>
#include "AUI/Common/ADeque.h"
#include "AMutex.h"
#include "AUI/Common/SharedPtrTypes.h"
#include "AUI/Common/AString.h"
#include "AUI/Util/AMessageQueue.h"
#include <AUI/Platform/AStacktrace.h>
#include <functional>
 
class IEventLoop;
class AString;
class AConditionVariable;

class API_AUI_CORE AAbstractThread
{
    friend class IEventLoop;
    friend class AThread;
    friend class AConditionVariable;
    friend void setupUIThread() noexcept; // OSDesktop.cpp
public:

    typedef std::thread::id id;
 
 
public:
    id getId() const;

    void enqueue(AMessageQueue<>::Message f);
 
    virtual ~AAbstractThread();

    virtual bool isInterrupted();

    virtual void resetInterruptFlag();

    virtual void interrupt();

    IEventLoop* getCurrentEventLoop() const {
        return mCurrentEventLoop;
    }
 

    template <class Callable>
    inline void operator<<(Callable fun) {
        enqueue(fun);
    }

    template <class Callable>
    inline void operator*(Callable fun)
    {
        enqueue(fun);
    }
 
    [[nodiscard]]
    const AString& threadName() const noexcept {
        return mThreadName;
    }

    [[nodiscard]]
    AStacktrace threadStacktrace() const;
        
    [[nodiscard]]
    bool messageQueueEmpty() noexcept;
 
protected:
    id mId;
 
    AString mThreadName;
 
    AMessageQueue<> mMessageQueue;
 
    AAbstractThread(const id& id) noexcept;
    void updateThreadName() noexcept;
    virtual void processMessagesImpl();
 
 
private:

    struct {
        AMutex mutex;
        AConditionVariable* cv = nullptr;
    } mCurrentCV;

    IEventLoop* mCurrentEventLoop = nullptr;

    AMutex mEventLoopLock;
 
    AAbstractThread() = default;
 

    static _<AAbstractThread>& threadStorage();
};
 
#include "AUI/Common/AObject.h"

class API_AUI_CORE AThread : public AAbstractThread, public AObject
{
public:
    class Interrupted
    {
    public:
        void needRethrow() const noexcept {
            AThread::current()->interrupt();
        }
    };
 
private:
    std::thread* mThread = nullptr;
 

    std::function<void()> mFunctor;

    std::atomic_bool mInterrupted = false;
 
public:
 
    AThread(std::function<void()> functor);
 
    virtual ~AThread();
 
    void detach();

    void start();
 

    static void sleep(std::chrono::milliseconds duration);

    static _<AAbstractThread> current();

    static void interruptionPoint();
 
 

    static void setName(AString name) noexcept {
        auto cur = current();
        cur->mThreadName = std::move(name);
        cur->updateThreadName();
    }

    static void processMessages() {
        current()->processMessagesImpl();
    }
 
    bool isInterrupted() override;
    void resetInterruptFlag() override;
    void interrupt() override;

    void join();
 
};
 
#include "AConditionVariable.h"