/* * Copyright (C) 2013-2015, 2019 by the Konclude Developer Team. * * This file is part of the reasoning system Konclude. * For details and support, see . * * Konclude is free software: you can redistribute it and/or modify * it under the terms of version 3 of the GNU Lesser General Public * License (LGPLv3) as published by the Free Software Foundation. * * Konclude 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 (Lesser) General Public License for more details. * * You should have received a copy of the GNU (Lesser) General Public * License along with Konclude. If not, see . * */ #include "CIntervalThread.h" namespace Konclude { namespace Concurrent { CIntervalThread::CIntervalThread(QString threadIdentifierName, CWatchDog *watchDog) : CThread(threadIdentifierName,watchDog),mSyncTimerMutex(QMutex::Recursive) { } CIntervalThread::~CIntervalThread() { } void CIntervalThread::setTimerInterval(qint64 timerID, qint64 timerIntervalMilliSecs) { postEvent(new CTimerIntervalEvent(timerID,timerIntervalMilliSecs)); } void CIntervalThread::startTimerWithInterval(qint64 timerID, qint64 timerIntervalMilliSecs) { postEvent(new CTimerIntervalEvent(timerID,timerIntervalMilliSecs,true)); } void CIntervalThread::startTimerWithIntervalLimited(qint64 timerID, qint64 timerIntervalMilliSecs, qint64 remainingCallCount) { postEvent(new CTimerIntervalEvent(timerID,timerIntervalMilliSecs,true,false,remainingCallCount)); } void CIntervalThread::startTimer(qint64 timerID) { postEvent(new CTimerIntervalEvent(timerID,-1,true)); } void CIntervalThread::stopTimer(qint64 timerID) { mSyncTimerMutex.lock(); if (timers.contains(timerID)) { CIntervalThreadData *timerData = timers.value(timerID); timerData->incDeactivateCount(); } mSyncTimerMutex.unlock(); postEvent(new CTimerIntervalEvent(timerID,-1,false,true)); } void CIntervalThread::threadStarted() { } void CIntervalThread::threadStopped() { mSyncTimerMutex.lock(); QList timerList = timers.values(); foreach (CIntervalThreadData *timerData, timerList) { bool isActive = timerData->isTimerActive(); if (isActive) { int timerThreadID = timerData->getTimerThreadID(); QObject::killTimer(timerThreadID); } timerData->setTimerActive(false); } mSyncTimerMutex.unlock(); } bool CIntervalThread::processEvents(QEvent *event) { QEvent *ev = event; if (CThread::processEvents(event)) { return true; } else if (event->type() == QEvent::Timer) { SETTASKDESCRIPTION("Process Timer Timeout"); QTimerEvent *te = (QTimerEvent *)event; int timerThreadID = te->timerId(); mSyncTimerMutex.lock(); if (timerMapping.contains(timerThreadID)) { qint64 timerID = timerMapping.value(timerThreadID); if (timers.contains(timerID)) { CIntervalThreadData *timerData = timers.value(timerID); if (timerData->isTimerActive() && timerData->getDeactivateCount() <= 0) { if (timerData->hasRemainingTimerInvocations()) { timerData->decRemainingTimerInvocations(1); processTimer(timerID); } else { int timerThreadID = timerData->getTimerThreadID(); QObject::killTimer(timerThreadID); timerData->setTimerActive(false); } } } } mSyncTimerMutex.unlock(); return true; } return false; } bool CIntervalThread::processControlEvents(QEvent::Type type, CControlEvent *event) { if (CThread::processControlEvents(type,event)) { return true; } else if (type == EVENTTIMERINTERVAL) { SETTASKDESCRIPTION("Configure Timer Settings"); CTimerIntervalEvent *tie = (CTimerIntervalEvent *)event; qint64 timerID = tie->getTimerID(); qint64 timerInterval = tie->getTimerInterval(); bool activateTimer = tie->getTimerActive(); bool deactivateTimer = tie->getTimerDeactive(); qint64 remTimerInvocs = tie->getRemainingTimerInvocations(); CIntervalThreadData *timerData = 0; mSyncTimerMutex.lock(); bool isNew = false; if (timers.contains(timerID)) { timerData = timers.value(timerID); } else { timerData = new CIntervalThreadData(); timers.insert(timerID,timerData); isNew = true; } if (deactivateTimer) { timerData->decDeactivateCount(); } bool reactivateTimer = false; if (timerInterval >= 0) { timerData->setInterval(timerInterval); bool isActive = timerData->isTimerActive(); if (isActive) { reactivateTimer = true; } } timerData->setRemainingTimerInvocations(remTimerInvocs); if (deactivateTimer) { reactivateTimer = false; int timerThreadID = timerData->getTimerThreadID(); bool isActive = timerData->isTimerActive(); if (isActive) { QObject::killTimer(timerThreadID); } timerData->setTimerActive(false); } if (activateTimer || reactivateTimer) { qint64 deactivateCount = timerData->getDeactivateCount(); if (deactivateCount <= 0) { bool isActive = timerData->isTimerActive(); int timerThreadID = timerData->getTimerThreadID(); if (isActive) { QObject::killTimer(timerThreadID); } timerThreadID = QObject::startTimer(timerData->getInterval()); timerData->setTimerThreadID(timerThreadID); timerData->setTimerActive(true); timerMapping.insert(timerThreadID,timerID); } } mSyncTimerMutex.unlock(); return true; } return false; } }; // end namespace Concurrent }; // end namespace Konclude