Removed ProductionQueue.hpp since the functionality was moved to

threading.hpp in CodeDweller.


git-svn-id: https://svn.microneil.com/svn/SNFMilter/trunk@5 2c985dca-31e6-41a4-b4a2-d8f5b7f8e074

ProductionQueue.hpp

@@ -1,48 +0,0 @@
-// ProductionQueue.hpp
-// Copyright (C) 2007 MicroNeil Research Corporation
-// See www.armresearch.com for the copyright terms.
-//
-// A ProductionQueue is a templated, thread safe mechanism for implementing
-// a producer/consumer relationship. The objects in the queue should be simple
-// data so that they can be created, destroyed, and copied without trouble. Put
-// another way - the objects in the ProductionQueue should be lightweight
-// handles for other things. Those things should be created and destroyed
-// elsewhere.
-
-#include <queue>
-#include "threading.hpp"
-
-using namespace std;
-
-template<typename T>                                                                // Templatized
-class ProductionQueue {                                                         // Production Queue Class
-  private:
-    Mutex myMutex;                                                              // Contains a mutex and
-    volatile int LatestSize;                                                    // a volatile (blinking light) size
-    ProductionGateway myGateway;                                                // integrated with a production
-    queue<T> myQueue;                                                           // gateway and a queue.
-
-  public:
-    ProductionQueue() : LatestSize(0) {}                                        // The size always starts at zero.
-
-    T take() {                                                                  // To consume a queued object
-        myGateway.consume();                                                    // we wait on the production gateway
-        ScopeMutex OneAtATimePlease(myMutex);                                   // and when we get through we lock
-        T O = myQueue.front();                                                  // the mutext, take the object on the
-        myQueue.pop();                                                          // front of the queue, pop it out,
-        LatestSize = myQueue.size();                                            // and rest our size (blinking light).
-        return O;                                                               // Then return the object we got.
-    }
-
-    void give(T O) {                                                            // To produce a queued object
-        ScopeMutex OneAtATimePlease(myMutex);                                   // we wait on the mutex. When we
-        myQueue.push(O);                                                        // get through we push our object
-        LatestSize = myQueue.size();                                            // into the queue, reset our size
-        myGateway.produce();                                                    // indicator and tell the gateway.
-    }                                                                           // When we're done it can be grabbed.
-
-    int size() {                                                                // To check the size we look at
-        return LatestSize;                                                      // the blinking light.
-    }
-};
-