diff options
Diffstat (limited to 'src/MTS_SignalThread.cpp')
-rw-r--r-- | src/MTS_SignalThread.cpp | 103 |
1 files changed, 103 insertions, 0 deletions
diff --git a/src/MTS_SignalThread.cpp b/src/MTS_SignalThread.cpp new file mode 100644 index 0000000..99975c0 --- /dev/null +++ b/src/MTS_SignalThread.cpp @@ -0,0 +1,103 @@ +/* + * Copyright (C) 2015 by Multi-Tech Systems + * + * This file is part of libmts. + * + * libmts is free software: you can redistribute it and/or modify + * it under the terms of the GNU Lesser General Public License as published by + * the Free Software Foundation, either version 2 of the License, or + * (at your option) any later version. + * + * libmts 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 libmts. If not, see <http://www.gnu.org/licenses/>. + * + */ + +#include <mts/MTS_SignalThread.h> +#include <mts/MTS_Logger.h> + +using namespace MTS; + +SignalThread::SignalThread(const std::string& name) +: Thread(name, true) +, m_bShouldExecute(false) +, m_bCurrentlyExecuting(false) +, m_ui32WaitMillis(200) +{ + init(); +} + +SignalThread::SignalThread(const std::string& name, uint32_t waitMillis) +: Thread(name, true) +, m_bShouldExecute(false) +, m_bCurrentlyExecuting(false) +, m_ui32WaitMillis(waitMillis) +{ + init(); +} + +void SignalThread::init() +{ + printConfig("SignalThread| %s - starting up", Thread::getName().c_str()); + m_apStateLock.reset(new MTS::Lock); + m_apConditionLock.reset(new MTS::Lock); + m_apCondition.reset(m_apConditionLock->createCondition()); +} + +SignalThread::~SignalThread() +{ + stop(); + m_apStateLock.reset(); + m_apConditionLock.reset(); + m_apCondition.reset(); + printConfig("SignalThread| %s - shutting down", Thread::getName().c_str()); +} + +void SignalThread::signal() +{ + m_apConditionLock->lock(); + m_bShouldExecute = true; + m_apCondition->signal(); + m_apConditionLock->unlock(); +} + +void SignalThread::run() +{ + while (! Thread::isCanceled()) + { + m_apConditionLock->lock(); + if (! m_bShouldExecute) + { + m_apCondition->wait(m_ui32WaitMillis); + } + if (m_bShouldExecute) + { + printTrace("SignalThread| %s - starting execute() function", Thread::getName().c_str()); + m_apStateLock->lock(); + m_bCurrentlyExecuting = true; + m_apStateLock->unlock(); + execute(); + m_apStateLock->lock(); + m_bCurrentlyExecuting = false; + m_apStateLock->unlock(); + printTrace("SignalThread| %s - finished execute() function", Thread::getName().c_str()); + } + m_bShouldExecute = false; + m_apConditionLock->unlock(); + } +} + +bool SignalThread::isExecuting() const +{ + bool retval = false; + m_apStateLock->lock(); + retval = m_bCurrentlyExecuting; + m_apStateLock->unlock(); + + return retval; +} |