Nothing about function. I added a bunch of docs and re-arranged a bunch of

the existing docs.  Taking advantage of some of the cooler extra features of
doxygen I've started writing extra how-to pages covering working with sections
of the library.  Also, I started grouping the classes by function so they show
up on the Modules page together, very cute.

1 files changed, 32 insertions, 29 deletions

diff --git a/src/itoqueue.h b/src/itoqueue.h
index 5945344..1a4e0b6 100644
--- a/src/itoqueue.h
+++ b/src/itoqueue.h
@@ -16,6 +16,7 @@ namespace Bu
          * something is enqueued within the specified time limit, or NULL if the
          * time limit is exceded.
          *@author Mike Buland
+         *@ingroup Threading Containers
          */
         template <class T>
         class ItoQueue
@@ -59,11 +60,11 @@ namespace Bu
                 }
 
                 /**
-                 * Enqueue a pieces of data.  The new data will go at the end of the queue,
-                 * and unless another piece of data is enqueued, will be the last piece of
-                 * data to be dequeued.
-                 *@param pData The data to enqueue.  If this is not a primitive data type
-                 * it's probably best to use a pointer type.
+                 * Enqueue a pieces of data.  The new data will go at the end of the
+                 * queue, and unless another piece of data is enqueued, will be the
+                 * last piece of data to be dequeued.
+                 *@param pData The data to enqueue.  If this is not a primitive data
+                 * type it's probably best to use a pointer type.
                  */
                 void enqueue( T pData )
                 {
@@ -91,20 +92,22 @@ namespace Bu
                 }
 
                 /**
-                 * Dequeue the first item from the queue.  This function can operate in two
-                 * different modes, blocking and non-blocking.  In non-blocking mode it will
-                 * return immediately weather there was data in the queue or not.  If there
-                 * was data it will remove it from the queue and return it to the caller.
-                 * In blocking mode it will block forever wating for data to be enqueued.
-                 * When data finally is enqueued this function will return immediately with
-                 * the new data.  The only way this function should ever return a null in
-                 * blocking mode is if the calling thread was cancelled.  It's probably a
-                 * good idea to check for NULL return values even if you use blocking, just
-                 * to be on the safe side.
-                 *@param bBlock Set to true to enable blocking, leave as false to work in
-                 * non-blocking mode.
-                 *@returns The next piece of data in the queue, or NULL if no data was in
-                 * the queue.
+                 * Dequeue the first item from the queue.  This function can operate in
+                 * two different modes, blocking and non-blocking.  In non-blocking
+                 * mode it will return immediately weather there was data in the queue
+                 * or not.  If there was data it will remove it from the queue and
+                 * return it to the caller.
+                 *
+                 * In blocking mode it will block forever wating for data to be
+                 * enqueued.  When data finally is enqueued this function will return
+                 * immediately with the new data.  The only way this function should
+                 * ever return a null in blocking mode is if the calling thread was
+                 * cancelled.  It's probably a good idea to check for NULL return
+                 * values even if you use blocking, just to be on the safe side.
+                 *@param bBlock Set to true to enable blocking, leave as false to work
+                 * in non-blocking mode.
+                 *@returns The next piece of data in the queue, or NULL if no data was
+                 * in the queue.
                  */
                 T dequeue( bool bBlock=false )
                 {
@@ -143,15 +146,15 @@ namespace Bu
                 }
 
                 /**
-                 * Operates just like the other dequeue function in blocking mode with one
-                 * twist.  This function will block for at most nSec seconds and nUSec
-                 * micro-seconds.  If the timer is up and no data is available, this will
-                 * just return NULL.  If data is enqueued before the timeout expires, it
-                 * will dequeue and exit immediately.
+                 * Operates just like the other dequeue function in blocking mode with
+                 * one twist.  This function will block for at most nSec seconds and
+                 * nUSec micro-seconds.  If the timer is up and no data is available,
+                 * this will just return NULL.  If data is enqueued before the timeout
+                 * expires, it will dequeue and exit immediately.
                  *@param nSec The number of seconds to wait, max.
                  *@param nUSec The number of micro-seconds to wait, max.
-                 *@returns The next piece of data in the queue, or NULL if the timeout was
-                 * exceeded.
+                 *@returns The next piece of data in the queue, or NULL if the timeout
+                 * was exceeded.
                  */
                 T dequeue( int nSec, int nUSec )
                 {
@@ -195,9 +198,9 @@ namespace Bu
                 }
 
                 /**
-                 * Checks to see if the queue has data in it or not.  Note that there is no
-                 * function to determine the length of the queue.  This data isn't kept
-                 * track of.  If you really need to know, fix this.
+                 * Checks to see if the queue has data in it or not.  Note that there
+                 * is no function to determine the length of the queue.  This data
+                 * isn't kept track of.  If you really need to know, fix this.
                  *@returns True if the queue is empty, false if it has data in it.
                  */
                 bool isEmpty()