thread_pthread.h

#include "thread.h"
#include <pthread.h>
#include <iostream>
#ifdef _WIN32
#include <concrt.h>
#else
#include <unistd.h>
#endif
 
namespace cgv {
    namespace os {
 
thread::thread()
{ 
    thread_ptr = new pthread_t();   
    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;
        pthread_attr_t attr;
        pthread_attr_init(&attr);
        pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_JOINABLE);
        if(pthread_create((pthread_t*)thread_ptr,&attr,execute_s,this))
            std::cerr << "error: starting thread" <<std::endl;
        pthread_attr_destroy(&attr);
        running=true;
    }
}
 
void thread::wait_for_signal(condition_mutex& cm)
{
    pthread_cond_wait(&(pthread_cond_t&)cm.pcond, &(pthread_mutex_t&)cm.pmutex);
}
 
void thread::wait_for_signal_with_lock(condition_mutex& cm)
{
    cm.lock(); 
    wait_for_signal(cm); 
    cm.unlock();
}
 
void* thread::execute_s(void* args)
{
    thread* t = (thread*)args;
    t->execute(); 
    if (t->delete_after_termination)
        delete t;
    return NULL; 
}
 
 
void thread::execute()
{
    run();
    running = false; 
}
 
void thread::wait(unsigned millisec)
{
#ifdef _WIN32
    Concurrency::wait(millisec);
#else
    usleep(1000*millisec);
#endif
}
 
void thread::stop()
{
    if(running) {
        stop_request=true;
        pthread_join(*(pthread_t*)thread_ptr,NULL);
        stop_request=false;
    }
}
 
void thread::kill()
{
    if (running) {
        pthread_cancel(*(pthread_t*)thread_ptr);
        stop_request=false;
        running=false;
    }
}
 
void thread::wait_for_completion()
{
    if (running)
        pthread_join(*(pthread_t*)thread_ptr,NULL);
    
}
 
thread::~thread()
{
    if(running)
        kill();
    delete (pthread_t*)thread_ptr;
}
 
thread_id_type to_id(const pthread_t& pt)
{
    return (const thread_id_type&) pt;
}
 
thread_id_type thread::get_current_thread_id()
{
    return (const thread_id_type&) pthread_self();
}
 
thread_id_type thread::get_id() const
{
    return *((const thread_id_type*)thread_ptr);
}
 
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;
}
 
    }
}