Renamed most of the core threading system, some ancillary systems need some

kind of prefix or something, we could stick with Ito, I will until I think of
something else.

13 files changed, 105 insertions, 91 deletions

diff --git a/src/itocondition.cpp b/src/condition.cpp
index 3d8db60..2f55ce2 100644
--- a/src/itocondition.cpp
+++ b/src/condition.cpp
@@ -7,24 +7,24 @@
 
 #include <sys/time.h>
 
-#include "bu/itocondition.h"
+#include "bu/condition.h"
 
-Bu::ItoCondition::ItoCondition()
+Bu::Condition::Condition()
 {
         pthread_cond_init( &cond, NULL );
 }
 
-Bu::ItoCondition::~ItoCondition()
+Bu::Condition::~Condition()
 {
         pthread_cond_destroy( &cond );
 }
 
-int Bu::ItoCondition::wait()
+int Bu::Condition::wait()
 {
         return pthread_cond_wait( &cond, &mutex );
 }
 
-int Bu::ItoCondition::wait( int nSec, int nUSec )
+int Bu::Condition::wait( int nSec, int nUSec )
 {
         struct timeval now;
         struct timespec timeout;
@@ -37,12 +37,12 @@ int Bu::ItoCondition::wait( int nSec, int nUSec )
         return pthread_cond_timedwait( &cond, &mutex, &timeout );
 }
 
-int Bu::ItoCondition::signal()
+int Bu::Condition::signal()
 {
         return pthread_cond_signal( &cond );
 }
 
-int Bu::ItoCondition::broadcast()
+int Bu::Condition::broadcast()
 {
         return pthread_cond_broadcast( &cond );
 }
diff --git a/src/itocondition.h b/src/condition.h
index 88e8d6c..71634f5 100644
--- a/src/itocondition.h
+++ b/src/condition.h
@@ -5,25 +5,25 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#ifndef BU_ITO_CONDITION_H
-#define BU_ITO_CONDITION_H
+#ifndef BU_CONDITION_H
+#define BU_CONDITION_H
 
 #include <pthread.h>
 
-#include "itomutex.h"
+#include "bu/mutex.h"
 
 namespace Bu
 {
         /**
          * Ito condition.  This is a fairly simple condition mechanism.  As you may
-         * notice this class inherits from the ItoMutex class, this is because all
+         * notice this class inherits from the Mutex class, this is because all
          * conditions must be within a locked block.  The standard usage of a
          * condition is to pause one thread, perhaps indefinately, until another
          * thread signals that it is alright to procede.
          * <br>
          * Standard usage for the thread that wants to wait is as follows:
          * <pre>
-         * ItoCondition cond;
+         * Condition cond;
          * ... // Perform setup and enter your run loop
          * cond.lock();
          * while( !isFinished() ) // Could be anything you're waiting for
@@ -36,18 +36,18 @@ namespace Bu
          * or broadcast.  See both of those functions for the difference.
          *@ingroup Threading
          */
-        class ItoCondition : public ItoMutex
+        class Condition : public Mutex
         {
         public:
                 /**
                  * Create a condition.
                  */
-                ItoCondition();
+                Condition();
 
                 /**
                  * Destroy a condition.
                  */
-                ~ItoCondition();
+                ~Condition();
 
                 /**
                  * Wait forever, or until signalled.  This has to be called from within
diff --git a/src/itocounter.h b/src/itocounter.h
index 10df467..10126a5 100644
--- a/src/itocounter.h
+++ b/src/itocounter.h
@@ -8,7 +8,7 @@
 #ifndef BU_ITO_COUNTER_H
 #define BU_ITO_COUNTER_H
 
-#include "itomutex.h"
+#include "mutex.h"
 
 namespace Bu
 {
@@ -42,7 +42,7 @@ namespace Bu
 
         private:
                 T tCounter;                             /**< The counter itself. */
-                ItoMutex mOperate;      /**< The master mutex, used on all operations. */
+                Mutex mOperate; /**< The master mutex, used on all operations. */
         };
 }
 
diff --git a/src/itolocker.cpp b/src/itolocker.cpp
deleted file mode 100644
index 17e97fd..0000000
--- a/src/itolocker.cpp
+++ /dev/null
@@ -1,13 +0,0 @@
-#include "bu/itolocker.h"
-#include "bu/itomutex.h"
-
-Bu::ItoLocker::ItoLocker( Bu::ItoMutex &mu ) :
-        mu( mu )
-{
-        mu.lock();
-}
-
-Bu::ItoLocker::~ItoLocker()
-{
-        mu.unlock();
-}
diff --git a/src/itolocker.h b/src/itolocker.h
deleted file mode 100644
index 76e5198..0000000
--- a/src/itolocker.h
+++ /dev/null
@@ -1,18 +0,0 @@
-#ifndef BU_ITO_LOCKER_H
-#define BU_ITO_LOCKER_H
-
-namespace Bu
-{
-        class ItoMutex;
-        class ItoLocker
-        {
-        public:
-                ItoLocker( ItoMutex &mu );
-                virtual ~ItoLocker();
-
-        private:
-                ItoMutex & mu;
-        };
-};
-
-#endif
diff --git a/src/itoqueue.h b/src/itoqueue.h
index dc3cadb..039e09c 100644
--- a/src/itoqueue.h
+++ b/src/itoqueue.h
@@ -10,8 +10,8 @@
 
 #include <pthread.h>
 
