Major clean-ups. Migrating to C++11.

[invirt/third/libt4.git] / rpc / fifo.h

diff --git a/rpc/fifo.h b/rpc/fifo.h
index 979cf62..d190c26 100644 (file)
--- a/rpc/fifo.h
+++ b/rpc/fifo.h
@@ -9,81 +9,69 @@
 #include <sys/time.h>
 #include <time.h>
 #include <errno.h>
-#include "slock.h"
 #include "lang/verify.h"
+#include "lock.h"
 
 template<class T>
 class fifo {
        public:
                fifo(int m=0);
-               ~fifo();
                bool enq(T, bool blocking=true);
                void deq(T *);
                bool size();
 
        private:
                std::list<T> q_;
-               pthread_mutex_t m_;
-               pthread_cond_t non_empty_c_; // q went non-empty
-               pthread_cond_t has_space_c_; // q is not longer overfull
+        mutex m_;
+        std::condition_variable non_empty_c_; // q went non-empty
+               std::condition_variable has_space_c_; // q is not longer overfull
                unsigned int max_; //maximum capacity of the queue, block enq threads if exceeds this limit
 };
 
 template<class T>
 fifo<T>::fifo(int limit) : max_(limit)
 {
-       VERIFY(pthread_mutex_init(&m_, 0) == 0);
-       VERIFY(pthread_cond_init(&non_empty_c_, 0) == 0);
-       VERIFY(pthread_cond_init(&has_space_c_, 0) == 0);
-}
-
-template<class T>
-fifo<T>::~fifo()
-{
-       //fifo is to be deleted only when no threads are using it!
-       VERIFY(pthread_mutex_destroy(&m_)==0);
-       VERIFY(pthread_cond_destroy(&non_empty_c_) == 0);
-       VERIFY(pthread_cond_destroy(&has_space_c_) == 0);
 }
 
 template<class T> bool
 fifo<T>::size()
 {
-       ScopedLock ml(&m_);
+    lock ml(m_);
        return q_.size();
 }
 
 template<class T> bool
 fifo<T>::enq(T e, bool blocking)
 {
-       ScopedLock ml(&m_);
+    lock ml(m_);
        while (1) {
                if (!max_ || q_.size() < max_) {
                        q_.push_back(e);
                        break;
                }
-               if (blocking)
-                       VERIFY(pthread_cond_wait(&has_space_c_, &m_) == 0);
+               if (blocking) {
+            has_space_c_.wait(ml);
+        }
                else
                        return false;
        }
-       VERIFY(pthread_cond_signal(&non_empty_c_) == 0);
+    non_empty_c_.notify_one();
        return true;
 }
 
 template<class T> void
 fifo<T>::deq(T *e)
 {
-       ScopedLock ml(&m_);
+       lock ml(m_);
 
        while(1) {
                if(q_.empty()){
-                       VERIFY (pthread_cond_wait(&non_empty_c_, &m_) == 0);
+            non_empty_c_.wait(ml);
                } else {
                        *e = q_.front();
                        q_.pop_front();
                        if (max_ && q_.size() < max_) {
-                               VERIFY(pthread_cond_signal(&has_space_c_)==0);
+                has_space_c_.notify_one();
                        }
                        break;
                }