Acore::Thread Class Reference

#include "Threading.h"

Public Member Functions
	Thread ()
	Thread (Runnable *instance)
	~Thread ()
bool	wait ()
void	destroy ()
void	setPriority (Priority type)

Static Public Member Functions
static void	Sleep (unsigned long msecs)
static std::thread::id	currentId ()

Private Member Functions
	Thread (const Thread &)
Thread &	operator= (const Thread &)

Static Private Member Functions
static void	ThreadTask (void *param)

Private Attributes
Runnable *const	m_task
std::thread::id	m_iThreadId
std::thread	m_ThreadImp

Detailed Description

Constructor & Destructor Documentation

Thread() [1/3]

Thread::Thread

(

)

               : m_task(nullptr), m_iThreadId(), m_ThreadImp()
{
}

Thread() [2/3]

Thread::Thread ( Runnable *  instance )

explicit

                                 : m_task(instance), m_ThreadImp(&Thread::ThreadTask, (void*)m_task)
{
    m_iThreadId = m_ThreadImp.get_id();
 
    // register reference to m_task to prevent it deeltion until destructor
    if (m_task)
    {
        m_task->incReference();
    }
}

References Acore::Runnable::incReference(), m_iThreadId, m_task, and m_ThreadImp.

~Thread()

Thread::~Thread

(

)

{
    // Wait();
 
    // deleted runnable object (if no other references)
    if (m_task)
    {
        m_task->decReference();
    }
}

References Acore::Runnable::decReference(), and m_task.

Thread() [3/3]

Acore::Thread::Thread ( const Thread &  )

private

Member Function Documentation

currentId()

std::thread::id Thread::currentId ( )

static

{
    return std::this_thread::get_id();
}

destroy()

void Thread::destroy

(

)

{
    if (m_iThreadId == std::thread::id() || !m_task)
    {
        return;
    }
 
    // FIXME: We need to make sure that all threads can be trusted to
    // halt execution on their own as this is not an interrupt
    m_ThreadImp.join();
    m_iThreadId = std::thread::id();
}

References m_iThreadId, m_task, and m_ThreadImp.

operator=()

Thread & Acore::Thread::operator= ( const Thread &  )

private

setPriority()

void Thread::setPriority

(

Priority

type

)

{
#ifdef WIN32
    std::thread::native_handle_type handle = m_ThreadImp.native_handle();
#endif
 
    bool _ok = true;
 
    switch (priority)
    {
#ifdef WIN32
        case Priority_Realtime:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_TIME_CRITICAL);
            break;
        case Priority_Highest:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_HIGHEST);
            break;
        case Priority_High:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_ABOVE_NORMAL);
            break;
        case Priority_Normal:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_NORMAL);
            break;
        case Priority_Low:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_BELOW_NORMAL);
            break;
        case Priority_Lowest:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_LOWEST);
            break;
        case Priority_Idle:
            _ok = SetThreadPriority(handle, THREAD_PRIORITY_IDLE);
            break;
#endif
        default:
            break;
    }
 
    // remove this ASSERT in case you don't want to know is thread priority change was successful or not
    ASSERT(_ok);
}

References ASSERT, m_ThreadImp, Acore::Priority_High, Acore::Priority_Highest, Acore::Priority_Idle, Acore::Priority_Low, Acore::Priority_Lowest, Acore::Priority_Normal, and Acore::Priority_Realtime.

Sleep()

void Thread::Sleep ( unsigned long  msecs )

static

{
    std::this_thread::sleep_for(std::chrono::milliseconds(msecs));
}

ThreadTask()

void Thread::ThreadTask ( void *  param )

staticprivate

{
    Runnable* _task = (Runnable*)param;
    _task->run();
}

References Acore::Runnable::run().

wait()

bool Thread::wait

(

)

{
    if (m_iThreadId == std::thread::id() || !m_task)
    {
        return false;
    }
 
    bool res = true;
 
    try
    {
        m_ThreadImp.join();
    }
    catch (std::system_error&)
    {
        res = false;
    }
 
    m_iThreadId = std::thread::id();
 
    return res;
}

References m_iThreadId, m_task, and m_ThreadImp.

Member Data Documentation

m_iThreadId

std::thread::id Acore::Thread::m_iThreadId

private

Referenced by destroy(), Thread(), and wait().

m_task

Runnable* const Acore::Thread::m_task

private

Referenced by destroy(), Thread(), wait(), and ~Thread().

m_ThreadImp

std::thread Acore::Thread::m_ThreadImp

private

Referenced by destroy(), setPriority(), Thread(), and wait().