PosixThread.hxx

#pragma once
 
// C++
#include <functional>
#include <optional>
#include <string>
#include <string_view>
 
// cosmos
#include <cosmos/thread/pthread.hxx>
#include <cosmos/time/types.hxx>
 
namespace cosmos {
 
 
class COSMOS_API PosixThread {
 
        // forbid copy-assignment
        PosixThread(const PosixThread&) = delete;
        PosixThread& operator=(const PosixThread&) = delete;
 
public: // types
 
        using PosixEntry = std::function<pthread::ExitValue (pthread::ThreadArg)>;
        using Entry = std::function<void (void)>;
 
public: // functions
 
 
        PosixThread() noexcept {}
 
 
        PosixThread(PosixEntry entry, pthread::ThreadArg arg, const std::string_view name = {});
 
 
        explicit PosixThread(Entry entry, const std::string_view name = {});
 
        PosixThread(PosixThread &&other) noexcept;
 
        PosixThread& operator=(PosixThread &&other) noexcept;
 
        virtual ~PosixThread();
 
        bool joinable() const {
                return m_pthread.has_value();
        }
 
 
        pthread::ExitValue join();
 
 
        std::optional<pthread::ExitValue> tryJoin();
 
 
        std::optional<pthread::ExitValue> joinTimed(const RealTime ts);
 
 
        void detach();
 
 
        const std::string& name() const { return m_name; }
 
 
        pthread::ID id() const { return pthread::ID{*m_pthread}; }
 
        bool isCallerThread() const {
                return id() == pthread::get_id();
        }
 
        void kill(const Signal sig) {
                pthread::kill(id(), sig);
        }
 
protected: // functions
 
        std::string buildName(const std::string_view name, size_t nr) const;
 
        void assertJoinConditions();
 
        void reset();
 
protected: // data
 
        std::optional<pthread_t> m_pthread;
 
        std::string m_name;
};
 
} // end ns