thread.h

 
#ifndef _aspose_system_threading_thread_h_
#define _aspose_system_threading_thread_h_
 
#include <thread>
#include <mutex>
#include <condition_variable>
 
#include <system/multicast_delegate.h>
#include <system/globalization/culture_info.h>
#include <system/threading/thread_state.h>
 
 
 
namespace System { 
    
    namespace ComponentModel {
        class BackgroundWorker;
    }
 
    namespace Threading {
 
using ParameterizedThreadStart = System::MulticastDelegate<void(System::SharedPtr<System::Object>)>;
using ThreadStart = System::MulticastDelegate<void()>;
 
class ASPOSECPP_SHARED_CLASS Thread final: public System::Object
{
    friend class ThreadPoolImpl;
    friend class System::ComponentModel::BackgroundWorker;
 
public:
    ASPOSECPP_SHARED_API Thread();
    ASPOSECPP_SHARED_API Thread(ThreadStart thread_function);
    ASPOSECPP_SHARED_API Thread(ParameterizedThreadStart thread_function);
 
    ASPOSECPP_SHARED_API Thread & operator = (const Thread &t);
    ASPOSECPP_SHARED_API Thread(Thread &t);
    virtual ASPOSECPP_SHARED_API ~Thread();
 
    ASPOSECPP_SHARED_API SharedPtr<Globalization::CultureInfo> get_CurrentCulture();
    ASPOSECPP_SHARED_API void set_CurrentCulture(const SharedPtr<Globalization::CultureInfo>& ci);
 
    static ASPOSECPP_SHARED_API System::SharedPtr<Thread> get_CurrentThread();
 
    ASPOSECPP_SHARED_API SharedPtr<Globalization::CultureInfo> get_CurrentUICulture();
    ASPOSECPP_SHARED_API void set_CurrentUICulture(const SharedPtr<Globalization::CultureInfo>& ci);
 
    ASPOSECPP_SHARED_API bool get_IsAlive();
    ASPOSECPP_SHARED_API bool get_IsBackground();
    ASPOSECPP_SHARED_API void set_IsBackground(bool is_background);
    ASPOSECPP_SHARED_API bool get_IsThreadPoolThread();
    ASPOSECPP_SHARED_API int get_ManagedThreadId() const;
    ASPOSECPP_SHARED_API System::String get_Name();
    ASPOSECPP_SHARED_API void set_Name(const System::String& name);
 
    ASPOSECPP_SHARED_API ThreadState get_ThreadState();
 
    ASPOSECPP_SHARED_API void Join();
    ASPOSECPP_SHARED_API bool Join(int millisecondsTimeout);
    ASPOSECPP_SHARED_API bool Join(TimeSpan timeout);
    static ASPOSECPP_SHARED_API void Sleep(int millisecondsTimeout);
    static ASPOSECPP_SHARED_API void Sleep(TimeSpan timeout);
    static ASPOSECPP_SHARED_API void SpinWait(int iterations);
 
    ASPOSECPP_SHARED_API void Start();
    ASPOSECPP_SHARED_API void Start(const System::SharedPtr<System::Object>& o);
    ASPOSECPP_SHARED_API void Abort();
    ASPOSECPP_SHARED_API void Interrupt();
    static ASPOSECPP_SHARED_API bool Yield();
 
    static ASPOSECPP_SHARED_API int GetCurrentThreadId();
 
    virtual ASPOSECPP_SHARED_API int GetHashCode() const override;
 
    static ASPOSECPP_SHARED_API void MemoryBarrier();
 
private:
    struct TlsData
    {
        System::String name;
        ThreadState state = Unstarted;
        bool is_backgroung = false;
        bool is_thread_pool_thread = false;
        // Whether the thread is ready
        bool is_ready = false;
        std::timed_mutex m_timed_mutex;
        std::condition_variable m_cv_sleep;
        std::mutex m_mtx_cv_sleep;
        int m_thread_id;
        TlsData();
    };
 
    bool m_is_pts;
    ParameterizedThreadStart m_pts;
    ThreadStart m_ts;
    std::thread m_thread;
    static std::shared_ptr<TlsData>& GetTlsData();
    std::shared_ptr<TlsData> m_data;
 
    static void StartHelper(const SharedPtr<Thread>& thread, const ThreadStart& worker);
 
    static ASPOSECPP_SHARED_API void CheckIsValidTimeout(TimeSpan timeout);
 
    static ASPOSECPP_SHARED_API void InitTlsData();
};
 
}} // namespace System::Threading
 
#endif // _aspose_system_threading_thread_h_