X-Git-Url: https://git.dogcows.com/gitweb?p=chaz%2Fyoink;a=blobdiff_plain;f=src%2FMoof%2FThread.hh;h=3e0bd829a8affabd059f5b7b376779e7971e4fbf;hp=a5e02254fe4a43b0de769e5b14a4c2eca125beba;hb=41f8dd670e963aad94527ce2be0486268993a477;hpb=c2321281bf12a7efaedde930422c7ddbc92080d4 diff --git a/src/Moof/Thread.hh b/src/Moof/Thread.hh index a5e0225..3e0bd82 100644 --- a/src/Moof/Thread.hh +++ b/src/Moof/Thread.hh @@ -1,46 +1,29 @@ -/******************************************************************************* - - 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 - #include namespace Mf { + // // The detach function detaches a separate thread by calling 'func' with // the 'arg' parameter. @@ -51,34 +34,33 @@ typedef SDL_Thread* Thread; typedef boost::function 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,40 +70,76 @@ 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); } -// ============================================================================= +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 @@ -129,39 +147,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 +191,15 @@ public: }; private: - SDL_mutex* mutex_; + + SDL_mutex* mMutex; }; class Condition { public: + Condition() { condition_ = SDL_CreateCond(); @@ -188,12 +211,13 @@ 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 +230,7 @@ public: } private: + SDL_cond* condition_; }; @@ -213,6 +238,7 @@ private: class Semaphore { public: + Semaphore(unsigned int value) { semaphore_ = SDL_CreateSemaphore(value); @@ -244,38 +270,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,14 +313,12 @@ public: }; private: + SDL_sem* semaphore_; }; } // namespace Mf - #endif // _MOOF_THREAD_HH_ -/** vim: set ts=4 sw=4 tw=80: *************************************************/ -