initial commit

1 files changed, 215 insertions, 0 deletions

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