Thread.h

Go to the documentation of this file.

#ifndef __THREAD_H__
#define __THREAD_H__

typedef int (*THREAD_START)( void *pArg );

//      SDL_Thread *SDL_CreateThread(int (*fn)(void *), void *data);
//      Uint32 SDL_GetThreadID(SDL_Thread *thread);


class Thread    {
protected:

        SDL_Thread *tid;                                                //      The Thread ID

        THREAD_START    threadFunc;

        long    threadReturnCode;
        void    *arg;

public:
        /*
         *      Info: Default Constructor
         */
        Thread( void )
        : tid( 0 ) , threadReturnCode( -1 ) , arg( 0 )
        { 
                threadFunc = (THREAD_START)Thread::EntryPoint; // Can call Detach() also.
        }

        /*
         *      Info: Plug Constructor
         *
         *      Use this to migrate/port existing worker threads to objects immediately
         *  Although you lose the benefits of ThreadCTOR and ThreadDTOR.
         */
        Thread( THREAD_START aExternalRoutine )
        : tid( 0 ) , threadReturnCode( -1 ) , arg( 0 )
        {
                Attach( aExternalRoutine );
        }

        /*
         *      Info: Default Destructor
         *
         *      I think it is wise to destroy the thread even if it is running,
         *  when the main thread reaches here.
         */
        ~Thread()
        {
                if( tid )
                        SDL_KillThread( tid );
                //      if ( m_ThreadCtx.m_hThread )    Stop(true);
        }

        /*
         * Info: return the thread handle....
         */
        SDL_Thread *GetHandle( void )   {       return tid;     }

        /*
         *      Info: Starts the thread.
         *      
         *      This function starts the thread pointed by m_pThreadFunc with default attributes
         */
        const bool Start( void* aArg = NULL )
        {
                tid = SDL_CreateThread( threadFunc , this );            //      CreateThread(NULL, 0, m_pThreadFunc, this, 0, &m_ThreadCtx.m_dwTID);
                threadReturnCode = 0;
                arg = aArg;
                return tid != 0;
        }

        void Stop( void )
        {
                if( tid )
                        SDL_KillThread( tid );
                tid = 0;
        }
        /*
         *      Info: Starts the thread.
         *      
         *      This function starts the thread pointed by m_pThreadFunc with default attributes
         */
        long GetExitCode() const 
        { 
                return threadReturnCode;
        }

        int Wait( void )
        {
                SDL_WaitThread( GetHandle() , (int *)&threadReturnCode );
                tid = 0;
                return GetExitCode();

        }
        /*
         *      Info: Attaches a Thread Function
         *      Used primarily for porting but can serve in developing generic thread objects
         */
        void Attach( THREAD_START lpThreadFunc ){       threadFunc = lpThreadFunc;      }

        /*
         *      Info: Detaches the Attached Thread Function
         *      
         *      Detaches the Attached Thread Function, If any.
         *      by resetting the thread function pointer to EntryPoint1
         */
        void  Detach( void ){   threadFunc = Thread::EntryPoint;        }

protected:

        /*
         *      Info: DONT override this method.
         *      
         *      This function is like a standard template. 
         *      Override if you are sure of what you are doing.
         */
#ifndef WIN32
#       define __cdecl 
#endif
        static int __cdecl EntryPoint( void *pArg)
        {
                Thread *pParent = reinterpret_cast<Thread*>( pArg );

                pParent->ThreadCtor();

                pParent->threadReturnCode = pParent->Run( pParent->arg );

                pParent->ThreadDtor();

                return 0;
        }

public: 

        /*
         *      Info: Override this method.
         *      
         *      This function should contain the body/code of your thread.
         *      Notice the signature is similar to that of any worker thread function
         *  except for the calling convention.
         */
        virtual long Run( void * /* arg */ )    { return 0; }

        /*
         *      Info: Constructor-like function. 
         *      
         *      Will be called by EntryPoint before executing the thread body.
         *  Override this function to provide your extra initialization.
         *
         *  NOTE: do not confuse it with the classes constructor
         */
        virtual void ThreadCtor(){      }

        /*
         *      Info: Destructor-like function. 
         *      
         *      Will be called by EntryPoint after executing the thread body.
         *  Override this function to provide your extra destruction.
         *
         *  NOTE: do not confuse it with the classes constructor
         */
        virtual void ThreadDtor()       {       tid = 0;        }
                
};

#endif //__THREAD_H__

---