AThread.h

/*
 * AUI Framework - Declarative UI toolkit for modern C++20
 * Copyright (C) 2020-2025 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);
 
   [[nodiscard]]
   const AMessageQueue<>& messageQueue() const {
       return mMessageQueue;
   }
 
   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();

   [[nodiscard]]
   static const _<AAbstractThread>& main() noexcept;

   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"

© 2025 AUI Framework Contributors. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. All trademarks are property of their respective owners.