-/*******************************************************************************
-
- Copyright (c) 2009, Charles McGarvey
- All rights reserved.
-
- Redistribution and use in source and binary forms, with or without
- modification, are permitted provided that the following conditions are met:
-
- * Redistributions of source code must retain the above copyright notice,
- this list of conditions and the following disclaimer.
- * Redistributions in binary form must reproduce the above copyright notice,
- this list of conditions and the following disclaimer in the documentation
- and/or other materials provided with the distribution.
-
- THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
- AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
- IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
- DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
- FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
- DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
- SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
- CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
- OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
- OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-*******************************************************************************/
+/*] Copyright (c) 2009-2010, Charles McGarvey [**************************
+**] All rights reserved.
+*
+* vi:ts=4 sw=4 tw=75
+*
+* Distributable under the terms and conditions of the 2-clause BSD license;
+* see the file COPYING for a complete text of the license.
+*
+**************************************************************************/
#ifndef _MOOF_THREAD_HH_
#define _MOOF_THREAD_HH_
/**
* @file Thread.hh
- * Light C++ wrapper around SDL threads.
+ * Light C++ wrapper around the SDL threads API.
*/
#include <boost/function.hpp>
-
#include <SDL/SDL.h>
namespace Mf {
+
//
// The detach function detaches a separate thread by calling 'func' with
// the 'arg' parameter.
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);
}
-// =============================================================================
+class AsyncTask
+{
+public:
+
+ virtual ~AsyncTask() {}
+
+ virtual bool isDone() const = 0;
+
+ virtual void run() = 0;
+ virtual int wait() = 0;
+};
+
+class ThreadedTask
+{
+public:
+
+ ThreadedTask() :
+ mThread(0) {}
+
+ Thread thread() const { return mThread; }
+
+ int wait()
+ {
+ int code = waitOnThread(mThread);
+ mThread = 0;
+ return code;
+ }
+
+
+protected:
+
+ Thread mThread;
+};
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
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
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_;
};
} // namespace Mf
-
#endif // _MOOF_THREAD_HH_
-/** vim: set ts=4 sw=4 tw=80: *************************************************/
-
projects / chaz / yoink / blobdiff