diff -r 7fdc9a71d314 -r 8ad140f3dd41 hti/PC_Tools/HTIGateway/HtiGateway/inc/safequeue.h
--- /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