diff options
Diffstat (limited to 'include')
25 files changed, 2292 insertions, 0 deletions
diff --git a/include/mts/MTS_AutoLock.h b/include/mts/MTS_AutoLock.h new file mode 100644 index 0000000..e7a05bd --- /dev/null +++ b/include/mts/MTS_AutoLock.h @@ -0,0 +1,56 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_AutoLock.h + \brief Auto lock + \date 08OCT14 + \author Pavlo Samko + + Auto lock. + */ + + +#ifndef _MTS_AUTOLOCK_H_ +#define _MTS_AUTOLOCK_H_ + +#include <mts/MTS_NonCopyable.h> +#include <mts/MTS_Lock.h> + +namespace MTS { + + //! Auto lock + /*! + Auto lock + + \sa Lock + */ + + class AutoLock: private NonCopyable { + + public: + AutoLock(Lock &lock): m_lock(lock) { m_lock.lock(); } //!< Constructs the AutoLock + ~AutoLock() { m_lock.unlock(); } //!< Destructs the AutoLock + + private: + Lock &m_lock; //!< Lock + }; +} + +#endif diff --git a/include/mts/MTS_AutoPtr.h b/include/mts/MTS_AutoPtr.h new file mode 100644 index 0000000..68b82cf --- /dev/null +++ b/include/mts/MTS_AutoPtr.h @@ -0,0 +1,115 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_AutoPtr.h + \brief An autopointer + \date 15JUN11 + \author Sean Godinez + + An autopointer. + */ + +#ifndef MTS_AUTOPTR_H +#define MTS_AUTOPTR_H + +#include <mts/MTS_NonCopyable.h> +#include <mts/MTS_Stdint.h> + +namespace MTS { + + //! An autopointer + /*! + An autopointer cleans up after itself. + */ + template<class T> class AutoPtr: NonCopyable { + + public: + enum MallocType { + SINGLE, ARRAY + }; + + explicit AutoPtr(T* ptr = 0, MallocType type = SINGLE); //!< Explicitly Constructs the AutoPtr to reference ptr + ~AutoPtr(); //!< Destructs the AutoPtr deleting T + + T& operator*() const; //!< Returns T + T* operator->() const; //!< Returns address of T + T& operator[](const uint32_t& index) const; //!< Returns T at index + T* get() const; //!< Returns address of T + T* release(); //!< Removes reference to T (does NOT delete T) and returns address + void reset(T* ptr = 0, MallocType type = SINGLE); //!< Deletes old T and assigns internal reference to ptr + bool isNull() const; //!< Returns true if pointer is NULL + + private: + T* m_pObj; //!< Reference to class T + MallocType m_eType; //!< Describes memory allocated as a single T or block of Ts + + }; + + template<class T> AutoPtr<T>::AutoPtr(T* ptr, MallocType type) + : m_pObj(ptr), m_eType(type) { + } + + template<class T> AutoPtr<T>::~AutoPtr() { + if (m_eType == SINGLE) { + delete m_pObj; + } else { + delete[] m_pObj; + } + } + + template<class T> T& AutoPtr<T>::operator*() const { + return *m_pObj; + } + + template<class T> T* AutoPtr<T>::operator->() const { + return m_pObj; + } + + template<class T> T& AutoPtr<T>::operator[](const uint32_t& index) const { + return m_pObj[index]; + } + + template<class T> T* AutoPtr<T>::get() const { + return m_pObj; + } + + template<class T> T* AutoPtr<T>::release() { + T* temp = m_pObj; + m_pObj = 0; + return temp; + } + + template<class T> void AutoPtr<T>::reset(T* ptr, MallocType type) { + T* temp = m_pObj; + m_pObj = ptr; + if (m_eType == SINGLE) { + delete temp; + } else { + delete[] temp; + } + m_eType = type; + } + + template<class T> bool AutoPtr<T>::isNull() const { + return (m_pObj == 0); + } +} + +#endif diff --git a/include/mts/MTS_BasicPublisher.h b/include/mts/MTS_BasicPublisher.h new file mode 100644 index 0000000..d5749ec --- /dev/null +++ b/include/mts/MTS_BasicPublisher.h @@ -0,0 +1,63 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_BasicPublisher.h + \brief A simple publisher + \date 28MAR12 + \author Sean Godinez + + A basic publisher. + */ + +#ifndef _MTS_BASICPUBLISHER_H_ +#define _MTS_BASICPUBLISHER_H_ + +#include <mts/MTS_Publisher.h> + +namespace MTS { + + //! A basic publisher + /*! + A basic publisher provides simple publishing functionality. + + \sa Publisher, Subscriber, BasicSubscriber + */ + template<class T> class BasicPublisher: public Publisher<T> { + + public: + BasicPublisher(); //!< Constructor + virtual ~BasicPublisher(); //!< Destructor + + virtual void publish(const T& object); //!< Publishes T to Subscribers + }; + + template<class T> BasicPublisher<T>::BasicPublisher() { + } + + template<class T> BasicPublisher<T>::~BasicPublisher() { + } + + template<class T> void BasicPublisher<T>::publish(const T& object) { + Publisher<T>::publish(object); + } + +} + +#endif diff --git a/include/mts/MTS_BasicSubscriber.h b/include/mts/MTS_BasicSubscriber.h new file mode 100644 index 0000000..908dde9 --- /dev/null +++ b/include/mts/MTS_BasicSubscriber.h @@ -0,0 +1,71 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_BasicSubscriber.h + \brief A simple subscriber + \date 28MAR12 + \author Sean Godinez + + A subscriber. + */ +#ifndef _MTS_BASICSUBSCRIBER_H_ +#define _MTS_BASICSUBSCRIBER_H_ + +#include <mts/MTS_Subscriber.h> +#include <mts/MTS_Callback.h> + +namespace MTS { + + //! A basic subscriber + /*! + A basic subscriber provides simple subscribing functionality. + + \sa Publisher, Subscriber, BasicPublisher + */ + template<class T> class BasicSubscriber: public Subscriber<T> { + + public: + explicit BasicSubscriber(const Callback<T>& callback, const std::string& name = ""); //!< Constructor + virtual ~BasicSubscriber();//!< Destructor + + virtual void update(const T& object); //!< Invokes callback with published data T + + private: + Callback<T>* callback; + + //Prevent Copy and Assignment operators from being called + BasicSubscriber(const BasicSubscriber&); + BasicSubscriber& operator=(const BasicSubscriber&); + }; + + template<class T> BasicSubscriber<T>::BasicSubscriber(const Callback<T>& callback, const std::string& name) + : Subscriber<T>(name), callback(callback.clone()) { + } + + template<class T> BasicSubscriber<T>::~BasicSubscriber() { + delete callback; + } + + template<class T> void BasicSubscriber<T>::update(const T& object) { + callback->invoke(object); + } +} + +#endif diff --git a/include/mts/MTS_Buffer.h b/include/mts/MTS_Buffer.h new file mode 100644 index 0000000..96f25a9 --- /dev/null +++ b/include/mts/MTS_Buffer.h @@ -0,0 +1,87 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Buffer.h + \brief A buffer + \date 15JUN11 + \author Sean Godinez + + A buffer. + */ + +#ifndef MTS_BUFFER_H +#define MTS_BUFFER_H + +#include <mts/MTS_Stdint.h> +#include <vector> +#include <string> + +namespace MTS { + + class Buffer { + + public: + static const uint32_t DEFAULT_CAPACITY; + + explicit Buffer(uint32_t capacity = DEFAULT_CAPACITY); + Buffer(const uint8_t* bytes, uint32_t count); + Buffer(const Buffer& other); + virtual ~Buffer(); + + Buffer& operator=(const Buffer& other); + + const uint8_t* getBuffer() const; + std::string str() const; + + uint32_t getSize() const; + void setSize(uint32_t newSize); + + uint32_t getCapacity() const; + void setCapacity(uint32_t newCapacity); + + void clear(); + void compact(); + + uint8_t operator[](uint32_t index) const; + uint8_t operator[](uint32_t index); + + const uint8_t& at(uint32_t index) const; + uint8_t& at(uint32_t index); + + Buffer& append(uint8_t byte); + Buffer& append(const uint8_t* bytes, uint32_t count); + + Buffer& insert(uint32_t index, uint8_t byte); + Buffer& insert(uint32_t index, const uint8_t* bytes, + uint32_t count); + + Buffer& remove(uint32_t index); + Buffer& remove(uint32_t start, uint32_t end); + + Buffer& replace(uint32_t start, uint32_t end, const uint8_t* bytes, uint32_t count); + Buffer* clone() const; + + private: + std::vector<uint8_t> m_vBuffer; + + }; +} + +#endif diff --git a/include/mts/MTS_Component.h b/include/mts/MTS_Component.h new file mode 100644 index 0000000..215add5 --- /dev/null +++ b/include/mts/MTS_Component.h @@ -0,0 +1,84 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Component.h + \brief A threaded sub-pub object + \date 28MAR12 + \author Sean Godinez + + A threaded subscriber-publisher object. + */ + +#ifndef _MTS_COMPONENT_H_ +#define _MTS_COMPONENT_H_ + +#include <mts/MTS_Thread.h> +#include <mts/MTS_NonCopyable.h> +#include <mts/MTS_SubscriberQueue.h> +#include <mts/MTS_BasicPublisher.h> +#include <mts/MTS_Stdint.h> +#include <string> + +namespace MTS { + + template<class S, class P> class Component: public Thread { + + public: + virtual ~Component(); + + Subscriber<S>& getSubscriber(); + Publisher<P>& getPublisher(); + + virtual void stop(); + + protected: + explicit Component(const std::string& sName, uint32_t iCapacity = UINT32_MAX, bool bManaged = true); + + SubscriberQueue<S> m_oSubscriber; + BasicPublisher<P> m_oPublisher; + + private: + + }; + + template<class S, class P> Component<S, P>::Component( + const std::string& name, uint32_t capacity, bool managed) + : Thread(name, managed), m_oSubscriber(name, capacity) { + } + + template<class S, class P> Component<S, P>::~Component() { + Component::stop(); + } + + template<class S, class P> Subscriber<S>& Component<S, P>::getSubscriber() { + return m_oSubscriber; + } + + template<class S, class P> Publisher<P>& Component<S, P>::getPublisher() { + return m_oPublisher; + } + + template<class S, class P> void Component<S, P>::stop() { + Thread::stop(); + m_oSubscriber.clear(); + } +} + +#endif diff --git a/include/mts/MTS_Condition.h b/include/mts/MTS_Condition.h new file mode 100644 index 0000000..c15acd0 --- /dev/null +++ b/include/mts/MTS_Condition.h @@ -0,0 +1,75 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Condition.h + \brief A condition that can be waited on or signaled + \date 15JUN11 + \author Sean Godinez + + A platform independent condition that can be waited on or signaled. + */ + +#ifndef _MTS_CONDITION_H_ +#define _MTS_CONDITION_H_ + +#include <mts/MTS_Stdint.h> +#include <mts/MTS_AutoPtr.h> +#include <mts/MTS_NonCopyable.h> + +#ifdef WIN32 +#include <windows.h> +#else +#include <pthread.h> +#endif + +namespace MTS { + + class Lock; + + //! A condition + /*! + A platform independent condition that can be waited on or signaled. Useful in building semaphores. + + \sa Lock + */ + class Condition: private NonCopyable { + friend class Lock; + + public: + ~Condition(); //!< Destructs the Condition + + void wait(); //!< Waits on *this Condition for signal + void wait(uint32_t millis); //!< Waits on *this Condition for signal or given amount of time + void signal(); //!< Signals *this Condition + + private: + + Lock* m_pLock; //!< Lock that created *this Condition +#ifdef WIN32 + AutoPtr<HANDLE> m_apCondition; //!< Handle to WIN32 Condition +#else + AutoPtr<pthread_cond_t> m_apCondition; //!< Handle to PTHREAD Condition +#endif + + explicit Condition(Lock* lock); //!< Explicit Constructor! Must pass Lock as parent. + }; +} + +#endif diff --git a/include/mts/MTS_Lock.h b/include/mts/MTS_Lock.h new file mode 100644 index 0000000..c35b131 --- /dev/null +++ b/include/mts/MTS_Lock.h @@ -0,0 +1,76 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Lock.h + \brief A mutex lock + \date 15JUN11 + \author Sean Godinez + + A platform independent mutex lock. + */ + +#ifndef _MTS_LOCK_H_ +#define _MTS_LOCK_H_ + +#include <mts/MTS_NonCopyable.h> +#include <mts/MTS_Condition.h> +#include <mts/MTS_AutoPtr.h> + +#ifdef WIN32 +#include <windows.h> +#else +#include <pthread.h> +#endif + +namespace MTS { + + //! A mutex lock + /*! + A platform independent mutex lock + + \sa Condition + */ + + class Lock: private NonCopyable { + + public: + Lock(); //!< Constructs the Lock + ~Lock(); //!< Destructs the Lock + + void lock(); //!< Locks the mutex + void unlock(); //!< Unlocks the mutex + + bool isLocked() const; //!< Returns true if locked + + Condition* createCondition(); //!< Creates a Condition object associated with *this Lock + + private: + friend class Condition; + volatile bool m_bLocked; //!< Locks the mutex +#ifdef WIN32 + AutoPtr<HANDLE> m_apMutex; //!< WIN32 Mutex Handle +#else + AutoPtr<pthread_mutex_t> m_apMutex; //!< PTHREAD Mutex Handle + AutoPtr<pthread_mutexattr_t> m_apMutexAttr; //!< PTHREAD Mutex Attributes +#endif + }; +} + +#endif diff --git a/include/mts/MTS_Logger.h b/include/mts/MTS_Logger.h new file mode 100644 index 0000000..a1e88a2 --- /dev/null +++ b/include/mts/MTS_Logger.h @@ -0,0 +1,161 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Logger.h + \brief A logging utility + \date 15JUN11 + \author Sean Godinez + + A logging utility capable of writing to stdout, syslog, or file + */ +#ifndef MTS_LOGGER_H_ +#define MTS_LOGGER_H_ + +#include <mts/MTS_NonCopyable.h> +#include <mts/MTS_NonConstructable.h> +#include <mts/MTS_Lock.h> +#include <mts/MTS_Stdint.h> +#include <string> + +#ifdef DEBUG +#define printFatal(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::FATAL_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::FATAL_LEVEL, MTS::Logger::PrintLevel::FATAL_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#define printError(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::ERROR_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::ERROR_LEVEL, MTS::Logger::PrintLevel::ERROR_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#define printWarning(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::WARNING_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::WARNING_LEVEL, MTS::Logger::PrintLevel::WARNING_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#define printInfo(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::INFO_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::INFO_LEVEL, MTS::Logger::PrintLevel::INFO_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#define printConfig(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::CONFIG_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::CONFIG_LEVEL, MTS::Logger::PrintLevel::CONFIG_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#define printDebug(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::DEBUG_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::DEBUG_LEVEL, MTS::Logger::PrintLevel::DEBUG_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#define printTrace(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::TRACE_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::TRACE_LEVEL, MTS::Logger::PrintLevel::TRACE_LABEL, "%s:%s:%d| " format, __FILE__, __func__, __LINE__, ##__VA_ARGS__) +#else +#define printFatal(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::FATAL_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::FATAL_LEVEL, MTS::Logger::PrintLevel::FATAL_LABEL, format, ##__VA_ARGS__) +#define printError(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::ERROR_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::ERROR_LEVEL, MTS::Logger::PrintLevel::ERROR_LABEL, format, ##__VA_ARGS__) +#define printWarning(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::WARNING_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::WARNING_LEVEL, MTS::Logger::PrintLevel::WARNING_LABEL, format, ##__VA_ARGS__) +#define printInfo(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::INFO_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::INFO_LEVEL, MTS::Logger::PrintLevel::INFO_LABEL, format, ##__VA_ARGS__) +#define printConfig(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::CONFIG_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::CONFIG_LEVEL, MTS::Logger::PrintLevel::CONFIG_LABEL, format, ##__VA_ARGS__) +#define printDebug(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::DEBUG_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::DEBUG_LEVEL, MTS::Logger::PrintLevel::DEBUG_LABEL, format, ##__VA_ARGS__) +#define printTrace(format, ...) \ + if (MTS::Logger::isPrintable(MTS::Logger::PrintLevel::TRACE_LEVEL)) \ + MTS::Logger::printfGeneric(MTS::Logger::PrintLevel::TRACE_LEVEL, MTS::Logger::PrintLevel::TRACE_LABEL, format, ##__VA_ARGS__) +#endif + +namespace MTS { + + class Logger: private NonCopyable { + + public: + + class PrintLevel: private NonConstructable { + public: + static const int32_t OFF_LEVEL; + static const int32_t MINIMUM_LEVEL; + static const int32_t FATAL_LEVEL; + static const int32_t ERROR_LEVEL; + static const int32_t WARNING_LEVEL; + static const int32_t INFO_LEVEL; + static const int32_t CONFIG_LEVEL; + static const int32_t DEBUG_LEVEL; + static const int32_t TRACE_LEVEL; + static const int32_t MAXIMUM_LEVEL; + + static const char* OFF_LABEL; + static const char* FATAL_LABEL; + static const char* ERROR_LABEL; + static const char* WARNING_LABEL; + static const char* INFO_LABEL; + static const char* CONFIG_LABEL; + static const char* DEBUG_LABEL; + static const char* TRACE_LABEL; + static const char* MAXIMUM_LABEL; + }; + + enum PrintMode { + NO_PRINTING, + STDOUT_ONLY, + FILE_ONLY, + SYSLOG_ONLY, + STDOUT_AND_FILE, + STDOUT_AND_SYSLOG + }; + + static int getPrintLevel(); + static const std::string& getPrintLevelString(); + static void setPrintLevel(int32_t level, bool silent = false); + static bool isPrintable(int32_t level); + + static void printfFatal(const char* format, ...); + static void printfError(const char* format, ...); + static void printfWarning(const char* format, ...); + static void printfInfo(const char* format, ...); + static void printfConfig(const char* format, ...); + static void printfDebug(const char* format, ...); + static void printfTrace(const char* format, ...); + static void printfGeneric(int level, const char* label, const char* format, ...); + + static void printf(int level, const char* format, ...); + static void printf(const char* format, ...); + + static bool setup(const PrintMode& mode); + static bool setup(const PrintMode& mode, const std::string& ident, const int& option, const int& facility); + static bool setup(const PrintMode& mode, const std::string& filename); + + private: + + static volatile int m_iPrintLevel; + static std::string m_sPrintLevel; + static Logger::PrintMode m_eMode; + static Lock m_oPrintLock; + static FILE* m_pFile; + static int m_iLogFacility; + static std::string m_sIdent; + static std::string m_sFileName; + + static int32_t syslogPrintLevelConversion(const int32_t& level); + static void printMessage(const int32_t& level, const char* label, const char* format, va_list argptr); + + Logger(); + }; +} + +#endif /* MTS_LOG_H_ */ diff --git a/include/mts/MTS_NonConstructable.h b/include/mts/MTS_NonConstructable.h new file mode 100644 index 0000000..ab69c1d --- /dev/null +++ b/include/mts/MTS_NonConstructable.h @@ -0,0 +1,47 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_NonConstructable.h + \brief Disables Constructors + \date May 7, 2012 + \author Sean Godinez + + Prevents this class from being constructed by anyone + */ + +#ifndef MTS_NONCONSTRUCTABLE_H_ +#define MTS_NONCONSTRUCTABLE_H_ + +namespace MTS { + + class NonConstructable { + protected: + + private: + // Do Not Allow Use of Any Constructors or the Assignment Operator + NonConstructable(); + ~NonConstructable(); + NonConstructable(const NonConstructable&); + const NonConstructable& operator=(const NonConstructable&); + }; + +} + +#endif /* MTS_NONCONSTRUCTABLE_H_ */ diff --git a/include/mts/MTS_NonCopyable.h b/include/mts/MTS_NonCopyable.h new file mode 100644 index 0000000..c5a772a --- /dev/null +++ b/include/mts/MTS_NonCopyable.h @@ -0,0 +1,47 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_NonCopyable.h + \brief Disables Copying + \date May 7, 2012 + \author Sean Godinez + + Prevents this class from being copied by anyone + */ +#ifndef _MTS_NONCOPYABLE_H_ +#define _MTS_NONCOPYABLE_H_ + +namespace MTS { + + class NonCopyable { + protected: + NonCopyable() { + } + ~NonCopyable() { + } + private: + // Do Not Allow Use of Copy Constructor or Assignment Operator + NonCopyable(const NonCopyable&); + const NonCopyable& operator=(const NonCopyable&); + }; + +} + +#endif /* _MTS_NONCOPYABLE_H_ */ diff --git a/include/mts/MTS_Object.h b/include/mts/MTS_Object.h new file mode 100644 index 0000000..4fd9d2d --- /dev/null +++ b/include/mts/MTS_Object.h @@ -0,0 +1,62 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Object.h + \brief An object + \date 28MAR12 + \author Sean Godinez + + A common base class to handle objects. + */ +#ifndef _MTS_OBJECT_H_ +#define _MTS_OBJECT_H_ + +#include <mts/MTS_Buffer.h> +#include <ostream> +#include <string> +#include <set> + +namespace MTS { + + //! An object + /*! + A common base class to handle objects + + \sa Buffer + */ + class Object { + + public: + virtual ~Object(); //!< Destructs object + + virtual void encode(Buffer& buffer) const = 0; //!< Encodes object into byte buffer + virtual void decode(Buffer& buffer) = 0; //!< Decodes object from byte buffer + virtual void copy(const Object& object) = 0; //!< Copies another object + virtual Object* clone() const = 0; //!< Clones object + + virtual std::string toString() const; //!< Generates a string of the object + virtual std::string toIDD() const; //!< Generates a string of the object type id + + protected: + Object(); //!< Constructor of object + }; +} + +#endif diff --git a/include/mts/MTS_Publisher.h b/include/mts/MTS_Publisher.h new file mode 100644 index 0000000..8b0fcee --- /dev/null +++ b/include/mts/MTS_Publisher.h @@ -0,0 +1,130 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Publisher.h + \brief An abstract publisher + \date 28MAR12 + \author Sean Godinez + + A publisher base class. Requires derived class to handle publishing. + */ +#ifndef _MTS_PUBLISHER_H_ +#define _MTS_PUBLISHER_H_ + +#include <mts/MTS_Subscriber.h> +#include <mts/MTS_AutoPtr.h> +#include <mts/MTS_Lock.h> +#include <mts/MTS_Logger.h> +#include <mts/MTS_NonCopyable.h> +#include <set> + +namespace MTS { + + //! An abstract publisher + /*! + A template abstract publisher class + + \sa Subscriber + */ + template<class T> class Publisher: NonCopyable { + + public: + virtual ~Publisher(); //!< Destructs subscriber + + void addSubscriber(Subscriber<T>& subscriber); //!< Adds a subscriber + void removeSubscriber(Subscriber<T>& subscriber); //!< Removes a subscriber + + protected: + Publisher(); //!< Constructs publisher + virtual void publish(const T& object); //!< Protects publishing operation + + private: + typedef std::set<Subscriber<T>*> SubscriberSet; + + AutoPtr<Lock> m_apLock; //!< Guards for thread safety + SubscriberSet m_sSubscribers; //!< Set of subscribers + + }; + + template<class T> Publisher<T>::Publisher() { + m_apLock.reset(new Lock()); + } + + template<class T> Publisher<T>::~Publisher() { + m_apLock.reset(); + } + + template<class T> void Publisher<T>::addSubscriber( + Subscriber<T>& subscriber) { + + m_apLock->lock(); + m_sSubscribers.insert(&subscriber); + + /* + + //WARNING IF ALREADY PRESENT IN SET + pair<set<T>::iterator,bool> ret; + ret = m_sSubscribers.insert(&subscriber); + if (ret.second==false) { + Logger::printWarning("subscriber already in set %s (%p)", + subscriber->getName().c_str(), subscriber); + } + + */ + + m_apLock->unlock(); + } + + template<class T> void Publisher<T>::removeSubscriber( + Subscriber<T>& subscriber) { + m_apLock->lock(); + m_sSubscribers.erase(&subscriber); + + /* + + //WARNING IF SUBSCRIBER WAS NOT IN SET + uint32_t count = m_sSubscribers.erase(&subscriber); + if (count == 0) { + Logger::printWarning("subscriber was not in set %s (%p)", + subscriber->getName().c_str(), subscriber); + } + + */ + + m_apLock->unlock(); + } + + template<class T> void Publisher<T>::publish(const T& object) { + m_apLock->lock(); + SubscriberSet set(m_sSubscribers); + for (typename SubscriberSet::iterator i = set.begin(); i != set.end(); i++) { + Subscriber<T>* subscriber = *i; + try { + subscriber->update(object); + } catch (...) { + printWarning("Publisher| exception caught while updating subscriber %s (%p)", + subscriber->getName().c_str(), subscriber); + } + } + m_apLock->unlock(); + } +} + +#endif diff --git a/include/mts/MTS_Queue.h b/include/mts/MTS_Queue.h new file mode 100644 index 0000000..aa59e51 --- /dev/null +++ b/include/mts/MTS_Queue.h @@ -0,0 +1,215 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Queue.h + \brief A queue + \date 15JUN11 + \author Sean Godinez + + A thread-safe queue with condition signaling + */ +#ifndef _MTS_QUEUE_H_ +#define _MTS_QUEUE_H_ + +#include <mts/MTS_NonCopyable.h> +#include <mts/MTS_AutoPtr.h> +#include <mts/MTS_Lock.h> +#include <mts/MTS_Logger.h> +#include <mts/MTS_Stdint.h> +#include <queue> +#include <cassert> + +namespace MTS { + + //! A queue + /*! + A thread-safe, blocking, template queue that signals when it is not empty, and when it is not full. + + \sa AutoPtr, Lock + */ + template<class T> class Queue : public NonCopyable { + + public: + explicit Queue(uint32_t capacity = UINT32_MAX); //!< Constructs the queue + ~Queue(); //!< Destructs the queue + + bool empty() const; //!< Returns true if queue is empty + bool full() const; //!< Returns true if queue is full + uint32_t size() const; //!< Returns the number of elements in the queue + uint32_t capacity() const; //!< Returns the maximum capacity of the queue + + void push(const T& object); //!< Pushes an object on the queue (BLOCKS IF FULL) + void pop(T& object); //!< Pops an object off the queue (BLOCKS IF EMPTY) + + bool offer(const T& object, uint32_t waitMillis); + bool poll(T& object, uint32_t waitMillis); + bool peek(T& object, uint32_t waitMillis); + + private: + const uint32_t m_iMaxSize; + std::queue<T> m_qContainer; + AutoPtr<Lock> m_apLock; + AutoPtr<Condition> m_apNotEmpty; + AutoPtr<Condition> m_apNotFull; + }; + + template<class T> Queue<T>::Queue(uint32_t capacity) + : m_iMaxSize(capacity) { + m_apLock.reset(new Lock()); + m_apNotEmpty.reset(m_apLock->createCondition()); + m_apNotFull.reset(m_apLock->createCondition()); + } + + template<class T> Queue<T>::~Queue() { + m_apNotFull.reset(); + m_apNotEmpty.reset(); + m_apLock.reset(); + } + + template<class T> bool Queue<T>::empty() const { + bool result = false; + m_apLock->lock(); + result = m_qContainer.empty(); + m_apLock->unlock(); + return result; + } + + template<class T> bool Queue<T>::full() const { + bool result = false; + m_apLock->lock(); + result = (m_qContainer.size() >= m_iMaxSize); + m_apLock->unlock(); + return result; + } + + template<class T> uint32_t Queue<T>::size() const { + uint32_t result = 0; + m_apLock->lock(); + result = static_cast<uint32_t>(m_qContainer.size()); + m_apLock->unlock(); + return result; + } + + template<class T> uint32_t Queue<T>::capacity() const { + return m_iMaxSize; + } + + template<class T> void Queue<T>::push(const T& object) { + // Block forever until there is room on the queue + m_apLock->lock(); + try { + while (m_qContainer.size() >= m_iMaxSize) { + m_apNotFull->wait(); + } + m_qContainer.push(object); + m_apNotEmpty->signal(); + } catch (...) { + printWarning("Queue| failed to push object"); + assert(false); + } + m_apLock->unlock(); + } + + template<class T> void Queue<T>::pop(T& object) { + //Block on not-empty condition if empty + m_apLock->lock(); + while (m_qContainer.empty()) { + m_apNotEmpty->wait(); + } + object = m_qContainer.front(); + m_qContainer.pop(); + m_apNotFull->signal(); + m_apLock->unlock(); + } + + //! Attempts to push an object onto the queue within the given milliseconds + /*! + \param object an object to push onto the queue + \param waitMillis the amount of milliseonds to wait if the queue is full + \return Returns true if the object was pushed onto the queue, false otherwise + \sa push() + */ + template<class T> bool Queue<T>::offer(const T& object, + uint32_t waitMillis) { + bool result = false; + m_apLock->lock(); + try { + if (waitMillis > 0 && m_qContainer.size() >= m_iMaxSize) { + m_apNotFull->wait(waitMillis); + } + if (m_qContainer.size() < m_iMaxSize) { + m_qContainer.push(object); + m_apNotEmpty->signal(); + result = true; + } + } catch (...) { + printWarning("Queue| failed to offer object"); + assert(false); + } + m_apLock->unlock(); + return result; + } + + //! Attempts to pop an object from the queue within the given milliseconds + /*! + \param object if successful, a reference to the object that was popped + \param waitMillis the amount of milliseonds to wait if the queue is empty + \return Returns true if an object was popped from the queue, false otherwise + \sa pop(), peek() + */ + template<class T> bool Queue<T>::poll(T& object, uint32_t waitMillis) { + bool result = false; + m_apLock->lock(); + if (waitMillis > 0 && m_qContainer.empty()) { + m_apNotEmpty->wait(waitMillis); + } + if (!m_qContainer.empty()) { + object = m_qContainer.front(); + m_qContainer.pop(); + m_apNotFull->signal(); + result = true; + } + m_apLock->unlock(); + return result; + } + + //! Attempts to view the top of the queue within the given milliseconds + /*! + \param object if successful, a reference to the object that is at the head of the queue + \param waitMillis the amount of milliseonds to wait if the queue is empty + \return Returns true if there is an object in the queue, false otherwise + \sa pop(), poll() + */ + template<class T> bool Queue<T>::peek(T& object, uint32_t waitMillis) { + bool result = false; + m_apLock->lock(); + if (waitMillis > 0 && m_qContainer.empty()) { + m_apNotEmpty->wait(waitMillis); + } + if (!m_qContainer.empty()) { + object = m_qContainer.front(); + result = true; + } + m_apLock->unlock(); + return result; + } +} + +#endif diff --git a/include/mts/MTS_SharedPtr.h b/include/mts/MTS_SharedPtr.h new file mode 100644 index 0000000..0fd670e --- /dev/null +++ b/include/mts/MTS_SharedPtr.h @@ -0,0 +1,137 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_SharedPtr.h + \brief A shared pointer template + \date 15JUN11 + \author Sean Godinez + + A shared pointer template + */ + +#ifndef _MTS_SHAREDPTR_H +#define _MTS_SHAREDPTR_H + +namespace MTS { + + //! A shared pointer + /*! + A shared pointer keeps track of references and + cleans up when the reference count reaches zero + */ + template<class T> class SharedPtr { + + public: + + enum MallocType { + SINGLE, ARRAY + }; + + explicit SharedPtr(T* ptr = 0, MallocType type = SINGLE); //!< Explicitly Constructs the SharedPtr to reference ptr + SharedPtr(const SharedPtr<T>& other); //!< Constructs from another shared pointer, increasing reference count + ~SharedPtr(); //!< Destructs the AutoPtr deleting T + + SharedPtr<T>& operator=(const SharedPtr<T>& other); //!< Releases *this and shares other's T + + T& operator*() const; //!< Returns T + T* operator->() const; //!< Returns address of T + T& operator[](const uint32_t& index) const; //!< Returns T at index + T* get() const; //!< Returns address of T + + bool isNull() const; //!< Returns true if pointer is NULL + bool isShared() const; //!< Returns true if reference count is greater than 1 + int count() const; //!< Returns number of references + + private: + + T* m_pObj; //!< Reference to class T + int* m_pReferences; //!< Reference to reference count + MallocType m_eType; //!< Describes memory allocated as a single T or block of Ts + + void release(); + }; + + template<class T> SharedPtr<T>::SharedPtr(T* ptr, MallocType type) + : m_pObj(ptr), m_pReferences(new int(1)), m_eType(type) { + } + + template<class T> SharedPtr<T>::SharedPtr(const SharedPtr<T>& other) + : m_pObj(other.m_pObj), m_pReferences(other.m_pReferences) { + *(m_pReferences) += 1; + } + + template<class T> SharedPtr<T>::~SharedPtr() { + release(); + } + + template<class T> SharedPtr<T>& SharedPtr<T>::operator=( + const SharedPtr<T>& other) { + if (&other != this) { + release(); + this->m_pObj = other.m_pObj; + this->m_pReferences = other.m_pReferences; + this->m_eType = other.m_eType; + (*m_pReferences) += 1; + } + return *this; + } + + template<class T> T& SharedPtr<T>::operator*() const { + return *m_pObj; + } + + template<class T> T* SharedPtr<T>::operator->() const { + return m_pObj; + } + + template<class T> T& SharedPtr<T>::operator[](const uint32_t& index) const { + return m_pObj[index]; + } + + template<class T> T* SharedPtr<T>::get() const { + return m_pObj; + } + + template<class T> bool SharedPtr<T>::isNull() const { + return (m_pObj == 0); + } + + template<class T> bool SharedPtr<T>::isShared() const { + return ((*m_pReferences) > 1); + } + + template<class T> int SharedPtr<T>::count() const { + return (*m_pReferences); + } + + template<class T> void SharedPtr<T>::release() { + (*m_pReferences) -= 1; + if ((*m_pReferences) == 0) { + if (m_eType == SINGLE) { + delete m_pObj; + } else { + delete[] m_pObj; + } + delete m_pReferences; + } + } +} + +#endif diff --git a/include/mts/MTS_SignalThread.h b/include/mts/MTS_SignalThread.h new file mode 100644 index 0000000..5f6aab4 --- /dev/null +++ b/include/mts/MTS_SignalThread.h @@ -0,0 +1,74 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_SignalThread.h + \brief An abstract worker thread + \date 01MAR13 + \author Mike Fiore + + A platform independent thread that executes a task when it is signaled. + */ + +#ifndef _MTS_SIGNAL_THREAD_H_ +#define _MTS_SIGNAL_THREAD_H_ + +#include <mts/MTS_Thread.h> +#include <mts/MTS_AutoPtr.h> +#include <mts/MTS_Lock.h> +#include <mts/MTS_Condition.h> + +namespace MTS { + + //! An abstract worker thread + /*! + A platform independent worker thread class + */ + + class SignalThread: public Thread { + + public: + + ~SignalThread(); //!< Destructs the thread + + bool isExecuting() const; //!< Returns true if the thread is currently running executing the execute() function + + void signal(); //!< Instructs the thread to run the execute() function + + protected: + + explicit SignalThread(const std::string& name); //!< Creates the thread + explicit SignalThread(const std::string& name, uint32_t waitMillis); //!< Creates the thread + + private: + + void run(); //!< Abstracts the running of the thread + virtual void execute() = 0; //!< main() of the thread which is executed each time signal() is called + void init(); //!< Startup code common to all constructors + + AutoPtr<Lock> m_apStateLock; //!< Condition Lock + AutoPtr<Lock> m_apConditionLock; //!< Condition Lock + AutoPtr<Condition> m_apCondition; //!< Condition for signaling and waiting + bool m_bShouldExecute; //!< Should execute flag + bool m_bCurrentlyExecuting; //!< Currently executing flag + uint32_t m_ui32WaitMillis; //!< Max time to wait on condition before checking for shutdown + }; +} + +#endif diff --git a/include/mts/MTS_Singleton.h b/include/mts/MTS_Singleton.h new file mode 100644 index 0000000..463d1c0 --- /dev/null +++ b/include/mts/MTS_Singleton.h @@ -0,0 +1,77 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Singleton.h + \brief A Documented file. + \date 2011-06-20 + \author Sean Godinez + + Details. + */ + +#ifndef _MTS_SINGLETON_H_ +#define _MTS_SINGLETON_H_ + +#include <mts/MTS_Lock.h> + +namespace MTS { + + template<class T> class Singleton { + + public: + + static T* instance(); + + protected: + + private: + static T* m_pInstance; + static AutoPtr<Lock> m_apLock; + + // Do Not Allow Use of Any Constructor or Assignment Operator + Singleton() { + } + ~Singleton(); + Singleton(const Singleton&); + Singleton& operator=(const Singleton&); + }; + + template<class T> Singleton<T>::~Singleton() { + m_apLock.reset(); + delete T; + } + + template<class T> T* Singleton<T>::instance() { + + m_apLock->lock(); + if (m_pInstance == NULL) { + m_pInstance = new T(); + } + m_apLock->unlock(); + + return m_pInstance; + } + + //FIXME: Template Initialization + template<class T> static AutoPtr<Lock> Singleton<T>::m_apLock.reset(new Lock()); + template<class T> static T* Singleton<T>::m_pInstance = NULL; +} + +#endif /* MTS_SINGLETON_H_ */ diff --git a/include/mts/MTS_Stdint.h b/include/mts/MTS_Stdint.h new file mode 100644 index 0000000..9a6885b --- /dev/null +++ b/include/mts/MTS_Stdint.h @@ -0,0 +1,104 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Stdint.h + \brief A set of defined types + \date 28MAR12 + \author Sean Godinez + + A set of defined types + */ +#ifndef MTS_STDINT_H +#define MTS_STDINT_H + +#ifdef WIN32 +typedef __int8 int8_t; +typedef __int16 int16_t; +typedef __int32 int32_t; +typedef __int64 int64_t; + +typedef unsigned __int8 uint8_t; +typedef unsigned __int16 uint16_t; +typedef unsigned __int32 uint32_t; +typedef unsigned __int64 uint64_t; + +#ifndef INT8_MIN +#define INT8_MIN (-127i8 - 1) +#endif + +#ifndef INT16_MIN +#define INT16_MIN (-32767i16 - 1) +#endif + +#ifndef INT32_MIN +#define INT32_MIN (-2147483647i32 - 1) +#endif + +#ifndef INT64_MIN +#define INT64_MIN (-9223372036854775807i64 - 1) +#endif + +#ifndef INT8_MAX +#define INT8_MAX (127i8) +#endif + +#ifndef INT16_MAX +#define INT16_MAX (32767i16) +#endif + +#ifndef INT32_MAX +#define INT32_MAX (2147483647i32) +#endif + +#ifndef INT64_MAX +#define INT64_MAX (9223372036854775807i64) +#endif + +#ifndef UINT8_MAX +#define UINT8_MAX (0xffui8) +#endif + +#ifndef UINT16_MAX +#define UINT16_MAX (0xffffui16) +#endif + +#ifndef UINT32_MAX +#define UINT32_MAX (0xffffffffui32) +#endif + +#ifndef UINT64_MAX +#define UINT64_MAX (0xffffffffffffffffui64) +#endif + +#elif __cplusplus +#ifdef STDINT +#ifndef __STDC_LIMIT_MACROS +#define __STDC_LIMIT_MACROS +#endif +#include <stdint.h> +#else +#include <cstdint> +#endif +#else +#include <stdint.h> +#endif + +#endif + diff --git a/include/mts/MTS_Subscriber.h b/include/mts/MTS_Subscriber.h new file mode 100644 index 0000000..e359d4c --- /dev/null +++ b/include/mts/MTS_Subscriber.h @@ -0,0 +1,71 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Subscriber.h + \brief An abstract subscriber + \date 28MAR12 + \author Sean Godinez + + A subscriber. + */ +#ifndef _MTS_SUBSCRIBER_H_ +#define _MTS_SUBSCRIBER_H_ + +#include <mts/MTS_NonCopyable.h> +#include <string> + +namespace MTS { + + //! An abstract subscriber + /*! + A template abstract subscriber class + + \sa Publisher + */ + template<class T> class Subscriber: NonCopyable { + + public: + virtual ~Subscriber(); //!< Destructs subscriber + + const std::string& getName() const; //!< Returns name + + virtual void update(const T& object) = 0; //!< Updates subscriber + + protected: + explicit Subscriber(const std::string& name = ""); //!< Protected Constructor + + private: + const std::string m_sName; //!< Name of subscriber + + }; + + template<class T> Subscriber<T>::Subscriber(const std::string& name) + : m_sName(name) { + } + + template<class T> Subscriber<T>::~Subscriber() { + } + + template<class T> const std::string& Subscriber<T>::getName() const { + return m_sName; + } +} + +#endif diff --git a/include/mts/MTS_SubscriberQueue.h b/include/mts/MTS_SubscriberQueue.h new file mode 100644 index 0000000..d070841 --- /dev/null +++ b/include/mts/MTS_SubscriberQueue.h @@ -0,0 +1,94 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_SubscriberQueue.h + \brief An template subscriber queue + \date 28MAR12 + \author Sean Godinez + + A subscriber queue. + */ + +#ifndef _MTS_SUBSCRIBERQUEUE_H_ +#define _MTS_SUBSCRIBERQUEUE_H_ + +#include <mts/MTS_Subscriber.h> +#include <mts/MTS_Queue.h> +#include <mts/MTS_Stdint.h> +#include <new> + +namespace MTS { + + template<class T> class SubscriberQueue: public Subscriber<T> { + + public: + explicit SubscriberQueue(const std::string& name, uint32_t capacity = UINT32_MAX); + virtual ~SubscriberQueue(); + + Queue<T*>& getQueue(); + void clear(); + + virtual void update(const T& object); + + private: + Queue<T*> m_oQueue; + + //Prevent Copy and Assignment operators from being called + SubscriberQueue(const SubscriberQueue&); + SubscriberQueue& operator=(const SubscriberQueue&); + }; + + template<class T> SubscriberQueue<T>::SubscriberQueue( + const std::string& name, uint32_t capacity) + : Subscriber<T>(name), m_oQueue(capacity) { + } + + template<class T> SubscriberQueue<T>::~SubscriberQueue() { + clear(); + } + + template<class T> Queue<T*>& SubscriberQueue<T>::getQueue() { + return m_oQueue; + } + + template<class T> void SubscriberQueue<T>::clear() { + while (!m_oQueue.empty()) { + T* object = 0; + m_oQueue.poll(object, 0); + delete object; + } + } + + template<class T> void SubscriberQueue<T>::update(const T& object) { + T* clone = object.clone(); + if (clone == 0) { + printWarning("SubQ| %s failed to clone object, out of memory", Subscriber<T>::getName().c_str()); + return; + } + bool ok = m_oQueue.offer(clone, 0); + if (!ok) { + delete clone; + printWarning("SubQ| %s queue full, dropping object", Subscriber<T>::getName().c_str()); + return; + } + } +} + +#endif diff --git a/include/mts/MTS_System.h b/include/mts/MTS_System.h new file mode 100644 index 0000000..a16265c --- /dev/null +++ b/include/mts/MTS_System.h @@ -0,0 +1,55 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_System.h + \brief System Utilities + \date 15JUN11 + \author Sean Godinez + + System utilities for time, endian, etc. + */ +#ifndef MTS_SYSTEM_H +#define MTS_SYSTEM_H + +#include <mts/MTS_NonConstructable.h> +#include <mts/MTS_Stdint.h> +#include <string> + +namespace MTS { + + class System: private NonConstructable { + + public: + + //UTC (Coordinated Universal Time) : This is the standard international time or the Greenwich Mean Time. + //EPOCH : number of seconds elapsed since 00:00:00 on January 1, 1970, Coordinated Universal Time. + + static uint64_t timeMicros(); + static uint64_t precisionTimeMicros(); + + static bool isBigEndian(); + static void swapBytes(uint8_t* const pBuffer, const uint32_t iSize); + + static int32_t cmd(const std::string& cmd, std::string& result); + static int32_t readFile(const std::string& path, std::string& result); + }; +} + +#endif diff --git a/include/mts/MTS_Text.h b/include/mts/MTS_Text.h new file mode 100644 index 0000000..2380add --- /dev/null +++ b/include/mts/MTS_Text.h @@ -0,0 +1,143 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Text.h + \brief A set of string formatting utilities + \date 15JUN11 + \author Sean Godinez + + A set of string formatting utilities + */ + +#ifndef MTS_TEXT_H_ +#define MTS_TEXT_H_ + +#include <mts/MTS_NonConstructable.h> +#include <mts/MTS_Stdint.h> +#include <mts/MTS_Buffer.h> +#include <sstream> +#include <string> +#include <vector> +#include <time.h> + +namespace MTS { + + class Text: private NonConstructable { + + public: + + enum DATEFORMAT { + MMsDDsYY, //MM/DD/YYYY + MMsDDsYY_HHcMMcSS, //MM/DD/YYYY HH:MM:SS:mmm + RFC_1123 //Wdy, DD Mon YYYY HH:MM:SS GMT (Thu, 01 Jan 1970 00:00:01 GMT) + }; + + enum TIMEFORMAT { + HHcMMcSScmmm, //HH:MM:SS:mmm + HHcMMcSS //HH:MM:SS + }; + + static const uint8_t RDSTATE_SUCCESS_MASK = 0x02; //Only OEF bit + + static std::string time(const uint64_t& iTimeMicros, const TIMEFORMAT& eTime = HHcMMcSScmmm); + static std::string date(const tm& stTime, const DATEFORMAT& eDate = MMsDDsYY); + static bool datetimeIsBefore(const std::string& time1, const std::string& time2); + + static std::vector<std::string> split(const std::string& str, char delimiter, int limit = 0); + static std::vector<std::string> split(const std::string& str, const std::string& delimiter, int limit = 0); + static std::string join(std::vector<std::string> list, char delimiter); + static std::string replace(const std::string& str, const std::string& from, const std::string& to); + static uint32_t count(const std::string& str, const std::string& element); + static uint32_t count(const std::string& str, const uint8_t& element); + static bool endsWith(const std::string& str, const std::string& key); + + static std::string getLine(const std::string& source, const size_t& start, size_t& cursor); + + static std::string trim(const std::string& str); + static std::string trim(const std::string& str, const uint8_t& element); + static std::string strip(const std::string& str, const std::vector<uint8_t>& elements); + static std::string strip(const std::string& str, const uint8_t& element); + + static std::string toLowerCase(const std::string& str); + static std::string toUpperCase(const std::string& str); + static std::string toCapitalized(const std::string& str); + static std::string toCamelCase(const std::string& str); + static std::string toCommandLineEscaped(const std::string& str); + + static std::wstring widen(const std::string& str); + static std::string narrow(const std::wstring& str); + + static std::string format(bool value); + static std::string format(double value, std::streamsize percision = 6); + + static std::string format(int8_t value); + static std::string format(int16_t value); + static std::string format(int32_t value); + static std::string format(int64_t value); + + static std::string format(uint8_t value); + static std::string format(uint16_t value); + static std::string format(uint32_t value); + static std::string format(uint64_t value); + + static std::string formatHex(int8_t value, bool pad = false); + static std::string formatHex(int16_t value, bool pad = false); + static std::string formatHex(int32_t value, bool pad = false); + static std::string formatHex(int64_t value, bool pad = false); + + static std::string formatHex(uint8_t value, bool pad = false); + static std::string formatHex(uint16_t value, bool pad = false); + static std::string formatHex(uint32_t value, bool pad = false); + static std::string formatHex(uint64_t value, bool pad = false); + + static std::string formatHex(const Buffer& value); + + static bool parse(bool& value, const std::string& str); + static bool parse(double& value, const std::string& str); + + static bool parse(int8_t& value, const std::string& str); + static bool parse(int16_t& value, const std::string& str); + static bool parse(int32_t& value, const std::string& str); + static bool parse(int64_t& value, const std::string& str); + + static bool parse(uint8_t& value, const std::string& str); + static bool parse(uint16_t& value, const std::string& str); + static bool parse(uint32_t& value, const std::string& str); + static bool parse(uint64_t& value, const std::string& str); + + static bool parseHex(uint8_t& value, const std::string& str); + static bool parseHex(uint16_t& value, const std::string& str); + static bool parseHex(uint32_t& value, const std::string& str); + static bool parseHex(uint64_t& value, const std::string& str); + + template<typename S, typename T> + static bool lexicalCast(S source, T& target) { + std::stringstream interpreter; + if(!(interpreter << source) || + !(interpreter >> target) || + !(interpreter >> std::ws).eof()) { + return false; + } + return true; + } + }; +} + +#endif diff --git a/include/mts/MTS_Thread.h b/include/mts/MTS_Thread.h new file mode 100644 index 0000000..7a3472c --- /dev/null +++ b/include/mts/MTS_Thread.h @@ -0,0 +1,105 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_Thread.h + \brief A thread + \date 15JUN11 + \author Sean Godinez + + A platform independent thread. + */ +#ifndef _MTS_THREAD_H_ +#define _MTS_THREAD_H_ + +#include <mts/MTS_AutoPtr.h> +#include <mts/MTS_Lock.h> +#include <mts/MTS_Condition.h> +#include <mts/MTS_Stdint.h> +#include <mts/MTS_NonCopyable.h> +#include <string> + +#ifdef WIN32 +#include <windows.h> +#else +#include <pthread.h> +#endif + +namespace MTS { + + //! An abstract thread + /*! + A platform independent abstract thread class + + \sa Condition, Lock + */ + + class Thread: private NonCopyable { + + public: + + virtual ~Thread(); //!< Destructs thread + + static void sleep(uint32_t iMillis); //!< Pauses calling thread for the given amount of milliseconds + + const std::string& getName() const; //!< Returns the name of thread + + virtual void start(); //!< Starts thread + virtual void stop(); //!< Ends thread + + void wait(); //!< Block until *this thread has finished executing + void wait(uint32_t millis); //!< Waits on signal for *this thread to finish executing or time is up + + bool isAlive() const; //!< Returns true if it is still running + bool isCanceled() const; //!< Returns true if it has been told to shutdown + bool isDone() const; //!< Returns true if it finished running + bool isManaged() const; //!< Returns true if it should not Destruct itself when done running + + protected: + explicit Thread(const std::string& name, bool managed = true); //!< Explicit Constructor + + private: + +#ifdef WIN32 + static DWORD WINAPI doInBackground(__in LPVOID lpParameter); //!< WIN32 function callback + HANDLE m_pThread;//!< WIN32 Thread Handle +#else + static void* doInBackground(void* parameters); //!< PTHREAD function callback + pthread_t* m_pThread; //!< PTHREAD Thread Handle +#endif + + const std::string m_sName; //!< Thread's name + const bool m_bManaged; //!< Self-cleanup flag + bool m_bComplete; //!< Completed flag + bool m_bCanceled; //!< Canceled/Shutdown flag + + AutoPtr<Lock> m_apThreadLock; //!< Thread Lock + AutoPtr<Lock> m_apStateLock; //!< State Lock + AutoPtr<Condition> m_apCompleteCondition; //!< Thread Completed Condition/Signal + + void cancel(); //!< Cancels thread by setting Canceled/Shutdown flag + void done(); //!< Triggers Thread Completed Condition/Signal + void reset(); //!< Resets Canceled and Completed flags + + + virtual void run() = 0; //!< main() of *this Thread + }; +} + +#endif diff --git a/include/mts/MTS_Timer.h b/include/mts/MTS_Timer.h new file mode 100644 index 0000000..3f0b0e5 --- /dev/null +++ b/include/mts/MTS_Timer.h @@ -0,0 +1,66 @@ +/* + * 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/>. + * + */ + +/*! + \file MTS_Timer.h + \brief Tracks passage of time + \date Jan 3, 2014 + \author sgodinez + + Useful for tracking time and timeout loops + */ + +#ifndef MTS_TIMER_H_ +#define MTS_TIMER_H_ + +#include <mts/MTS_Stdint.h> + +namespace MTS { + + class Timer { + + public: + Timer(); + virtual ~Timer(); + + void start(); + void stop(); + void pause(); + void resume(); + void reset(); + + bool isRunning(); + + uint64_t getMicros(); + uint64_t getMillis(); + uint64_t getSeconds(); + uint64_t getMinutes(); + + protected: + + private: + uint64_t m_iStart; + uint64_t m_iPause; + bool m_bStarted; + bool m_bPaused; + }; +} + +#endif /* MTS_TIMER_H_ */ diff --git a/include/mts/MTS_TimerThread.h b/include/mts/MTS_TimerThread.h new file mode 100644 index 0000000..28e3e73 --- /dev/null +++ b/include/mts/MTS_TimerThread.h @@ -0,0 +1,77 @@ +/* + * 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/>. + * + */ + +/*! \file MTS_TimerThread.h + \brief An abstract worker thread + \date 10MAY13 + \author Mike Fiore + + A platform independent thread that executes a task every x miliseconds. + Thread can be paused and unpaused. + */ + +#ifndef _MTS_TIMER_THREAD_H_ +#define _MTS_TIMER_THREAD_H_ + +#include <mts/MTS_Thread.h> +#include <mts/MTS_AutoPtr.h> +#include <mts/MTS_Lock.h> + +namespace MTS { + + //! An abstract worker thread + /*! + A platform independent worker thread class + */ + + class TimerThread: public Thread { + + public: + + ~TimerThread(); //!< Destructs the thread + + virtual bool isExecuting() const; //!< Returns true if the thread has been started + + virtual void stopExecution(); //!< Stops running execute() function + + virtual void restartExecution(); //!< Resumes running execute() function + + virtual void updateIntervalMillis(uint32_t newMillis); //!< Updates interval to given value + + protected: + + explicit TimerThread(const std::string& name); //!< Creates the thread + + explicit TimerThread(const std::string& name, uint32_t intervalMillis); //!< Creates the thread + + private: + + void run(); //!< Abstracts the running of the thread + virtual void execute() = 0; //!< main() of the thread which is executed once per interval + void init(); //!< Startup code common to all constructors + + AutoPtr<Lock> m_apStateLock; //!< Condition Lock + bool m_bCurrentlyExecuting; //!< Currently executing flag + bool m_bExecutionStopped; //!< Execution stopped flag + uint32_t m_ui32IntervalMillis; //!< How often the thread executes + }; +} + +#endif |