/**
* @file Thread.hh
- * Light C++ wrapper around SDL threads.
+ * Light C++ wrapper around the SDL threads API.
*/
#include <boost/function.hpp>
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);
}
// 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);
}
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
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)
{
};
private:
- SDL_mutex* mutex_;
+
+ SDL_mutex* mMutex;
};
class Condition
{
public:
+
Condition()
{
condition_ = SDL_CreateCond();
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()
}
private:
+
SDL_cond* condition_;
};
class Semaphore
{
public:
+
Semaphore(unsigned int value)
{
semaphore_ = SDL_CreateSemaphore(value);
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)
{
};
private:
+
SDL_sem* semaphore_;
};