00001 #ifndef __THREADMESSAGEQUEUE_H 00002 #define __THREADMESSAGEQUEUE_H 00003 00004 #include <iostream> 00005 #include <list> 00006 #include "Mutex.h" 00007 #include "Condition.h" 00008 00009 template<class T> 00010 class ThreadMessageQueue 00011 { 00012 public: 00013 ThreadMessageQueue(); 00014 ~ThreadMessageQueue(); 00015 inline void add(T* object); 00016 inline T* getNext(); 00017 inline bool isEmpty(); 00018 inline int getLength(); 00019 void print(std::ostream&); 00020 00021 private: 00022 std::list<T*> m_queue; 00023 Condition m_ready; 00024 Mutex m_lock; 00025 }; 00026 00034 00035 #include "debug.h" 00036 00037 using namespace std; 00038 00042 template <class T> 00043 ThreadMessageQueue<T>::ThreadMessageQueue() 00044 { 00045 } // constructor 00046 00047 00051 template <class T> 00052 ThreadMessageQueue<T>::~ThreadMessageQueue() 00053 { 00054 Guard guard(&m_lock); 00055 m_queue.clear(); 00056 } // destructor 00057 00058 00062 template <class T> 00063 void ThreadMessageQueue<T>::add(T* object) 00064 { 00065 Guard guard(&m_lock); 00066 m_queue.push_back(object); 00067 m_ready.signal(); 00068 } // fn add 00069 00070 00075 template <class T> 00076 T* ThreadMessageQueue<T>::getNext() 00077 { 00078 Guard guard(&m_lock); 00079 00080 while (m_queue.empty()) 00081 { 00082 m_ready.wait(&m_lock); 00083 } 00084 T* object = m_queue.front(); 00085 m_queue.pop_front(); 00086 00087 return object; 00088 } // fn getNext 00089 00090 00094 template <class T> 00095 bool ThreadMessageQueue<T>::isEmpty() 00096 { 00097 return m_queue.empty(); 00098 } // fn isEmpty 00099 00100 00104 template <class T> 00105 int ThreadMessageQueue<T>::getLength() 00106 { 00107 return m_queue.size(); 00108 } // fn getLength 00109 00110 00114 template <class T> 00115 void ThreadMessageQueue<T>::print(std::ostream& out) 00116 { 00117 Guard guard(&m_lock); 00118 list<T*>::iterator iter; 00119 for (iter = m_queue.begin(); iter != m_queue.end(); ++iter) { 00120 out << **iter << "\n"; 00121 } 00122 } // fn print 00123 00124 #endif