ClassMethodThread.h

Go to the documentation of this file.

#ifndef CLASSMETHODTHREAD_H_
#define CLASSMETHODTHREAD_H_

#include "SttclThread.h"
#include "SttclMutex.h"

namespace sttcl
{
template
< class T
, class UserArgs = void
, class ThreadImpl = STTCL_DEFAULT_THREADIMPL
, class MutexImpl = STTCL_DEFAULT_MUTEXIMPL
>
class ClassMethodThread
: public sttcl::internal::SttclThread<ThreadImpl>
{
public:
        typedef void* (T::*ThreadMethodPtr)(UserArgs*);

private:
        struct RunArgs
        {
                ClassMethodThread<T,UserArgs,ThreadImpl,MutexImpl>* threadInstance;
                T* instance;
                ThreadMethodPtr threadMethod;
                UserArgs* userArgs;

                RunArgs(ClassMethodThread<T,UserArgs,ThreadImpl,MutexImpl>* argThreadInstance,T* argInstance, ThreadMethodPtr argThreadMethod, UserArgs* argUserArgs = 0)
                : threadInstance(argThreadInstance)
                , instance(argInstance)
                , threadMethod(argThreadMethod)
                , userArgs(argUserArgs)
                {
                }
                RunArgs(const RunArgs& rhs)
                : threadInstance(rhs.threadInstance)
                , instance(rhs.instance)
                , threadMethod(rhs.threadMethod)
                , userArgs(rhs.userArgs)
                {
                }
                RunArgs& operator=(const RunArgs& rhs)
                {
                        threadInstance = rhs.threadInstance;
                        instance = rhs.instance;
                        threadMethod = rhs.threadMethod;
                        userArgs = rhs.userArgs;
                        return *this;
                }

        private:
                RunArgs(); 
        };
public:
        ClassMethodThread(T* argInstance, ThreadMethodPtr argThreadMethod)
        : sttcl::internal::SttclThread<ThreadImpl>(internalThreadMethod)
        , runArgs(this,argInstance,argThreadMethod)
        , running(false)
        , threadMutex()
        {
        }

        virtual ~ClassMethodThread()
        {
        }

        bool run(UserArgs* userArgs = 0)
        {
                if(!isRunning())
                {
                        runArgs.userArgs = userArgs;
                        return sttcl::internal::SttclThread<ThreadImpl>::run(&runArgs);
                }
                return false;
        }

        bool isRunning()
        {
                sttcl::internal::AutoLocker<MutexImpl> lock(threadMutex);
                return running;
        }

        void join()
        {
                if(!isSelf(*this))
                {
                        sttcl::internal::SttclThread<ThreadImpl>::join();
                }
        }

private:
        static void* internalThreadMethod(void* args)
        {
                void * result = 0;
                RunArgs* runArgs = reinterpret_cast<RunArgs*>(args);
                ClassMethodThread<T,UserArgs,ThreadImpl,MutexImpl>* thisPtr = runArgs->threadInstance;

//              if(!isSelf(*thisPtr) && !thisPtr->isRunning())
//              {
                        { sttcl::internal::AutoLocker<MutexImpl> lock(thisPtr->threadMutex);
                                thisPtr->running = true;
                        }
                        T* instance = runArgs->instance;
                        ThreadMethodPtr threadMethod = runArgs->threadMethod;
                        result = (instance->*threadMethod)(runArgs->userArgs);
                        { sttcl::internal::AutoLocker<MutexImpl> lock(thisPtr->threadMutex);
                                thisPtr->running = false;
                        }
//              }
                return result;
        }

        ClassMethodThread(); 
        ClassMethodThread(const ClassMethodThread<T,UserArgs,ThreadImpl>& rhs); 
        ClassMethodThread<T,UserArgs,ThreadImpl>& operator=(const ClassMethodThread<T,UserArgs,ThreadImpl>& rhs); 

        RunArgs runArgs;
        bool running;
        MutexImpl threadMutex;
};

}
#endif /* CLASSMETHODTHREAD_H_ */