mostlyharmless_TaskThread.cpp

//
// Created by Syl on 12/08/2024.
//
#include "mostly_harmless/utils/mostlyharmless_OnScopeExit.h"


#include <mostly_harmless/utils/mostlyharmless_TaskThread.h>
#include <cassert>
#include <thread>
namespace mostly_harmless::utils {
    TaskThread::~TaskThread() noexcept {
        stop();
    }

    auto TaskThread::perform() -> void {
        auto expected{ false };
        if (m_isThreadRunning.compare_exchange_strong(expected, true)) {
            auto actionWrapper = [this]() -> void {
                OnScopeExit se{ [this]() -> void {
                    m_isThreadRunning.store(false);
                } };
                action();
            };
            m_thread = std::make_unique<std::thread>(std::move(actionWrapper));
        }
    }

    auto TaskThread::stop() noexcept -> void {
        signalStop();
        if (!m_thread) {
            return;
        }
        if (m_thread->joinable()) {
            m_thread->join();
        }
        reset();
    }

    auto TaskThread::sleep() -> void {
        m_sleepState.canWakeUp = false;
        std::unique_lock<std::mutex> ul{ m_sleepState.mutex };
        m_sleepState.conditionVariable.wait(ul, [this]() -> bool { return m_sleepState.canWakeUp; });
    }

    auto TaskThread::wake() -> void {
        m_sleepState.canWakeUp = true;
        std::lock_guard<std::mutex> lock{ m_sleepState.mutex };
        m_sleepState.conditionVariable.notify_one();
    }

    auto TaskThread::isThreadRunning() const noexcept -> bool {
        return m_isThreadRunning;
    }

    auto TaskThread::signalStop() -> void {
        m_stop.store(true);
    }

    auto TaskThread::hasSignalledStop() const noexcept -> bool {
        return m_stop;
    }

    auto TaskThread::reset() -> void {
        m_thread.reset();
        m_stop = false;
    }




} // namespace mostly_harmless::utils