Thread.hpp

//
//  Copyright PHOENIX CONTACT Electronics GmbH
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/delegate.hxx"
#include "Arp/System/Commons/Threading/ThreadSettings.hpp"
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Threading/AutoResetEvent.hpp"
#include "Arp/System/Commons/Threading/ThreadState.hpp"
#include "Arp/System/Commons/Threading/Semaphore.hpp"
 
#include <atomic>
 
// forwards
namespace Arp { namespace System { namespace Ve
{
class IThreadService;
}}}
 
namespace Arp { namespace System { namespace Commons { namespace Threading
{
 
// forwards
class ThreadBinaryCompatibilityExtensions;
 
// forwards
class AutoResetEvent2;
 
class Thread : private Loggable<Thread>
{
private: // friends
    friend class AutoResetEvent;
    friend class AutoResetEvent2;
 
public: // typedefs/usings
    typedef void (*ThreadStartFunction)(void*);
 
    typedef delegate<void(void*)>   ThreadStartDelegate;
 
    static const std::size_t CpuAffinityAll;
 
public: // construction/destruction
 
    template<class TInstance, class TFunction>
    ARP_DEPRECATED("Use constructor with ThreadSettings instead. Supply at least a thread name!")
    Thread(TInstance& instance, TFunction fn, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    ARP_DEPRECATED("Use constructor with ThreadSettings instead. Supply at least a thread name!")
    Thread(const TInstance& instance, TFunction fn, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    ARP_DEPRECATED("Use constructor with ThreadSettings instead. Supply at least a thread name!")
    Thread(TInstance* pInstance, TFunction fn, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    ARP_DEPRECATED("Use constructor with ThreadSettings instead. Supply at least a thread name!")
    Thread(const TInstance* pInstance, TFunction fn, void* pStartParam = nullptr);
 
    ARP_DEPRECATED("Use constructor with ThreadSettings instead. Supply at least a thread name!")
    explicit Thread(ThreadStartDelegate&& threadStart, void* pStartParam = nullptr);
 
    ARP_DEPRECATED("Use constructor with ThreadSettings instead. Supply at least a thread name!")
    Thread(ThreadStartFunction threadStart, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    Thread(const ThreadSettings& settings, TInstance& instance, TFunction fn, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    Thread(const ThreadSettings& settings, const TInstance& instance, TFunction fn, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    Thread(const ThreadSettings& settings, TInstance* pInstance, TFunction fn, void* pStartParam = nullptr);
 
    template<class TInstance, class TFunction>
    Thread(const ThreadSettings& settings, const TInstance* pInstance, TFunction fn, void* pStartParam = nullptr);
 
    Thread(ThreadSettings& settings, ThreadStartDelegate&& threadStart, void* pStartParam = nullptr);
 
    Thread(ThreadSettings& settings, ThreadStartFunction threadStart, void* pStartParam = nullptr);
 
    Thread(const ThreadSettings& settings, ThreadStartDelegate&& threadStart, void* pStartParam = nullptr);
 
    Thread(const ThreadSettings& settings, ThreadStartFunction threadStart, void* pStartParam = nullptr);
 
    ~Thread(void);
 
public: // static operations
 
    static void Sleep(size_t milliseconds);
 
    static size_t GetCurrentThreadId(void);
 
    static Thread* GetCurrentThread(void);
 
    static void SetAsynchronousCancelability(bool enable);
 
public: // properties/setter/getter
    bool IsRunning(void)const;
 
    void SetCpuAffinity(size_t mask);
 
    size_t GetCpuAffinity(void)const;
 
    void SetPriority(size_t value);
 
    size_t GetPriority(void)const;
 
    ARP_DEPRECATED("Set thread stack size at the constructor")
    void SetStackSize(size_t value);
 
    size_t GetStackSize(void)const;
 
    void SetName(const String& value);
 
    const String& GetName(void)const;
 
    ThreadState GetState() const;
    bool IsJoinable(void);
 
public: // operations
    void Start(void);
 
    void Join(void);
 
    void Interrupt(void);
 
    void Terminate(void);
 
private: // typedefs/usings
    using IThreadService = Arp::System::Ve::IThreadService;
 
private: // static methods
    static void* RunInternal(void* pParam);
    static void CheckInterruptOfCurrentThread(void);
    static void SetStateOfCurrentThread(ThreadState state);
    static String CreateDefaultThreadName(void);
 
private: // methods
    void    CreateThreadInternal(void);
    void    CreateThreadInternal(const ThreadSettings& parameter);
    void    RunThread(ThreadBinaryCompatibilityExtensions* pBinCompat);
 
private: // deleted methods
    Thread(const Thread& arg) = delete;
    Thread& operator=(const Thread& arg) = delete;
 
private: // fields
    ThreadStartDelegate         threadStart;
    void*                       pStartParam;
    ThreadBinaryCompatibilityExtensions* pBinaryCompatibilityExtensions;
    AutoResetEvent              exitEvent;
    std::atomic<ThreadState>    state;
    std::atomic<bool>           interrupting;
 
private: // static fields
    static thread_local Thread* pCurrentThread;
};
 
// inline methods of class Thread
template<class TInstance, class TFunction>
inline Thread::Thread(TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(&instance, fn, pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(&instance, fn, pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(TInstance* pInstance, TFunction fn, void* pStartParam)
    : threadStart(make_delegate(pInstance, fn))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal();
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const TInstance* pInstance, TFunction fn, void* pStartParam)
    : threadStart(make_delegate(pInstance, fn))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal();
}
 
inline Thread::Thread(ThreadStartDelegate&& threadStart, void* pStartParam)
    : threadStart(std::move(threadStart))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal();
}
 
inline Thread::Thread(ThreadStartFunction threadStart, void* pStartParam)
    : threadStart(make_delegate(threadStart))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal();
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(settings, &instance, fn, pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, const TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(settings, &instance, fn, pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, TInstance* pInstance, TFunction fn, void* pStartParam)
    : threadStart(make_delegate(pInstance, fn))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal(settings);
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, const TInstance* pInstance, TFunction fn, void* pStartParam)
    : threadStart(make_delegate(pInstance, fn))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal(settings);
}
 
inline Thread::Thread(ThreadSettings& settings, ThreadStartDelegate&& threadStart, void* pStartParam)
    : Thread((const ThreadSettings&)settings, std::move(threadStart), pStartParam)
{
}
 
inline Thread::Thread(ThreadSettings& settings, ThreadStartFunction threadStart, void* pStartParam)
    : Thread((const ThreadSettings&)settings, threadStart, pStartParam)
{
}
 
inline Thread::Thread(const ThreadSettings& settings, ThreadStartDelegate&& threadStart, void* pStartParam)
    : threadStart(std::move(threadStart))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal(settings);
}
 
inline Thread::Thread(const ThreadSettings& settings, ThreadStartFunction threadStart, void* pStartParam)
    : threadStart(make_delegate(threadStart))
    , pStartParam(pStartParam)
    , pBinaryCompatibilityExtensions(nullptr)
    , state(ThreadState::Stopped)
    , interrupting(false)
{
    this->CreateThreadInternal(settings);
}
 
inline bool Thread::IsRunning(void)const
{
    return (this->GetState() == ThreadState::Running);
}
 
inline Thread* Thread::GetCurrentThread(void)
{
    return Thread::pCurrentThread;
}
 
inline void Thread::Interrupt(void)
{
    this->interrupting = true;
}
 
inline ThreadState Thread::GetState(void) const
{
    return this->state.load();
}
 
}}}} // end of namespace Arp::System::Commons::Threading