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

/*]  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 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 SDL_Thread* Thread;

typedef boost::function<int(void)> Function;


inline int detach_(void* arg)
{
        //Function function = *(Function*)arg;
        int code = (*(Function*)arg)();

        delete (Function*)arg;
        return code;
}

inline Thread detachFunction(const Function& function)
{
        Function* fcopy = new Function(function);
        Thread thread = SDL_CreateThread(detach_, (void*)fcopy);

    if (thread == 0) delete fcopy;
        return thread;
}


inline int waitOnThread(Thread thread)
{
        int i;
        SDL_WaitThread(thread, &i);
        return i;
}

inline void killThread(Thread thread)
{
        SDL_KillThread(thread);
}


//
// The identifier function returns a unique integer for the calling thread.
//

inline unsigned getThreadIdentifier()
{
    return SDL_ThreadID();
}

inline unsigned getThreadIdentifier(Thread thread)
{
    return SDL_GetThreadID(thread);
}


//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

class Mutex
{
    friend class Condition;

public:

    Mutex()
        {
                mMutex = SDL_CreateMutex();
        }
    ~Mutex()
        {
                SDL_DestroyMutex(mMutex);
        }

    bool acquireLock()
        {
                return (SDL_LockMutex(mMutex) == 0);
        }
    bool releaseLock()
        {
                return (SDL_UnlockMutex(mMutex) == 0);
        }

    class Lock
    {
        friend class Condition;

    public:

        Lock(Mutex& mutex)
                {
                        mMutex = &mutex;
                        mIsLocked = false;
                }
        ~Lock()
                {
                        if (mIsLocked) release();
                }

        bool acquire()
                {
                        return (mIsLocked = mMutex->acquireLock());
                }
        bool release()
                {
                        return mMutex->releaseLock();
                        mIsLocked = false;
                }

        bool isLocked() const
                {
                        return mIsLocked;
                }

    protected:

        Mutex*  mMutex;
        bool    mIsLocked;
    };

    class ScopedLock : public Lock
    {
        public:

                ScopedLock(Mutex& mutex) :
                        Lock(mutex)
                {
                        acquire();
                }
    };

private:

    SDL_mutex* mMutex;
};


class Condition
{
public:

    Condition()
        {
                condition_ = SDL_CreateCond();
        }
    ~Condition()
        {
                SDL_DestroyCond(condition_);
        }

    bool wait(Mutex::Lock& lock)
        {
        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.mMutex->mMutex, ms) == 0);
        }

    bool notify()
        {
                return (SDL_CondSignal(condition_) == 0);
        }
    bool notifyAll()
        {
                return (SDL_CondBroadcast(condition_) == 0);
        }

private:

    SDL_cond* condition_;
};


class Semaphore
{
public:

    Semaphore(unsigned int value)
        {
                semaphore_ = SDL_CreateSemaphore(value);
        }
    ~Semaphore()
        {
                SDL_DestroySemaphore(semaphore_);
        }

    bool acquireLock()
        {
                return (SDL_SemWait(semaphore_) == 0);
        }
    bool releaseLock()
        {
                return (SDL_SemPost(semaphore_) == 0);
        }

    bool tryLock()
        {
                return (SDL_SemTryWait(semaphore_) == 0);
        }
        bool tryLock(unsigned ms)
        {
                // TODO for consistency, this function should take seconds
                return (SDL_SemWaitTimeout(semaphore_, ms) == 0);
        }
    
    class Lock
    {
    public:

        Lock(Semaphore& semaphore)
                {
                        semaphore_ = &semaphore;
                        mIsLocked = false;
                }
        ~Lock()
                {
                        if (mIsLocked) release();
                }
        
        bool acquire()
                {
                        return (mIsLocked = semaphore_->acquireLock());
                }
        bool release()
                {
                        return semaphore_->releaseLock(); mIsLocked = false;
                }

        bool isLocked() const
                {
                        return mIsLocked;
                }
        
    protected:

        Semaphore*      semaphore_;
        bool            mIsLocked;
    };
    
    class ScopedLock : public Lock
    {
    public:

        ScopedLock(Semaphore& semaphore) :
                        Lock(semaphore)
                {
                        acquire();
                }
    };

private:

    SDL_sem* semaphore_;
};


} // namespace Mf

#endif // _MOOF_THREAD_HH_