-#include "itomutex.h"
-#include "itocondition.h"
+#include "mutex.h"
+#include "condition.h"
 
 namespace Bu
 {
@@ -232,8 +232,8 @@ namespace Bu
                 Item *pEnd;             /**< The end of the queue, the last element to dequeue. */
                 long nSize;             /**< The number of items in the queue. */
 
-                ItoMutex mOperate;      /**< The master mutex, used on all operations. */
-                ItoCondition cBlock;    /**< The condition for blocking dequeues. */
+                Mutex mOperate; /**< The master mutex, used on all operations. */
+                Condition cBlock;       /**< The condition for blocking dequeues. */
         };
 }
 
diff --git a/src/itoserver.h b/src/itoserver.h
index 902c684..75b3349 100644
--- a/src/itoserver.h
+++ b/src/itoserver.h
@@ -16,8 +16,8 @@
 
 #include "bu/string.h"
 #include "bu/list.h"
-#include "bu/ito.h"
-#include "bu/itomutex.h"
+#include "bu/thread.h"
+#include "bu/mutex.h"
 #include "bu/itoqueue.h"
 #include "bu/set.h"
 
@@ -50,7 +50,7 @@ namespace Bu
          * happening within the server itself, and actually makes it useful.
          *@ingroup Threading Serving
          */
-        class ItoServer : public Ito
+        class ItoServer : public Thread
         {
                 friend class ItoClient;
                 friend class SrvClientLinkFactory;
@@ -74,7 +74,7 @@ namespace Bu
 
         private:
                 class SrvClientLink;
-                class ItoClient : public Ito
+                class ItoClient : public Thread
                 {
                 friend class Bu::ItoServer::SrvClientLink;
                 public:
@@ -96,7 +96,7 @@ namespace Bu
                         int iPort;
                         int nTimeoutSec;
                         int nTimeoutUSec;
-                        ItoMutex imProto;
+                        Mutex imProto;
                 };
 
                 class SrvClientLink : public Bu::ClientLink
@@ -132,7 +132,7 @@ namespace Bu
                 typedef ItoQueue<ItoClient *> ClientQueue;
                 ClientHash hClients;
                 ClientQueue qClientCleanup;
-                ItoMutex imClients;
+                Mutex imClients;
 
                 void clientCleanup( int iSocket );
         };
diff --git a/src/itomutex.cpp b/src/mutex.cpp
index 8de6336..dbaaece 100644
--- a/src/itomutex.cpp
+++ b/src/mutex.cpp
@@ -5,29 +5,29 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/itomutex.h"
+#include "bu/mutex.h"
 
-Bu::ItoMutex::ItoMutex()
+Bu::Mutex::Mutex()
 {
         pthread_mutex_init( &mutex, NULL );
 }
 
-Bu::ItoMutex::~ItoMutex()
+Bu::Mutex::~Mutex()
 {
         pthread_mutex_destroy( &mutex );
 }
 
-int Bu::ItoMutex::lock()
+int Bu::Mutex::lock()
 {
         return pthread_mutex_lock( &mutex );
 }
 
-int Bu::ItoMutex::unlock()
+int Bu::Mutex::unlock()
 {
         return pthread_mutex_unlock( &mutex );
 }
 
-int Bu::ItoMutex::trylock()
+int Bu::Mutex::trylock()
 {
         return pthread_mutex_trylock( &mutex );
 }
diff --git a/src/itomutex.h b/src/mutex.h
index 68a0c1d..b5c8b7a 100644
--- a/src/itomutex.h
+++ b/src/mutex.h
@@ -5,8 +5,8 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#ifndef BU_ITO_MUTEX_H
-#define BU_ITO_MUTEX_H
+#ifndef BU_MUTEX_H
+#define BU_MUTEX_H
 
 #include <pthread.h>
 
@@ -19,13 +19,13 @@ namespace Bu
          * or initing them.
          *@ingroup Threading
          */
