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, 33 insertions, 30 deletions

diff --git a/src/ito.h b/src/ito.h
index c062052..4ed2c8b 100644
--- a/src/ito.h
+++ b/src/ito.h
@@ -6,11 +6,12 @@
 namespace Bu
 {
         /**
-         * Simple thread class.  This wraps the basic pthread (posix threads) system in
-         * an object oriented sort of way.  It allows you to create a class with
-         * standard member variables and callable functions that can be run in it's own
-         * thread, one per class instance.
+         * Simple thread class.  This wraps the basic pthread (posix threads)
+         * system in an object oriented sort of way.  It allows you to create a
+         * class with standard member variables and callable functions that can be
+         * run in it's own thread, one per class instance.
          *@author Mike Buland
+         *@ingroup Threading
          */
         class Ito
         {
@@ -27,24 +28,26 @@ namespace Bu
 
                 /**
                  * Begin thread execution.  This will call the overridden run function,
-                 * which will simply execute in it's own thread until the function exits,
-                 * the thread is killed, or the thread is cancelled (optionally).  The
-                 * thread started in this manner has access to all of it's class variables,
-                 * but be sure to protect possible multiple-access with ItoMutex objects.
-                 *@returns True if starting the thread was successful.  False if something
-                 * went wrong and the thread has not started.
+                 * which will simply execute in it's own thread until the function
+                 * exits, the thread is killed, or the thread is cancelled (optionally).
+                 * The thread started in this manner has access to all of it's class
+                 * variables, but be sure to protect possible multiple-access with
+                 * ItoMutex objects.
+                 * @returns True if starting the thread was successful.  False if
+                 * something went wrong and the thread has not started.
                  */
                 bool start();
 
                 /**
-                 * Forcibly kill a thread.  This is not generally considered a good thing to
-                 * do, but in those rare cases you need it, it's invaluable.  The problem
-                 * with stopping (or killing) a thread is that it stops it the moment you
-                 * call stop, no matter what it's doing.  The object oriented approach to
-                 * this will help clean up any class variables that were used, but anything
-                 * not managed as a member variable will probably create a memory leak type
-                 * of situation.  Instead of stop, consider using cancel, which can be
-                 * handled by the running thread in a graceful manner.
+                 * Forcibly kill a thread.  This is not generally considered a good
+                 * thing to do, but in those rare cases you need it, it's invaluable.
+                 * The problem with stopping (or killing) a thread is that it stops it
+                 * the moment you call stop, no matter what it's doing.  The object
+                 * oriented approach to this will help clean up any class variables
+                 * that were used, but anything not managed as a member variable will
+                 * probably create a memory leak type of situation.  Instead of stop,
+                 * consider using cancel, which can be handled by the running thread in
+                 * a graceful manner.
                  *@returns True if the thread was stopped, false otherwise.  When this
                  * function returns the thread may not have stopped, to ensure that the
                  * thread has really stopped, call join.
@@ -52,11 +55,11 @@ namespace Bu
                 bool stop();
 
                 /**
-                 * The workhorse of the Ito class.  This is the function that will run in
-                 * the thread, when this function exits the thread dies and is cleaned up
-                 * by the system.  Make sure to read up on ItoMutex, ItoCondition, and
-                 * cancel to see how to control and protect everything you do in a safe way
-                 * within this function.
+                 * The workhorse of the Ito class.  This is the function that will run
+                 * in the thread, when this function exits the thread dies and is
+                 * cleaned up by the system.  Make sure to read up on ItoMutex,
+                 * ItoCondition, and cancel to see how to control and protect
+                 * everything you do in a safe way within this function.
                  *@returns I'm not sure right now, but this is the posix standard form.
                  */
                 virtual void *run()=0;
@@ -64,13 +67,13 @@ namespace Bu
                 /**
                  * Join the thread in action.  This function performs what is commonly
                  * called a thread join.  That is that it effectively makes the calling
-                 * thread an the Ito thread contained in the called object one in the same,
-                 * and pauses the calling thread until the called thread exits.  That is,
-                 * when called from, say, your main(), mythread.join() will not return until
-                 * the thread mythread has exited.  This is very handy at the end of
-                 * programs to ensure all of your data was cleaned up.
-                 *@returns True if the thread was joined, false if the thread couldn't be
-                 * joined, usually because it isn't running to begin with.
+                 * thread an the Ito thread contained in the called object one in the
+                 * same, and pauses the calling thread until the called thread exits.
+                 * That is, when called from, say, your main(), mythread.join() will
+                 * not return until the thread mythread has exited.  This is very handy
+                 * at the end of programs to ensure all of your data was cleaned up.
+                 *@returns True if the thread was joined, false if the thread couldn't
+                 * be joined, usually because it isn't running to begin with.
                  */
                 bool join();