thread_std_thread.h

#include <iostream>
#include "common_std_thread.h"
 
namespace cgv {
    namespace os {
 
 
thread::thread()
{ 
    thread_ptr = 0; 
    stop_request = false;
    running = false;
    delete_after_termination = false;
}
 
void thread::start(bool _delete_after_termination)
{
    if(!running) {
        delete_after_termination = _delete_after_termination;
        stop_request=false;
        std::thread*& std_thread_ptr = reinterpret_cast<std::thread*&>(thread_ptr);
        running = true;
        std_thread_ptr = new std::thread(&cgv::os::thread::execute_s, this);
    }
}
 
void thread::wait_for_signal(condition_mutex& cm)
{
    Condition& c = *((Condition*&) cm.pcond);
    c.cv.wait(c.ul);
}
 
bool thread::wait_for_signal_or_timeout(condition_mutex& cm, unsigned millisec)
{
    Condition& c = *((Condition*&) cm.pcond);
    std::chrono::milliseconds dura(millisec);
    return c.cv.wait_for(c.ul, dura) == std::cv_status::no_timeout;
}
 
void thread::wait_for_signal_with_lock(condition_mutex& cm)
{
    cm.lock(); 
    wait_for_signal(cm); 
    cm.unlock();
}
 
bool thread::wait_for_signal_or_timeout_with_lock(condition_mutex& cm, unsigned millisec)
{
    cm.lock(); 
    bool res =  wait_for_signal_or_timeout(cm, millisec); 
    cm.unlock();
    return res;
}
 
void* thread::execute_s(void* args)
{
    thread* t = (thread*)args;
    t->execute(); 
    if (t->delete_after_termination) {
        std::thread*& std_thread_ptr = reinterpret_cast<std::thread*&>(t->thread_ptr);
        std_thread_ptr->detach();
        std_thread_ptr = 0;
        delete t;
    }
    return NULL; 
}
 
 
void thread::execute()
{
    run();
    running = false; 
}
 
void thread::wait(unsigned millisec)
{
    std::chrono::milliseconds dura(millisec);
    std::this_thread::sleep_for(dura);
}
 
void thread::stop()
{
    if(running) {
        stop_request=true;
        std::thread* std_thread_ptr = reinterpret_cast<std::thread*>(thread_ptr);
        std_thread_ptr->join();
        stop_request=false;
    }
}
 
void thread::kill()
{
    if (running) {
        std::thread*& std_thread_ptr = reinterpret_cast<std::thread*&>(thread_ptr);
        std_thread_ptr->detach();
        delete std_thread_ptr;
        std_thread_ptr = 0;
        stop_request=false;
        running=false;
    }
}
 
void thread::wait_for_completion()
{
    if (running) {
        std::thread& t = *((std::thread*&) thread_ptr);
        t.join();
    }
}
 
thread::~thread()
{
    if(running)
        kill();
    if (thread_ptr) {
        std::thread*& std_thread_ptr = reinterpret_cast<std::thread*&>(thread_ptr);
        if (std_thread_ptr->joinable())
            std_thread_ptr->detach();
        delete std_thread_ptr;
        std_thread_ptr = 0;
    }
}
 
thread_id_type thread::get_current_thread_id()
{
    std::thread::id id = std::this_thread::get_id();
    return (long long&) id;
}
 
thread_id_type thread::get_id() const
{
    std::thread* std_thread_ptr = reinterpret_cast<std::thread*>(thread_ptr);
    std::thread::id id = std_thread_ptr->get_id();
    return (long long&) id;
}
 
class function_thread : public thread
{
protected:
    void (*func)(thread_id_type);
public:
    function_thread(void (*_func)(thread_id_type)) 
    {
        func = _func;
    }
    void run()
    {
        func(get_id());
    }
};
 
thread* start_in_thread(void (*func)(thread_id_type), bool _delete_after_termination)
{
    thread* ft = new function_thread(func);
    ft->start(_delete_after_termination);
    return ft;
}
 
    }
}