Classes/C_Th_DoOnSignal.cpp - AddMacOS - Dengit-man/CustomLocaleKeyShortcut

Classes/C_Th_DoOnSignal.cpp
106 строк4 KB
Dengit-man
Поправлен `LICENSE.md` и соответствующие упоминания в нужных файлах.
25 май 2026, 23:32
25 май 2026, 23:3279c96dd
//
// Created by Dengit-man on 05.03.2026.
// Правообладатель (c) 2026 Пользователь GitVerse "Dengit-man"
//

#include "C_Th_DoOnSignal.h"

#include <format>
#include <utility>

#include "C_Logger.h"

C_Th_DoOnSignal::C_Th_DoOnSignal(callable a_function)
    : f_pendingSwitch(false), f_stop(false), f_function(std::move(a_function))
{
    LogDebug("C_Th_DoOnSignal::C_Th_DoOnSignal(call a_function) created.", false);
}

C_Th_DoOnSignal::~C_Th_DoOnSignal()
{
    LogDebug("Thread with background loop is destroying...", false);
    this->f_stop.store(true, std::memory_order_release);
    this->f_readyToSwitchOrStop.notify_all();
    if (this->f_thread != nullptr)
    {
        if (this->f_thread->joinable())
        {
            this->f_thread->join();
        }
    }
    LogDebug("Thread with background loop is destroyed.", false);
}

C_Th_DoOnSignal::C_Th_DoOnSignal(C_Th_DoOnSignal && other) noexcept
  : f_pendingSwitch(other.f_pendingSwitch.load()),
    f_stop(other.f_stop.load()),
    f_function(std::move(other.f_function))
{
    LogDebug("C_Th_DoOnSignal::C_Th_DoOnSignal(C_Th_DoOnSignal &&) created from Move.", false);
    std::lock_guard lock(other.f_mtx);
    this->f_thread = std::move(other.f_thread);
    // гарантировать, что other не будет держать работающий поток
    other.f_stop.store(true);
    other.f_readyToSwitchOrStop.notify_all();
}

void C_Th_DoOnSignal::start()
{
    LogDebug("C_Th_DoOnSignal::start()", false);
    this->f_thread = std::make_unique<std::thread>(std::thread(&C_Th_DoOnSignal::backgroundLoop, this));
    LogDebug("Thread with background loop is created and started.", false);
}

void C_Th_DoOnSignal::stop()
{
    LogDebug("C_Th_DoOnSignal::stop() called.", false);
    this->f_stop.store(true, std::memory_order_release);
    this->f_readyToSwitchOrStop.notify_all();
}

void C_Th_DoOnSignal::triggerIt()
{
    LogDebug("C_Th_DoOnSignal::triggerIt() called.", false);
    this->f_pendingSwitch.store(true, std::memory_order_release);
    this->f_readyToSwitchOrStop.notify_all();
}

void C_Th_DoOnSignal::backgroundLoop()
{
    LogDebug("C_Th_DoOnSignal::backgroundLoop() started...", false);
    std::unique_lock lock(this->f_mtx);
    while (!this->f_stop)
    {
        // Ждём, пока флаг станет true или пока получим запрос на остановку
        LogDebug("C_Th_DoOnSignal::backgroundLoop() waiting for trigger...", false);
        this->f_readyToSwitchOrStop.wait(lock, [this]
            {
            return this->f_pendingSwitch.load(std::memory_order_acquire) ||
                   this->f_stop.load(std::memory_order_acquire);
        });


        if (this->f_stop.load(std::memory_order_acquire))
        {
            LogDebug("C_Th_DoOnSignal::backgroundLoop() going to stop.", false);
            break;                     // завершить поток
        }

        this->f_pendingSwitch.store(false, std::memory_order_release);

        LogDebug("C_Th_DoOnSignal::backgroundLoop() calling function...", false);
        try
        {
            this->f_function();
        }
        catch (const std::exception& e) {
            LogCritical(std::format("[!] C_Th_DoOnSignal::backgroundLoop(). Function threw exception: {}", e.what()), false);
            Sleep(100);
        } catch (...) {
            LogCritical("[!] C_Th_DoOnSignal::backgroundLoop(). Function threw unknown exception", false);
            Sleep(100);
        }
        LogDebug("C_Th_DoOnSignal::backgroundLoop() function ended.", false);
    }
    LogDebug("C_Th_DoOnSignal::backgroundLoop() finished.", false);
}