mthread.h

Go to the documentation of this file.

#ifndef MYTH_THREAD_H
#define MYTH_THREAD_H
 
#include <climits>
 
#include <QThread>
 
#include "mythbaseexp.h"
#include "mythchrono.h"
 
class MThreadInternal;
class QStringList;
class QRunnable;
class MThread;
 
bool MBASE_PUBLIC is_current_thread(MThread *thread);
bool MBASE_PUBLIC is_current_thread(QThread *thread);
bool MBASE_PUBLIC is_current_thread(MThread &thread);
 
class MBASE_PUBLIC MThread
{
    friend class MThreadInternal;
  public:
    explicit MThread(const QString &objectName);
    explicit MThread(const QString &objectName, QRunnable *runnable);
    virtual ~MThread();
 
    MThread(const MThread &) = delete;            // not copyable
    MThread &operator=(const MThread &) = delete; // not copyable
 
    void RunProlog(void);
    void RunEpilog(void);
 
    QThread *qthread(void);
 
    void setObjectName(const QString &name);
    QString objectName(void) const;
 
    void setPriority(QThread::Priority priority);
    QThread::Priority priority(void) const;
 
    bool isFinished(void) const;
    bool isRunning(void) const;
 
    void setStackSize(uint stackSize);
    uint stackSize(void) const;
 
    void exit(int retcode = 0);
    void start(QThread::Priority p = QThread::InheritPriority);
    void terminate(void);
    void quit(void); 
 
    static void ThreadSetup(const QString& name);
    static void ThreadCleanup(void);
 
  public:
    bool wait(std::chrono::milliseconds time = std::chrono::milliseconds::max());
 
    static void Cleanup(void);
    static void GetAllThreadNames(QStringList &list);
    static void GetAllRunningThreadNames(QStringList &list);
 
  protected:
    virtual void run(void);
    int exec(void);
 
    static void setTerminationEnabled(bool enabled = true);
    static void usleep(std::chrono::microseconds time);
    template<typename R, typename P>
    static typename std::enable_if_t<std::chrono::treat_as_floating_point<R>::value, void>
    usleep(std::chrono::duration<R,P> time) { usleep(duration_cast<std::chrono::microseconds>(time)); };
 
    MThreadInternal *m_thread {nullptr};
    QRunnable *m_runnable     {nullptr};
    bool m_prologExecuted     {true};
    bool m_epilogExecuted     {true};
};
 
#endif // MYTH_THREAD_H