ThreadCapsule.cpp

Go to the documentation of this file.

/*
** EPITECH PROJECT, 2024
** epitech-ratrappage-babel (Workspace)
** File description:
** ThreadCapsule.cpp
*/
 
#include "Controls/ThreadCapsule.hpp"
 
Controls::ThreadCapsule::ThreadCapsule()
    : _running(false)
{
 
}
 
Controls::ThreadCapsule::~ThreadCapsule()
{
    if (_running || _thread.joinable()) {
        stopThread();
    }
}
 
void Controls::ThreadCapsule::startThread()
{
    if (!_running) {
        _running = true;
        _thread = std::thread(&Controls::UserControls::spamUserChoice, &_userControls);
        std::cout << "Thread started" << std::endl;
    }
}
 
void Controls::ThreadCapsule::stopThread(const unsigned int delay)
{
    // if (_running) {
    //     _running = false;
 
    //     if (_thread.joinable()) {
    //         std::chrono::steady_clock::time_point start_time = std::chrono::steady_clock::now();
 
    //         while (std::chrono::steady_clock::now() - start_time < std::chrono::seconds(delay)) {
    //             if (!_thread.joinable()) {
    //                 return;
    //             }
    //             std::this_thread::sleep_for(std::chrono::milliseconds(100));
    //         }
 
    //         PRETTY_INFO << "Thread did not stop in time. Forcibly terminating." << std::endl;
    //         try {
    //             PRETTY_INFO << "Injecting the 'q' key to stop the thread." << std::endl;
    //             std::cin.putback('q');
    //             std::cin.putback('\n');
    //             throw CustomExceptions::ThreadFound();
    //         }
    //         catch (const std::exception &e) {
    //             std::cerr << "Error: " << e.what() << std::endl;
    //         }
    //         catch (...) {
    //             std::cerr << "Unknown error occurred while stopping the thread." << std::endl;
    //         }
    //     }
    // }
    if (_running) {
        _running = false;
        PRETTY_INFO << "Injecting the 'q' key to stop the thread." << std::endl;
        _userControls.setLooping(false);
        _userControls.setPlaying(false);
        std::cin.putback('q');
        std::cin.putback('\n');
        std::cin.putback('\n');
        std::cin.putback('\n');
        std::cin.putback('\n');
        if (_thread.joinable()) {
            _thread.join();
        }
    }
    // if (_running) {
    //     _running = false;
    //     if (_thread.joinable()) {
    //         _thread.join();
    //     }
    // }
}
 
const bool Controls::ThreadCapsule::isRunning() const
{
    return _running;
}
 
void Controls::ThreadCapsule::setEcho(const bool echo)
{
    _userControls.setEcho(echo);
}
 
void Controls::ThreadCapsule::setHelp(const bool help)
{
    _userControls.setHelp(help);
}
 
void Controls::ThreadCapsule::setPlaying(const bool playing)
{
    _userControls.setPlaying(playing);
}
 
void Controls::ThreadCapsule::setLooping(const bool looping)
{
    _userControls.setLooping(looping);
}
 
void Controls::ThreadCapsule::setRecording(const bool recording)
{
    _userControls.setRecording(recording);
}
 
void Controls::ThreadCapsule::setUserChoice(const std::string &userChoice)
{
    _userControls.setUserChoice(userChoice);
}
 
const bool Controls::ThreadCapsule::isEcho() const
{
    return _userControls.isEcho();
}
 
const bool Controls::ThreadCapsule::isHelp() const
{
    return _userControls.isHelp();
}
 
const bool Controls::ThreadCapsule::isPlaying() const
{
    return _userControls.isPlaying();
}
 
const bool Controls::ThreadCapsule::isLooping() const
{
    return _userControls.isLooping();
}
 
const bool Controls::ThreadCapsule::isRecording() const
{
    return _userControls.isRecording();
}
 
const bool Controls::ThreadCapsule::hangUpTheCall() const
{
    return _userControls.hangUpTheCall();
}
 
void Controls::ThreadCapsule::showPrompt() const
{
    _userControls.showPrompt();
}
 
void Controls::ThreadCapsule::toggleEcho()
{
    _userControls.toggleEcho();
}
 
void Controls::ThreadCapsule::toggleHelp()
{
    _userControls.toggleHelp();
}
 
void Controls::ThreadCapsule::togglePlaying()
{
    _userControls.togglePlaying();
}
 
void Controls::ThreadCapsule::toggleLooping()
{
    _userControls.toggleLooping();
}
 
void Controls::ThreadCapsule::toggleRecording()
{
    _userControls.toggleRecording();
}
 
const std::string Controls::ThreadCapsule::getInfo(const unsigned int indent) const
{
    std::string indentation = "";
    for (unsigned int i = 0; i < indent; ++i) {
        indentation += "\t";
    }
    std::string result = indentation + "Thread Capsule:\n";
    result += indentation + "- Running: '" + Recoded::myToString(_running) + "'\n";
    result += indentation + "- User Controls: {\n" + _userControls.getInfo(indent + 1) + indentation + "}\n";
    return result;
}
 
std::ostream &Controls::operator<<(std::ostream &os, const Controls::ThreadCapsule &network)
{
    os << network.getInfo();
    return os;
}