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