Initial source commit

minorGems/util/CircularBuffer.h

@@ -0,0 +1,167 @@
+/*
+ * Modification History
+ *
+ * 2001-Janary-11	Jason Rohrer
+ * Created.
+ *
+ * 2001-Janary-12	Jason Rohrer
+ * Added canRead and canWrite functions.  
+ *
+ * 2001-February-24		Jason Rohrer
+ * Fixed incorrect delete usage.  
+ */
+
+#include "minorGems/common.h"
+
+
+ 
+#ifndef CIRCULAR_BUFFER_INCLUDED
+#define CIRCULAR_BUFFER_INCLUDED 
+
+
+#include "minorGems/system/Semaphore.h"
+
+
+/**
+ * Thread-safe circular buffer.
+ *
+ * @author Jason Rohrer 
+ */
+class CircularBuffer { 
+	
+	public:
+		
+		/**
+		 * Constructs a CircularBuffer.
+		 *
+		 * @param inSize the number of objects in this buffer.
+		 */
+		CircularBuffer( unsigned long inSize );
+		
+		
+		~CircularBuffer();
+		
+		
+		/**
+		 * Writes an object into the next free position in the buffer.
+		 * Blocks if no free positions are available.
+		 *
+		 * @param inObject the object pointer to write.
+		 */
+		void writeObject( void *inObject );
+		
+		
+		/**
+		 * Reads the next available object from the buffer.
+		 * Blocks if now objects are available.
+		 *
+		 * @return the object pointer read.
+		 */
+		void *readNextObject();
+		
+		
+		/**
+		 * Returns true if an object can be read from this buffer
+		 * without blocking.
+		 */
+		char canRead();
+		
+		
+		/**
+		 * Returns true if an object can be written to this buffer
+		 * without blocking.
+		 */
+		char canWrite();
+		
+		
+	private:
+		unsigned long mBufferSize;
+		
+		void **mObjects;
+		
+		unsigned long mReadIndex, mWriteIndex;
+		
+		// initialized to 0
+		Semaphore *mReadSemaphore;
+		
+		// initialized to mBufferSize;
+		Semaphore *mWriteSemaphore;
+		
+		MutexLock *mLock;
+	};
+
+
+
+inline CircularBuffer::CircularBuffer( unsigned long inSize ) 
+	: mBufferSize( inSize ), mObjects( new void*[inSize] ),
+	mReadIndex( 0 ), mWriteIndex( 0 ), 
+	mReadSemaphore( new Semaphore( 0 ) ), 
+	mWriteSemaphore( new Semaphore( inSize ) ),
+	mLock( new MutexLock() ) {
+	
+	}
+		
+
+		
+inline CircularBuffer::~CircularBuffer() {
+	delete [] mObjects;
+	delete mReadSemaphore;
+	delete mWriteSemaphore;
+	delete mLock;
+	}
+
+
+
+// note that in this implementation, no mutex is needed, since
+// reader and writer are never accessing the same data members
+// simultaneously
+
+inline void CircularBuffer::writeObject( void *inObject ) {
+	// wait to for a space to write into
+	mWriteSemaphore->wait();
+	
+	// write, and increment our write location
+	mObjects[ mWriteIndex ] = inObject;
+	mWriteIndex++;
+	mWriteIndex = mWriteIndex % mBufferSize;
+	
+	// signal the reader that an new object is ready
+	mReadSemaphore->signal();
+	}
+
+
+inline void *CircularBuffer::readNextObject() {
+	void *returnObject;
+	
+	// wait for an object to read
+	mReadSemaphore->wait();
+	
+	// read the object, and increment our read location
+	returnObject = mObjects[ mReadIndex ];
+	mReadIndex++;
+	mReadIndex = mReadIndex % mBufferSize;
+	
+	// signal the writer
+	mWriteSemaphore->signal();
+	
+	// now return the object that we retrieved from the buffer
+	return returnObject;
+	}
+
+
+
+inline char CircularBuffer::canRead() {
+	// can read if the read semaphore won't block
+	return ! mReadSemaphore->willBlock();
+	}
+
+
+		
+inline char CircularBuffer::canWrite() {
+	// can write if the write semaphore won't block
+	return ! mWriteSemaphore->willBlock();
+	}
+
+
+
+#endif