X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FThread.hh;h=74952fa3411e99e211c971ce005ac36e406dcbb0;hp=a5e02254fe4a43b0de769e5b14a4c2eca125beba;hb=a31d65a998121df0651c57bfb68782e2a07d2e2f;hpb=c2321281bf12a7efaedde930422c7ddbc92080d4

diff --git a/src/Moof/Thread.hh b/src/Moof/Thread.hh
index a5e0225..74952fa 100644
--- 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_;
 };