cxLogThread.cpp

Go to the documentation of this file.

/*=========================================================================
This file is part of CustusX, an Image Guided Therapy Application.
                 
Copyright (c) SINTEF Department of Medical Technology.
All rights reserved.
                 
CustusX is released under a BSD 3-Clause license.
                 
See Lisence.txt (https://github.com/SINTEFMedtek/CustusX/blob/master/License.txt) for details.
=========================================================================*/
 
#include "cxLogThread.h"
#include "cxReporterMessageRepository.h"
#include "boost/bind.hpp"
#include <iostream>
 
namespace cx
{
 
ThreadMethodInvoker::ThreadMethodInvoker(QObject* parent) :
    QObject(parent)
{
}
 
void ThreadMethodInvoker::callInLogThread(ActionType action)
{
    QMutexLocker sentry(&mActionsMutex);
    mPendingActions.push_back(action);
    sentry.unlock();
 
    this->invokePendingAction();
}
 
void ThreadMethodInvoker::invokePendingAction()
{
    QMetaObject::invokeMethod(this, "pendingAction", Qt::QueuedConnection);
}
 
void ThreadMethodInvoker::pendingAction()
{
    while (this->executeAction());
}
 
bool ThreadMethodInvoker::executeAction()
{
    ActionType action = this->popAction();
    if (!action)
        return false;
 
    action();
    return true;
}
 
ThreadMethodInvoker::ActionType ThreadMethodInvoker::popAction()
{
    QMutexLocker sentry(&mActionsMutex);
    ActionType action;
 
    if (mPendingActions.isEmpty())
        return action;
 
    action = mPendingActions.front();
    mPendingActions.pop_front();
    return action;
}
 
} // namespace cx
 
 
 
 
namespace cx
{
 
LogThread::LogThread(QObject* parent) :
        QObject(parent)
{
    mQueue = new ThreadMethodInvoker(this);
        mRepository = MessageRepository::create();
}
 
void LogThread::installObserver(MessageObserverPtr observer, bool resend)
{
        ActionType action = boost::bind(&MessageRepository::install, mRepository, observer, resend);
        this->callInLogThread(action);
}
 
void LogThread::uninstallObserver(MessageObserverPtr observer)
{
        ActionType action = boost::bind(&MessageRepository::uninstall, mRepository, observer);
        this->callInLogThread(action);
}
 
void LogThread::setLoggingFolder(QString absoluteLoggingFolderPath)
{
        ActionType action = boost::bind(&LogThread::executeSetLoggingFolder, this, absoluteLoggingFolderPath);
        this->callInLogThread(action);
}
 
void LogThread::callInLogThread(ThreadMethodInvoker::ActionType action)
{
    mQueue->callInLogThread(action);
}
 
void LogThread::processMessage(Message message)
{
        message = this->cleanupMessage(message);
 
        emit emittedMessage(message);
 
        mRepository->setMessage(message);
}
 
 
Message LogThread::cleanupMessage(Message message)
{
        if (message.mTimeoutTime<0)
                message.mTimeoutTime = this->getDefaultTimeout(message.mMessageLevel);
 
        if (message.mChannel.isEmpty())
                message.mChannel = "console";
 
        if (!message.mSourceFile.isEmpty())
        {
                message.mSourceFile = message.mSourceFile.split("CustusX/").back();
                message.mSourceFile = message.mSourceFile.split("CX/").back();
        }
 
        return message;
}
 
int LogThread::getDefaultTimeout(MESSAGE_LEVEL messageLevel) const
{
        switch(messageLevel)
        {
        case mlDEBUG: return 0;
        case mlINFO: return 1500;
        case mlSUCCESS: return 1500;
        case mlWARNING: return 3000;
        case mlERROR: return 0;
        case mlVOLATILE: return 5000;
        default: return 0;
        }
}
 
 
 
} //End namespace cx