-        class ItoMutex
+        class Mutex
         {
         public:
                 /**
                  * Create an unlocked mutex.
                  */
-                ItoMutex();
+                Mutex();
                 
                 /**
                  * Destroy a mutex.  This can only be done when a mutex is unlocked.
@@ -33,7 +33,7 @@ namespace Bu
                  * wait for the mutex to unlock, the odds of which are usually farily
                  * low at deconstruction time.
                  */
-                ~ItoMutex();
+                ~Mutex();
 
                 /**
                  * Lock the mutex.  This causes all future calls to lock on this
diff --git a/src/mutexlocker.cpp b/src/mutexlocker.cpp
new file mode 100644
index 0000000..90b730e
--- /dev/null
+++ b/src/mutexlocker.cpp
@@ -0,0 +1,24 @@
+#include "bu/mutexlocker.h"
+#include "bu/mutex.h"
+
+Bu::MutexLocker::MutexLocker( Bu::Mutex &mu ) :
+        mu( mu )
+{
+        mu.lock();
+}
+
+Bu::MutexLocker::~MutexLocker()
+{
+        mu.unlock();
+}
+
+void Bu::MutexLocker::unlock()
+{
+        mu.unlock();
+}
+
+void Bu::MutexLocker::relock()
+{
+        mu.lock();
+}
+
diff --git a/src/mutexlocker.h b/src/mutexlocker.h
new file mode 100644
index 0000000..7c3c97e
--- /dev/null
+++ b/src/mutexlocker.h
@@ -0,0 +1,21 @@
+#ifndef BU_MUTEX_LOCKER_H
+#define BU_MUTEX_LOCKER_H
+
+namespace Bu
+{
+        class Mutex;
+        class MutexLocker
+        {
+        public:
+                MutexLocker( Mutex &mu );
+                virtual ~MutexLocker();
+
+                void unlock();
+                void relock();
+
+        private:
+                Mutex &mu;
+        };
+};
+
+#endif
diff --git a/src/ito.cpp b/src/thread.cpp
index aa9a597..e4563a2 100644
--- a/src/ito.cpp
+++ b/src/thread.cpp
@@ -5,51 +5,51 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#include "bu/ito.h"
+#include "bu/thread.h"
 
 #include "bu/config.h"
 
-Bu::Ito::Ito()
+Bu::Thread::Thread()
 {
 }
 
-Bu::Ito::~Ito()
+Bu::Thread::~Thread()
 {
 }
 
-bool Bu::Ito::start()
+bool Bu::Thread::start()
 {
         nHandle = pthread_create( &ptHandle, NULL, threadRunner, this );
 
         return true;
 }
 
-bool Bu::Ito::stop()
+bool Bu::Thread::stop()
 {
         pthread_cancel( ptHandle );
 
         return true;
 }
 
-void *Bu::Ito::threadRunner( void *pThread )
+void *Bu::Thread::threadRunner( void *pThread )
 {
-        ((Ito *)pThread)->run();
+        ((Thread *)pThread)->run();
         pthread_exit( NULL );
         return NULL;
 }
 
-bool Bu::Ito::join()
+bool Bu::Thread::join()
 {
         pthread_join( ptHandle, NULL );
         return true;
 }
 
-void Bu::Ito::yield()
+void Bu::Thread::yield()
 {
 #ifndef WIN32
         pthread_yield();
 #else
-        #warning Bu::Ito::yield IS A STUB for WIN32!!!! 
+        #warning Bu::Thread::yield IS A STUB for WIN32!!!!      
 #endif
 }
 
diff --git a/src/ito.h b/src/thread.h
index 9f50b2a..70e6f5f 100644
--- a/src/ito.h
+++ b/src/thread.h
@@ -5,8 +5,8 @@
  * terms of the license contained in the file LICENSE.
  */
 
-#ifndef BU_ITO_H
-#define BU_ITO_H
+#ifndef BU_THREAD_H
+#define BU_THREAD_H
 
 #include <pthread.h>
 
@@ -19,18 +19,18 @@ namespace Bu
          * run in it's own thread, one per class instance.
          *@ingroup Threading
          */
-        class Ito
+        class Thread
         {
         public:
                 /**
-                 * Construct an Ito thread.
+                 * Construct an Thread thread.
                  */
-                Ito();
+                Thread();
 
                 /**
-                 * Destroy an Ito thread.
+                 * Destroy an Thread thread.
                  */
-                virtual ~Ito();
+                virtual ~Thread();
 
                 /**
                  * Begin thread execution.  This will call the overridden run function,
@@ -38,7 +38,7 @@ namespace Bu
                  * 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.
+                 * ThreadMutex objects.
                  * @returns True if starting the thread was successful.  False if
                  * something went wrong and the thread has not started.
                  */
@@ -63,7 +63,7 @@ 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
+                 * thread an the Thread 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
@@ -79,10 +79,10 @@ namespace Bu
 
         protected:
                 /**
-                 * The workhorse of the Ito class.  This is the function that will run
+                 * The workhorse of the Thread 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
+                 * cleaned up by the system.  Make sure to read up on ThreadMutex,
+                 * ThreadCondition, 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.
                  */