--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hti/PC_Tools/HTIGateway/HtiGateway/inc/safequeue.h Wed Oct 13 16:17:58 2010 +0300
@@ -0,0 +1,218 @@
+/*
+* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of "Eclipse Public License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.eclipse.org/legal/epl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description:
+* This file contains headers of SafeQueue template class.
+*/
+
+#ifndef SAFEQUEUE_H
+#define SAFEQUEUE_H
+
+#include "sync.h"
+
+//STL
+#pragma warning (push, 3)
+#pragma warning( disable : 4702 ) // Unreachable code warning
+#pragma warning( disable : 4290 ) // C++ exception specification ignored except to indicate a function is not __declspec(nothrow)
+#include <queue>
+
+
+
+
+using namespace std;
+class Data;
+
+//**********************************************************************************
+// Template Class SafeQueue
+//
+// This template class implements a thread safe queue with generic types
+//**********************************************************************************
+
+template <class T>
+class SafeQueue : private queue<T>,
+ private Mutex,
+ private Semaphore
+{
+public:
+ typedef typename queue<T>::size_type size_type;
+ SafeQueue();
+ ~SafeQueue();
+ /*
+ * Adds a new element to the end of the queue
+ */
+ void push(const T& val);
+ /*
+ * Removes the next element in the queue
+ */
+ void pop(void);
+ /*
+ * Returns whether the queue is empty or not
+ */
+ bool empty(void) const;
+ /*
+ * Returns a reference to the last element in the queue
+ */
+ T& back(DWORD timeout = INFINITE) throw (TimeoutException);
+ /*
+ * Returns a constant reference to the last element in the queue
+ */
+ const T& back(DWORD timeout = INFINITE) const throw (TimeoutException);
+ /*
+ * Returns a reference to the next element in the queue
+ */
+ T& front(DWORD timeout = INFINITE) throw (TimeoutException);
+ /*
+ * Returns a constant reference to the next element in the queue
+ */
+ const T& front(DWORD timeout = INFINITE) const throw (TimeoutException);
+ /*
+ * Returns the number of elements in the queue
+ */
+ typename SafeQueue<T>::size_type size(void) const;
+ /*
+ * This method is used to pop all of the elements in queue and return them in single Data object
+ */
+ T& popAll(DWORD timeout = INFINITE) throw (TimeoutException);
+};
+
+template <class T>
+SafeQueue<T>::SafeQueue()
+{
+}
+
+template <class T>
+SafeQueue<T>::~SafeQueue()
+{
+}
+
+/*
+ * Adds a new element to the end of the queue
+ */
+template <class T>
+void SafeQueue<T>::push(const T& val)
+{
+ Mutex::Lock();
+ queue<T>::push(val);
+ Mutex::Unlock();
+ Semaphore::Notify();
+}
+
+/*
+ * Removes the next element in the queue
+ */
+template <class T>
+void SafeQueue<T>::pop(void)
+{
+ Mutex::Lock();
+ queue<T>::pop();
+ Mutex::Unlock();
+}
+
+/*
+ * Returns whether the queue is empty or not
+ */
+template <class T>
+bool SafeQueue<T>::empty(void) const
+{
+ const_cast<SafeQueue<T>*>(this)->Lock();
+ bool value = queue<T>::empty();
+ const_cast<SafeQueue<T>*>(this)->Unlock();
+ return value;
+}
+
+/*
+ * Returns a reference to the last element in the queue
+ */
+template <class T>
+T& SafeQueue<T>::back(DWORD timeout)
+ throw (TimeoutException)
+{
+ if (Semaphore::Wait(timeout) == WAIT_TIMEOUT)
+ {
+ throw TimeoutException("queue back timed out");
+ }
+ Mutex::Lock();
+ T& value = queue<T>::back();
+ Mutex::Unlock();
+ return value;
+}
+
+/*
+ * Returns a constant reference to the last element in the queue
+ */
+template <class T>
+const T& SafeQueue<T>::back(DWORD timeout) const
+ throw (TimeoutException)
+{
+ if (const_cast<SafeQueue<T>*>(this)->Wait(timeout) == WAIT_TIMEOUT)
+ {
+ throw TimeoutException("queue back timed out");;
+ }
+ const_cast<SafeQueue<T>*>(this)->Lock();
+ const T& value = queue<T>::back();
+ const_cast<SafeQueue<T>*>(this)->Unlock();
+ return value;
+}
+
+/*
+ * Returns a reference to the next element in the queue
+ */
+template <class T>
+T& SafeQueue<T>::front(DWORD timeout)
+ throw (TimeoutException)
+{
+ if (Semaphore::Wait(timeout) == WAIT_TIMEOUT)
+ {
+ throw TimeoutException("queue front timed out");
+ }
+ Mutex::Lock();
+ T& value = queue<T>::front();
+ Mutex::Unlock();
+ return value;
+}
+
+/*
+ * Returns a constant reference to the next element in the queue
+ */
+template <class T>
+const T& SafeQueue<T>::front(DWORD timeout) const
+ throw (TimeoutException)
+{
+ if (const_cast<SafeQueue<T>*>(this)->Wait(timeout) == WAIT_TIMEOUT)
+ {
+ throw TimeoutException("queue front timed out");
+ }
+ const_cast<SafeQueue<T>*>(this)->Lock();
+ const T& value = queue<T>::front();
+ const_cast<SafeQueue<T>*>(this)->Unlock();
+ return value;
+}
+
+/*
+ * Returns the number of elements in the queue
+ */
+template <class T>
+typename SafeQueue<T>::size_type SafeQueue<T>::size(void) const
+{
+ const_cast<SafeQueue<T>*>(this)->Lock();
+ queue<T>::size_type value = queue<T>::size();
+ const_cast<SafeQueue<T>*>(this)->Unlock();
+ return value;
+}
+
+
+#pragma warning (pop)
+
+#endif
+
+// End of the file
\ No newline at end of file