thread.hpp

Go to the documentation of this file.

#ifndef __FRIOS_POSIX_THREADS_THREAD_HPP__
#define __FRIOS_POSIX_THREADS_THREAD_HPP__

#include <frios/posix/error.hpp>
#include <frios/posix/threads/thread_attr.hpp>

#include <cassert>

#include <pthread.h>

namespace frios {
namespace posix {


class thread
{
private:
    unique<pthread_t> _thread;
    bool _joined;
    bool _detached;

    void _start(
        const pthread_attr_t* thread_attr,
        void* thread_main(void*),
        void* thread_data
    )
    {
        int fail = pthread_create(
            &_thread,
            thread_attr,
            thread_main,
            thread_data
        );
        if(fail) throw create_error(fail);
    }

    thread(const thread&) = delete;
public:

    struct create_error : error
    {
        create_error(int error_code)
         : error(error_code)
        { }
    };


    thread(
        void* thread_main(void*),
        void* thread_data
    ): _joined(false)
     , _detached(false)
    {
        _start(0, thread_main, thread_data);
    }


    thread(
        const thread_attr& attr,
        void* thread_main(void*),
        void* thread_data
    ): _joined(false)
     , _detached(attr.get_detach_state() == thread_attr::detach_state::detached)
    {
        _start(&attr._attr, thread_main, thread_data);
    }

    thread(thread&& tmp)
     : _thread(std::move(tmp._thread))
     , _joined(tmp._joined)
     , _detached(tmp._detached)
    { }


    ~thread(void)
    {
        if(_thread.valid())
            assert(joined() || detached());
    }


    bool joinable(void) const
    {
        return !detached() && !joined();
    }


    bool detached(void) const
    {
        return _detached;
    }


    bool joined(void) const
    {
        return _joined;
    }


    void detach(void)
    {
        assert(!joined() && !detached());
        int fail = pthread_detach(_thread);
        if(fail) throw error(fail);
        _detached = true;
    }


    void* join(void)
    {
        assert(!joined() && !detached());
        void* result = 0;
        int fail = pthread_join(_thread, &result);
        if(fail) throw error(fail);
        _joined = true;
        return result;
    }


    void wait_for(void)
    {
        assert(!detached());
        if(!joined()) join();
    }
};

} // namespace posix
} // namespace frios

#endif // include guard