thread.hpp

Go to the documentation of this file.

 
#ifndef JOIN_CORE_THREAD_HPP
#define JOIN_CORE_THREAD_HPP
 
// C++.
#include <functional>
#include <memory>
#include <atomic>
 
// C.
#include <pthread.h>
 
namespace join
{
    class Invoker
    {
    public:
        Invoker () = delete;
 
    private:
        template <class Function, class... Args>
        explicit Invoker (Function&& func, Args&&... args)
        : Invoker (-1, 0, std::forward<Function> (func), std::forward<Args> (args)...)
        {
        }
 
        template <class Function, class... Args>
        explicit Invoker (int core, int prio, Function&& func, Args&&... args)
        : _func (std::bind (std::forward<Function> (func), std::forward<Args> (args)...))
        , _core (core)
        , _priority (prio)
        , _done (false)
        {
            pthread_create (&_handle, nullptr, _routine, this);
        }
 
    public:
        Invoker (const Invoker& other) = delete;
 
        Invoker& operator= (const Invoker& other) = delete;
 
        Invoker (Invoker&& other) = delete;
 
        Invoker& operator= (Invoker&& other) = delete;
 
        ~Invoker () = default;
 
    private:
        static void* _routine (void* context);
 
        void* routine ();
 
        std::function<void ()> _func;
 
        pthread_t _handle;
 
        int _core = -1;
 
        int _priority = 0;
 
        std::atomic_bool _done;
 
        friend class Thread;
    };
 
    class Thread
    {
    public:
        Thread () noexcept = default;
 
        template <class Function, class... Args>
        explicit Thread (Function&& func, Args&&... args)
        : Thread (-1, 0, std::forward<Function> (func), std::forward<Args> (args)...)
        {
        }
 
        template <class Function, class... Args>
        explicit Thread (int core, int prio, Function&& func, Args&&... args)
        : _invoker (new Invoker (core, prio, std::forward<Function> (func), std::forward<Args> (args)...))
        {
        }
 
        Thread (const Thread& other) = delete;
 
        Thread& operator= (const Thread& other) = delete;
 
        Thread (Thread&& other) noexcept;
 
        Thread& operator= (Thread&& other) noexcept;
 
        ~Thread ();
 
        int affinity (int core);
 
        static int affinity (pthread_t handle, int core);
 
        int affinity () const noexcept;
 
        int priority (int prio);
 
        static int priority (pthread_t handle, int prio);
 
        int priority () const noexcept;
 
        bool joinable () const noexcept;
 
        bool running () const noexcept;
 
        void join () noexcept;
 
        bool tryJoin () noexcept;
 
        void cancel () noexcept;
 
        void swap (Thread& other) noexcept;
 
        pthread_t handle () const noexcept;
 
    private:
        std::unique_ptr<Invoker> _invoker;
    };
}
 
#endif