Thread.hpp

 
//
//  Copyright Phoenix Contact GmbH & Co. KG
//
#pragma once
#include "Arp/System/Core/Arp.h"
#include "Arp/System/Core/PimplPtr.hxx"
#include "Arp/System/Core/delegate.hxx"
#include "Arp/System/Commons/Threading/ThreadSettings.hpp"
#include "Arp/System/Commons/Threading/ThreadState.hpp"
 
#include "Arp/System/Commons/Logging.h"
#include "Arp/System/Commons/Threading/AutoResetEvent.hpp"
#include "Arp/System/Commons/Threading/ManualResetEvent.hpp"
#include "Arp/System/Commons/Threading/Semaphore.hpp"
#include "Arp/System/Commons/Threading/Mutex.hpp"
#include <atomic>
 
namespace Arp::System::Commons::Threading
{
 
class ARP_CXX_SYMBOL_EXPORT Thread
{
public: // usings
    using ThreadStartFunction = void (*)(void*);
 
    using ThreadStartDelegate = delegate<void(void*)>;
 
    static const 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);
 
    // canonical construction/destruction/assignment
 
    Thread(const Thread& arg) = delete;
 
    Thread(Thread&& arg)noexcept;
 
    Thread& operator=(const Thread& arg) = delete;
 
    Thread& operator=(Thread&& arg)noexcept;
 
    ~Thread(void);
 
public: // static operations
 
    static void Sleep(uint64 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);
 
public: // Impl forward declaration
    class Impl;
 
public: // internal operations
    Impl& GetImpl(void);
    const Impl& GetImpl(void)const;
 
private: // Impl usings
    using Pimpl = PimplPtr<Impl>;
 
private: // Impl fields
    Pimpl   pimpl;
};
 
//inline methods of class Thread
template<class TInstance, class TFunction>
inline Thread::Thread(TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(ThreadSettings(""), (ThreadStartDelegate)make_delegate(&instance, fn), pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(ThreadSettings(""), (ThreadStartDelegate)make_delegate(&instance, fn), pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(TInstance* pInstance, TFunction fn, void* pStartParam)
    : Thread(ThreadSettings(""), (ThreadStartDelegate)make_delegate(pInstance, fn), pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const TInstance* pInstance, TFunction fn, void* pStartParam)
    : Thread(ThreadSettings(""), (ThreadStartDelegate)make_delegate(pInstance, fn), pStartParam)
{
}
 
inline Thread::Thread(ThreadStartDelegate&& threadStart, void* pStartParam)
    : Thread(ThreadSettings(""), std::move(threadStart), pStartParam)
{
}
 
inline Thread::Thread(ThreadStartFunction threadStart, void* pStartParam)
    : Thread(ThreadSettings(""), threadStart, pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(settings, (ThreadStartDelegate)make_delegate(&instance, fn), pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, const TInstance& instance, TFunction fn, void* pStartParam)
    : Thread(settings, (ThreadStartDelegate)make_delegate(&instance, fn), pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, TInstance* pInstance, TFunction fn, void* pStartParam)
    : Thread(settings, (ThreadStartDelegate)make_delegate(pInstance, fn), pStartParam)
{
}
 
template<class TInstance, class TFunction>
inline Thread::Thread(const ThreadSettings& settings, const TInstance* pInstance, TFunction fn, void* pStartParam)
    : Thread(settings, (ThreadStartDelegate)make_delegate(pInstance, fn), pStartParam)
{
}
 
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)
{
}
 
} // end of namespace Arp::System::Commons::Threading