1 files changed, 19 insertions, 18 deletions

diff --git a/src/itomutex.h b/src/itomutex.h
index 9c9d205..27ca125 100644
--- a/src/itomutex.h
+++ b/src/itomutex.h
@@ -7,10 +7,11 @@ namespace Bu
 {
         /**
          * Simple mutex wrapper.  Currently this doesn't do anything extra for you
-         * except keep all of the functionality together in an OO sorta' way and keep
-         * you from having to worry about cleaning up your mutexes properly, or initing
-         * them.
+         * except keep all of the functionality together in an OO sorta' way and
+         * keep you from having to worry about cleaning up your mutexes properly,
+         * or initing them.
          *@author Mike Buland
+         *@ingroup Threading
          */
         class ItoMutex
         {
@@ -23,33 +24,33 @@ namespace Bu
                 /**
                  * Destroy a mutex.  This can only be done when a mutex is unlocked.
                  * Failure to unlock before destroying a mutex object could cause it to
-                 * wait for the mutex to unlock, the odds of which are usually farily low
-                 * at deconstruction time.
+                 * wait for the mutex to unlock, the odds of which are usually farily
+                 * low at deconstruction time.
                  */
                 ~ItoMutex();
 
                 /**
-                 * Lock the mutex.  This causes all future calls to lock on this instance
-                 * of mutex to block until the first thread that called mutex unlocks it.
-                 * At that point the next thread that called lock will get a chance to go
-                 * to work.  Because of the nature of a mutex lock it is a very bad idea to
-                 * do any kind of serious or rather time consuming computation within a
-                 * locked section.  This can cause thread-deadlock and your program may
-                 * hang.
+                 * Lock the mutex.  This causes all future calls to lock on this
+                 * instance of mutex to block until the first thread that called mutex
+                 * unlocks it.  At that point the next thread that called lock will get
+                 * a chance to go to work.  Because of the nature of a mutex lock it is
+                 * a very bad idea to do any kind of serious or rather time consuming
+                 * computation within a locked section.  This can cause thread-deadlock
+                 * and your program may hang.
                  */
                 int lock();
 
                 /**
-                 * Unlock the mutex.  This allows the next thread that asked for a lock to
-                 * lock the mutex and continue with execution.
+                 * Unlock the mutex.  This allows the next thread that asked for a lock
+                 * to lock the mutex and continue with execution.
                  */
                 int unlock();
 
                 /**
-                 * Try to lock the mutex.  This is the option to go with if you cannot avoid
-                 * putting lengthy operations within a locked section.  trylock will attempt
-                 * to lock the mutex, if the mutex is already locked this function returns
-                 * immediately with an error code.
+                 * Try to lock the mutex.  This is the option to go with if you cannot
+                 * avoid putting lengthy operations within a locked section.  trylock
+                 * will attempt to lock the mutex, if the mutex is already locked this
+                 * function returns immediately with an error code.
                  */
                 int trylock();