simplethreadhandler.cpp

Go to the documentation of this file.

/*****************************************************************************
 * Copyright 2015 Haye Hinrichsen, Christoph Wick
 *
 * This file is part of Entropy Piano Tuner.
 *
 * Entropy Piano Tuner 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.
 *
 * Entropy Piano Tuner 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
 * Entropy Piano Tuner. If not, see http://www.gnu.org/licenses/.
 *****************************************************************************/

//=============================================================================
//                            Thread handler
//=============================================================================

#include "simplethreadhandler.h"
#include <chrono>
#include "../system/log.h"


//------------------ Constructor, clear cancel flag ---------------------------


SimpleThreadHandler::SimpleThreadHandler()
    : mCancelThread(false),
      mRunning(false)
{}


//------------------ Destructor ------------------- ---------------------------


SimpleThreadHandler::~SimpleThreadHandler()
{
    stop();
}


//--------------- threadsafe cancelThread setter function----------------------


void  SimpleThreadHandler::setCancelThread(bool b)
{
    std::lock_guard<std::mutex> lock(mLockMutex); // protect remainder of block
    mCancelThread = b;
}


//--------------- threadsafe cancelThread getter function----------------------


bool  SimpleThreadHandler::cancelThread() const
{
    std::lock_guard<std::mutex> lock(mLockMutex);  // protect remainder of block
    return mCancelThread;
}


//-------------------------- Start the thread ---------------------------------


void SimpleThreadHandler::start()
{
    stop();
    setCancelThread(false);
    mThread = std::thread(&SimpleThreadHandler::simpleWorkerFunction, this);
}


//------------------- Mark the thread as to be cancelled ---------------------


void SimpleThreadHandler::stop()
{
    setCancelThread(true);                  // Set cancel flag to true
    if (mThread.joinable()) mThread.join(); // Wait for thread to terminate
}


//--------------- Let the thread sleep in an idle state ----------------------


void SimpleThreadHandler::msleep(double milliseconds)
{
    std::this_thread::sleep_for(
                std::chrono::microseconds(static_cast<int>(1000*milliseconds)));
}


//--------------- Returns whether the thread is running ----------------------


bool SimpleThreadHandler::isThreadRunning() const
{
    return mRunning;
}


//--- called when an exception was caught during the worker function ---------


void SimpleThreadHandler::exceptionCaught(const EptException &e)
{
    // empty
    (void)e;
}


//------------------------------ Set thread name ------------------------------


void SimpleThreadHandler::setThreadName(std::string s)
{
#if defined(__linux__) and not defined(QT_NO_DEBUG) and not defined(__ANDROID__)
    // Note: If you encounter a compiler error in the following line
    // please comment it out. It serves only for debugging purposes on Qt.
    pthread_setname_np (pthread_self(), s.c_str());
#else
    if (s.size()){}; // suppress warning if inactive
#endif
}


// -------------------------- Private helper function -------------------------


void SimpleThreadHandler::simpleWorkerFunction()
{
    mRunning = true;

    try
    {
        workerFunction();
    }
    catch (const EptException &e)
    {
        LogE("Worker thread stopped with EptException: %s", e.what());
        exceptionCaught(e);
    }
    catch (const std::exception &e)
    {
        LogE("Worker thread stopped with std::exception: %s", e.what());
    }
    catch (...) {
        LogE("Worker thread stopped with an unknown exception");
    }

    mRunning = false;
}