minor refactoring and state progress

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

diff --git a/src/Moof/Thread.hh b/src/Moof/Thread.hh
index 274f717b057895c79cd10bacdcd46babcb199d67..74952fa3411e99e211c971ce005ac36e406dcbb0 100644 (file)
--- a/src/Moof/Thread.hh
+++ b/src/Moof/Thread.hh
@@ -105,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
@@ -128,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)
                {
@@ -169,13 +173,15 @@ public:
     };
 
 private:
-    SDL_mutex* mutex_;
+
+    SDL_mutex* mMutex;
 };
 
 
 class Condition
 {
 public:
+
     Condition()
        {
                condition_ = SDL_CreateCond();
@@ -187,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()
@@ -205,6 +211,7 @@ public:
        }
 
 private:
+
     SDL_cond* condition_;
 };
 
@@ -212,6 +219,7 @@ private:
 class Semaphore
 {
 public:
+
     Semaphore(unsigned int value)
        {
                semaphore_ = SDL_CreateSemaphore(value);
@@ -243,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)
                {
@@ -283,6 +294,7 @@ public:
     };
 
 private:
+
     SDL_sem* semaphore_;
 };