Thread.hpp

// SPDX-FileCopyrightText: 2025-2026 Vincent Leroy
// SPDX-License-Identifier: MIT
//
// This file is part of dfx.
//
// Licensed under the MIT License. See the LICENSE file in the project root
// for full license information.
 
#pragma once
 
// Standard includes
#include <cstring>
#include <future>
#include <string_view>
#include <system_error>
#include <thread>
#include <utility>
 
// Project includes
#include "CompilerSupport.hpp"
#include "CopyMoveControl.hpp"
#include "Exception.hpp"
#include "Log.hpp"
 
namespace dfx::Utils
{

template<typename T>
concept CallWithToken = requires(T t, std::stop_token st)
{ t.exec(st); };

template<typename T>
concept CallWithoutToken = requires(T t)
{ t.exec(); };

template<typename T>
concept Runnable = CallWithToken<T> || CallWithoutToken<T>;


class Thread
{
private:
    struct State
    {
        std::promise<void> startPromise;
        std::shared_future<void> startFuture;
        void * runnable = nullptr;
    };
 
public:
    template<Runnable R, typename ... Args>
    Thread(std::in_place_type_t<R>, std::string threadName, Args && ... args)
        : _st { std::make_shared<State>() }
    {
        _st->startFuture = _st->startPromise.get_future();
 
        // Do not capture this in the following lambda since the Thread object can be moved
        // between the end of this ctor and the thread finishing. Use the State internal struct
        // to pass information around instead
        _thread = std::jthread([newName = std::move(threadName), ...args = std::forward<Args>(args), state = _st](std::stop_token stopToken) mutable noexcept
        {
            std::error_code ec;
            setName(newName, ec);
            if (ec)
                DFX_UTILITIES_LOG_WARN("Failed to set name '{}' for thread ID {}: {}", newName, gettid(), ::strerror(ec.value()));
 
            auto logger = DFX_UTILITIES_LOGGER();
            try
            {
                R runnable(std::move(args)...);
                if (DFX_UNLIKELY(stopToken.stop_requested()))
                    return ;
 
                state->runnable = static_cast<void *>(&runnable);
                state->startPromise.set_value();
                if constexpr (CallWithToken<R>)
                    runnable.exec(std::move(stopToken));
                else
                    runnable.exec();
            }
            catch (Exception const & e)
            { if (logger != nullptr) Exception::printToLogger(e, logger); }
            catch (std::exception const & e)
            { if (logger != nullptr) SPDLOG_LOGGER_ERROR(logger, "An error occured: {}", e.what()); }
            catch (...)
            { if (logger != nullptr) SPDLOG_LOGGER_ERROR(logger, "An unknown error occured"); }
        });
    }
 
    DFX_ENABLE_DEFAULT_MOVE_DISABLE_COPY_NOEXCEPT(Thread);
 
public:
    void waitForStarted()
    { return _st->startFuture.get(); }

    void stop(bool waitForFinished = false) noexcept;

    std::jthread const & nativeThread() const noexcept
    { return _thread; }

    template<Runnable R>
    R & getRunnable() const { return *static_cast<R *>(_st->runnable); }
 
public:
    template<Runnable R, typename ... Args>
    static Thread create(std::string threadName, Args && ... args)
    {
        return Thread(std::in_place_type<R>, std::move(threadName), std::forward<Args>(args)...);
    }
 
public:
    static void setName(std::string_view name, std::error_code & ec) noexcept;

    static void setName(std::string_view name);

    static std::string getName(std::error_code & ec) noexcept;

    static std::string getName();
 
private:
    std::jthread _thread;
    std::shared_ptr<State> _st;
};
} // !namespace dfx::Utils