WorkerThread.hpp

 
//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Commons/Threading/Thread.hpp"
 
namespace Arp { namespace System { namespace Commons { namespace Threading
{
 
class WorkerThread
{
public: // typedefs
    typedef delegate<void(void)>    WorkDelegate;
 
public: // construction/destruction
 
    template<class TInstance, class TFunction>
    WorkerThread(TInstance& instance, TFunction fn, int idleTime, const char* threadName);
 
    template<class TInstance, class TFunction>
    WorkerThread(const TInstance& instance, TFunction fn, int idleTime, const char* threadName);
 
    template<class TInstance, class TFunction>
    WorkerThread(TInstance* pInstance, TFunction fn, int idleTime, const char* threadName);
 
    template<class TInstance, class TFunction>
    WorkerThread(const TInstance* pInstance, TFunction fn, int idleTime, const char* threadName);
 
    template<class TInstance, class TFunction>
    WorkerThread(ThreadSettings& settings, TInstance& instance, TFunction fn, int idleTime);
 
    template<class TInstance, class TFunction>
    WorkerThread(ThreadSettings& settings, const TInstance& instance, TFunction fn, int idleTime);
 
    template<class TInstance, class TFunction>
    WorkerThread(ThreadSettings& settings, TInstance* pInstance, TFunction fn, int idleTime);
 
    template<class TInstance, class TFunction>
    WorkerThread(ThreadSettings& settings, const TInstance* pInstance, TFunction fn, int idleTime);
 
    explicit WorkerThread(WorkDelegate&& loopDelegate, int idleTime, const char* threadName);
 
    WorkerThread(ThreadSettings& settings, WorkDelegate&& loopDelegate, int idleTime);
 
    ~WorkerThread(void) = default;
 
public: // setter/getter operations
 
    bool    IsRunning(void)const;
 
public: // operations
    void Start(void);
 
    void Stop(void);
 
private: // static methods
    static void RunInternal(void* pParam);
 
private: // fields
    Thread            thread;
    WorkDelegate      work;
    std::atomic<bool> stopWorking{false};
    std::atomic<bool> isStarted{false};
    int               idleTime = 1;
};
 
// inline methods of class WorkerThread
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(TInstance& instance, TFunction fn, int idleTime, const char* threadName)
    : WorkerThread(&instance, fn, idleTime, threadName)
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(const TInstance& instance, TFunction fn, int idleTime, const char* threadName)
    : WorkerThread(&instance, fn, idleTime, threadName)
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(TInstance* pInstance, TFunction fn, int idleTime, const char* threadName)
    : thread(ThreadSettings(threadName), &WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTime)
    , work(make_delegate(pInstance, fn))
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(const TInstance* pInstance, TFunction fn, int idleTime, const char* threadName)
    : thread(ThreadSettings(threadName), &WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTime)
    , work(make_delegate(pInstance, fn))
{
}
 
inline WorkerThread::WorkerThread(WorkDelegate&& workDelegate, int idleTime, const char* threadName)
    : thread(ThreadSettings(threadName), &WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTime)
    , work(workDelegate)
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(ThreadSettings& settings, TInstance& instance, TFunction fn, int idleTimeArg)
    : WorkerThread(settings, &instance, fn, idleTime)
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(ThreadSettings& settings, const TInstance& instance, TFunction fn, int idleTimeArg)
    : WorkerThread(settings, &instance, fn, idleTime)
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(ThreadSettings& settings, TInstance* pInstance, TFunction fn, int idleTimeArg)
    : thread(settings, &WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTimeArg)
    , work(make_delegate(pInstance, fn))
{
}
 
template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(ThreadSettings& settings, const TInstance* pInstance, TFunction fn, int idleTimeArg)
    : thread(settings, &WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTimeArg)
    , work(make_delegate(pInstance, fn))
{
}
 
inline WorkerThread::WorkerThread(ThreadSettings& settings, WorkDelegate&& workDelegate, int idleTimeArg)
    : thread(settings, &WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTimeArg)
    , work(workDelegate)
{
}
 
inline bool WorkerThread::IsRunning(void)const
{
    return this->thread.IsRunning();
}
 
}}}} // end of namespace Arp::System::Commons::Threading