/Users/ljp/code/gamma/trunk/Gamma/Thread.h

#ifndef GAMMA_THREAD_H_INC
#define GAMMA_THREAD_H_INC

/*  Gamma - Generic processing library
    See COPYRIGHT file for authors and license information */

/***************************************************/
/* \class Thread
    \brief STK thread class.

    This class provides a uniform interface for cross-platform
    threads.  On unix systems, the pthread library is used.  Under
    Windows, the C runtime threadex functions are used.

    Each instance of the Thread class can be used to control a single
    thread process.  Routines are provided to signal cancelation
    and/or joining with a thread, though it is not possible for this
    class to know the running status of a thread once it is started.

    For cross-platform compatability, thread functions should be
    declared as follows:

    THREAD_FUNCTION(thread_function_name)

    by Perry R. Cook and Gary P. Scavone, 1995 - 2005.
*/
/***************************************************/

namespace gam{

#define GAM_USE_PTHREAD     (defined (__APPLE__) || defined (OSX) || defined (__LINUX__) || defined (__UNIX__))
#define GAM_USE_THREADEX    (defined(WIN32))

#ifdef GAM_USE_PTHREAD
    #include <pthread.h>
#elif GAM_USE_THREADEX
    #include <windows.h>
    #include <process.h>
#endif

class Thread{
public:

    typedef void * (*Function)(void * user);

    #ifdef GAM_USE_PTHREAD
        typedef pthread_t       Handle;
    #elif GAM_USE_THREADEX
        typedef unsigned long   Handle;
    #endif

    Thread()
    :   mHandle(0), mJoinOnDestroy(false)
    {}
    
    Thread(Function func, void * user = NULL)
    :   mHandle(0), mJoinOnDestroy(false)
    {   start(func, user); }

    ~Thread(){
        if(mJoinOnDestroy) join();
    }


    bool start(Function func, void * user = NULL);

    
    bool cancel();

    
    bool join();


    Thread& joinOnDestroy(bool v){ mJoinOnDestroy=v; return *this; }

protected:
    Handle mHandle;
    bool mJoinOnDestroy;
};




// Implementation

#ifdef GAM_USE_PTHREAD

inline bool Thread::start(Thread::Function func, void * user){
    if(mHandle) return false;
    return 0 == pthread_create(&mHandle, NULL, *func, user);
}

inline bool Thread::cancel(){
    return 0 == pthread_cancel(mHandle);
}

inline bool Thread::join(){
    if(pthread_join(mHandle, NULL) == 0){
        mHandle = 0;
        return true;
    }
    return false;
}


#elif GAM_USE_THREADEX

inline bool Thread::start(Thread::Function func, void * user){
    if(mHandle) return false;
    
    struct F{
        Thread::Function func;
        void * user;

        static unsigned _stdcall * call(void * user){
            F& f = *(F*)user;
            f.func(f.userData);
            return 0;
        }
    } f = { func, user };
    
    unsigned thread_id;
    mHandle = _beginthreadex(NULL, 0, F::call, &f, 0, &thread_id);
    if(mHandle) return true;
    return false;
}

inline bool Thread::cancel(){
    TerminateThread((HANDLE)mHandle, 0);
    return true;
}

inline bool Thread::join(){
    long retval = WaitForSingleObject((HANDLE)mHandle, INFINITE);
    if(WAIT_OBJECT_0 == retval){
        CloseHandle((HANDLE)mHandle);
        mHandle = 0;
        return true;
    }
    return false;
}

#endif

} // gam::

#endif