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(&WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTime)
    , work(make_delegate(pInstance, fn))
{
    this->thread.SetName(threadName);
}

template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(const TInstance* pInstance, TFunction fn, int idleTime, const char* threadName)
    : thread(&WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTime)
    , work(make_delegate(pInstance, fn))
{
    this->thread.SetName(threadName);
}

inline WorkerThread::WorkerThread(WorkDelegate&& workDelegate, int idleTime, const char* threadName)
    : thread(&WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTime)
    , work(workDelegate)
{
    this->thread.SetName(threadName);
}

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(&WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTimeArg)
    , work(make_delegate(pInstance, fn))
{
    this->thread.SetName(settings.Name);
    this->thread.SetCpuAffinity(settings.CpuAffinity);
    this->thread.SetPriority(settings.Priority);
    this->thread.SetStackSize(settings.StackSize);
}

template<class TInstance, class TFunction>
inline WorkerThread::WorkerThread(ThreadSettings& settings, const TInstance* pInstance, TFunction fn, int idleTimeArg)
    : thread(&WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTimeArg)
    , work(make_delegate(pInstance, fn))
{
    this->thread.SetName(settings.Name);
    this->thread.SetCpuAffinity(settings.CpuAffinity);
    this->thread.SetPriority(settings.Priority);
    this->thread.SetStackSize(settings.StackSize);
}

inline WorkerThread::WorkerThread(ThreadSettings& settings, WorkDelegate&& workDelegate, int idleTimeArg)
    : thread(&WorkerThread::RunInternal, (void*)this)
    , idleTime(idleTimeArg)
    , work(workDelegate)
{
    this->thread.SetName(settings.Name);
    this->thread.SetCpuAffinity(settings.CpuAffinity);
    this->thread.SetPriority(settings.Priority);
    this->thread.SetStackSize(settings.StackSize);
}

inline bool WorkerThread::IsRunning(void)const
{
    return this->thread.IsRunning();
}

}}}} // end of namespace Arp::System::Commons::Threading