thread.h

Go to the documentation of this file.

// =====================================================================================================================
//  fennec, a free and open source game engine
//  Copyright © 2025  Medusa Slockbower
//
//  This program is free software: you can redistribute it and/or modify
//  it under the terms of the GNU General Public License as published by
//  the Free Software Foundation, either version 3 of the License, or
//  (at your option) any later version.
//
//  This program is distributed in the hope that it will be useful,
//  but WITHOUT ANY WARRANTY; without even the implied warranty of
//  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
//  GNU General Public License for more details.
//
//  You should have received a copy of the GNU General Public License
//  along with this program.  If not, see <https://www.gnu.org/licenses/>.
// =====================================================================================================================
 
 
 
#ifndef FENNEC_THREADING_THREAD_H
#define FENNEC_THREADING_THREAD_H
 
#include <pthread.h>
#include <fennec/format/formatter.h>
#include <fennec/lang/type_traits.h>
#include <fennec/lang/type_transforms.h>
#include <fennec/memory/bytes.h>
#include <fennec/threading/detail/_thread.h>
 
namespace fennec
{
 
class thread {
private:
    static constexpr pthread_t nullthread = 0;
 
public:
    using native_handle_type = pthread_t;
 
    class id {
    public:
        constexpr id() noexcept : _id(0) {}
 
        constexpr friend bool operator==(id x, id y) noexcept {
            if (x._id == 0) {
                return y._id == 0;
            }
            if (y._id == 0) {
                return false;
            }
            return pthread_equal(x._id, y._id) != 0;
        }
        constexpr friend bool operator!=(id x, id y) noexcept { return !(x == y); }
 
    private:
        friend class thread;
        friend struct hash<id>;
        friend struct formatter<id>;
 
        constexpr id(pthread_t id) : _id(id) {}
 
        pthread_t _id;
    };
 
    thread() noexcept
        : _handle(nullthread) {
    }
 
    thread(thread&& th)
        : _handle(th._handle) {
        th._handle = nullthread;
    }
 
    thread(const thread&) = delete;
 
    template<typename FuncT, typename...ArgsT>
        requires(not is_same_v<thread, remove_cvref_t<FuncT>>)
    thread(FuncT&& func, ArgsT&&...args)
        : _handle(nullthread) {
        using proxy_t = detail::thread_proxy_t<function<FuncT>, ArgsT...>;
        unique_ptr<proxy_t> proxy = fennec::make_unique<proxy_t>(fennec::forward<FuncT>(func), fennec::forward<ArgsT>(args)...);
 
        int_t res = ::pthread_create(&_handle, nullptr, &detail::_run_thread<proxy_t>(), proxy.get());
        assertf(res == 0, "Thread creation failed!");
 
        proxy.release();
    }
 
    thread& operator=(thread&& th) noexcept {
        assertf(_handle == nullthread, "Attempted to overwrite running thread!");
 
        _handle    = th._handle;
        th._handle = nullthread;
 
        return *this;
    }
 
    ~thread() {
        assertf(_handle == 0, "Attempted to destruct a running thread!");
    }
 
    bool joinable() const noexcept {
        return _handle != nullthread and pthread_self() != _handle;
    }
 
    void join() {
        if (not joinable()) {
            return;
        }
 
        int_t res = pthread_join(_handle, nullptr);
        assertf(res == 0, "Failed to join thread!");
        _handle = nullthread;
    }
 
    void detatch() {
        if (not joinable()) {
            return;
        }
 
        int_t res = pthread_detach(_handle);
        assertf(res == 0, "Failed to detatch thread!");
        _handle = nullthread;
    }
 
    void swap(thread& other) {
        fennec::swap(_handle, other._handle);
    }
 
    static id current() {
        return pthread_self();
    }
 
    id get_id() const {
        return _handle;
    }
 
 
private:
    pthread_t _handle;
};
 
template <>
struct hash<thread::id> {
    size_t operator()(thread::id v) const noexcept {
        return hash<thread::native_handle_type>()(v._id);
    }
};
 
template<>
struct formatter<thread::id> {
    string operator()(const format_arg& fmt, thread::id v) const noexcept {
        return formatter<thread::native_handle_type>()(fmt, v._id);
    }
};
 
}
 
#endif // FENNEC_THREADING_THREAD_H