minor refactoring and state progress

[chaz/yoink] / src / Moof / Thread.hh

diff --git a/src/Moof/Thread.hh b/src/Moof/Thread.hh
index a5e02254fe4a43b0de769e5b14a4c2eca125beba..74952fa3411e99e211c971ce005ac36e406dcbb0 100644 (file)
--- a/src/Moof/Thread.hh
+++ b/src/Moof/Thread.hh
@@ -31,7 +31,7 @@
 
 /**
  * @file Thread.hh
- * Light C++ wrapper around SDL threads.
+ * Light C++ wrapper around the SDL threads API.
  */
 
 #include <boost/function.hpp>
@@ -51,34 +51,33 @@ typedef SDL_Thread* Thread;
 typedef boost::function<int(void)> Function;
 
 
-int detach_(void* arg)
+inline int detach_(void* arg)
 {
-       Function function = *(Function*)arg;
-       int ret = function();
+       //Function function = *(Function*)arg;
+       int code = (*(Function*)arg)();
 
        delete (Function*)arg;
-       return ret;
+       return code;
 }
 
-Thread detachFunction(const Function& function)
+inline Thread detachFunction(const Function& function)
 {
-       Thread thread;
        Function* fcopy = new Function(function);
+       Thread thread = SDL_CreateThread(detach_, (void*)fcopy);
 
-       thread = SDL_CreateThread(detach_, (void*)fcopy);
     if (thread == 0) delete fcopy;
        return thread;
 }
 
 
-int waitOnThread(Thread thread)
+inline int waitOnThread(Thread thread)
 {
        int i;
        SDL_WaitThread(thread, &i);
        return i;
 }
 
-void killThread(Thread thread)
+inline void killThread(Thread thread)
 {
        SDL_KillThread(thread);
 }
@@ -88,12 +87,12 @@ void killThread(Thread thread)
 // The identifier function returns a unique integer for the calling thread.
 //
 
-unsigned int getThreadIdentifier()
+inline unsigned getThreadIdentifier()
 {
     return SDL_ThreadID();
 }
 
-unsigned int getThreadIdentifier(Thread thread)
+inline unsigned getThreadIdentifier(Thread thread)
 {
     return SDL_GetThreadID(thread);
 }
@@ -106,22 +105,23 @@ class Mutex
     friend class Condition;
 
 public:
+
     Mutex()
        {
-               mutex_ = SDL_CreateMutex();
+               mMutex = SDL_CreateMutex();
        }
     ~Mutex()
        {
-               SDL_DestroyMutex(mutex_);
+               SDL_DestroyMutex(mMutex);
        }
 
     bool acquireLock()
        {
-               return (SDL_LockMutex(mutex_) == 0);
+               return (SDL_LockMutex(mMutex) == 0);
        }
     bool releaseLock()
        {
-               return (SDL_UnlockMutex(mutex_) == 0);
+               return (SDL_UnlockMutex(mMutex) == 0);
        }
 
     class Lock
@@ -129,39 +129,42 @@ public:
         friend class Condition;
 
     public:
+
         Lock(Mutex& mutex)
                {
-                       mutex_ = &mutex;
-                       isLocked_ = false;
+                       mMutex = &mutex;
+                       mIsLocked = false;
                }
         ~Lock()
                {
-                       if (isLocked_) release();
+                       if (mIsLocked) release();
                }
 
         bool acquire()
                {
-                       return (isLocked_ = mutex_->acquireLock());
+                       return (mIsLocked = mMutex->acquireLock());
                }
         bool release()
                {
-                       return mutex_->releaseLock();
-                       isLocked_ = false;
+                       return mMutex->releaseLock();
+                       mIsLocked = false;
                }
 
         bool isLocked() const
                {
-                       return isLocked_;
+                       return mIsLocked;
                }
 
     protected:
-        Mutex* mutex_;
-        bool   isLocked_;
+
+        Mutex* mMutex;
+        bool   mIsLocked;
     };
 
     class ScopedLock : public Lock
     {
        public:
+
                ScopedLock(Mutex& mutex) :
                        Lock(mutex)
                {
@@ -170,13 +173,15 @@ public:
     };
 
 private:
-    SDL_mutex* mutex_;
+
+    SDL_mutex* mMutex;
 };
 
 
 class Condition
 {
 public:
+
     Condition()
        {
                condition_ = SDL_CreateCond();
@@ -188,12 +193,12 @@ public:
 
     bool wait(Mutex::Lock& lock)
        {
-        return (SDL_CondWait(condition_, lock.mutex_->mutex_) == 0);
+        return (SDL_CondWait(condition_, lock.mMutex->mMutex) == 0);
     }
     bool wait(Mutex::Lock& lock, unsigned ms)
        {
                // TODO for consistency, this function should take seconds
-        return (SDL_CondWaitTimeout(condition_, lock.mutex_->mutex_, ms) == 0);
+        return (SDL_CondWaitTimeout(condition_, lock.mMutex->mMutex, ms) == 0);
        }
 
     bool notify()
@@ -206,6 +211,7 @@ public:
        }
 
 private:
+
     SDL_cond* condition_;
 };
 
@@ -213,6 +219,7 @@ private:
 class Semaphore
 {
 public:
+
     Semaphore(unsigned int value)
        {
                semaphore_ = SDL_CreateSemaphore(value);
@@ -244,38 +251,41 @@ public:
     class Lock
     {
     public:
+
         Lock(Semaphore& semaphore)
                {
                        semaphore_ = &semaphore;
-                       isLocked_ = false;
+                       mIsLocked = false;
                }
         ~Lock()
                {
-                       if (isLocked_) release();
+                       if (mIsLocked) release();
                }
         
         bool acquire()
                {
-                       return (isLocked_ = semaphore_->acquireLock());
+                       return (mIsLocked = semaphore_->acquireLock());
                }
         bool release()
                {
-                       return semaphore_->releaseLock(); isLocked_ = false;
+                       return semaphore_->releaseLock(); mIsLocked = false;
                }
 
         bool isLocked() const
                {
-                       return isLocked_;
+                       return mIsLocked;
                }
         
     protected:
+
         Semaphore*     semaphore_;
-        bool           isLocked_;
+        bool           mIsLocked;
     };
     
     class ScopedLock : public Lock
     {
     public:
+
         ScopedLock(Semaphore& semaphore) :
                        Lock(semaphore)
                {
@@ -284,6 +294,7 @@ public:
     };
 
 private:
+
     SDL_sem* semaphore_;
 };