ZFThread.h

Go to the documentation of this file.

 
#ifndef _ZFI_ZFThread_h_
#define _ZFI_ZFThread_h_
 
#include "ZFObject.h"
ZF_NAMESPACE_GLOBAL_BEGIN
 
// ============================================================
zfclassFwd _ZFP_ZFThreadPrivate;
zfclass ZFLIB_ZFCore ZFThread : zfextend ZFObject {
    ZFOBJECT_DECLARE(ZFThread, ZFObject)
 
public:
    // ============================================================
    // observer events
    ZFEVENT(ThreadOnRegister)
    ZFEVENT(ThreadOnUnregister)

    ZFEVENT(ThreadOnStart)
    ZFEVENT(ThreadOnStop)
    ZFEVENT(ThreadOnStopRequested)
    ZFEVENT(ThreadTaskQueueOnFinish)
 
    // ============================================================
    // thread control
public:
    ZFMETHOD_DECLARE_STATIC_1(void *, nativeThreadRegister
            , ZFMP_IN(const zfstring &, threadName)
            )
    ZFMETHOD_DECLARE_STATIC_1(void, nativeThreadUnregister
            , ZFMP_IN(void *, token)
            )
 
public:
    ZFMETHOD_DECLARE_STATIC_0(zfbool, implAvailable)
    ZFMETHOD_DECLARE_STATIC_0(zfbool, implMainThreadTaskAvailable)

    ZFMETHOD_DECLARE_STATIC_0(const ZFCoreArray<ZFThread *> &, allThread)

    ZFMETHOD_DECLARE_STATIC_0(ZFThread *, mainThread)
    ZFMETHOD_DECLARE_STATIC_0(ZFThread *, currentThread)

    ZFMETHOD_DECLARE_STATIC_1(zfbool, sleep
            , ZFMP_IN(zftimet, miliSecs)
            )
    ZFMETHOD_DECLARE_0(void, sleepCancel)

    ZFMETHOD_DECLARE_STATIC_2(ZFThread *, executeInThread
            , ZFMP_IN(ZFThread *, thread)
            , ZFMP_IN(const ZFListener &, callback)
            )
 
    // ============================================================
    // thread instance method
protected:
    ZFOBJECT_ON_INIT_DECLARE_1(ZFMP_IN(const ZFListener &, runnable))
    zfoverride
    virtual void objectOnInit(void);
    zfoverride
    virtual void objectOnDealloc(void);
    zfoverride
    virtual void objectOnDeallocPrepare(void);
 
protected:
    zfoverride
    virtual void objectInfoImplAppend(ZF_IN_OUT zfstring &ret);
 
public:
    ZFPROPERTY_ASSIGN(zfstring, threadName)

    ZFPROPERTY_ASSIGN(ZFListener, threadRunnable)

    ZFMETHOD_DECLARE_2(void, threadStart
            , ZFMP_IN_OPT(ZFObject *, param0, zfnull)
            , ZFMP_IN_OPT(ZFObject *, param1, zfnull)
            )
    ZFMETHOD_DECLARE_0(zfbool, threadStarted)
    ZFMETHOD_DECLARE_0(zfbool, threadRunning)
    ZFMETHOD_DECLARE_0(void, threadStop)
    ZFMETHOD_DECLARE_0(zfbool, threadStopRequested)

    ZFMETHOD_DECLARE_0(void, threadWait)

    ZFMETHOD_DECLARE_1(zfbool, threadWait
            , ZFMP_IN(zftimet, miliSecs)
            )

    ZFMETHOD_DECLARE_0(zfbool, isMainThread)
    ZFMETHOD_DECLARE_0(zfbool, isNativeThread)

    virtual void autoReleasePoolAdd(ZF_IN ZFObject *obj);
    virtual void autoReleasePoolDrain();
 
public:
    ZFMETHOD_DECLARE_0(void, taskQueueInit)
    ZFMETHOD_DECLARE_0(void, taskQueueCleanup)
    ZFMETHOD_DECLARE_0(zfbool, taskQueueAvailable)
    ZFMETHOD_DECLARE_0(zfindex, taskQueueCount)
    ZFMETHOD_DECLARE_1(void, taskQueueAdd
            , ZFMP_IN(const ZFListener &, task)
            )
    ZFMETHOD_DECLARE_1(void, taskQueueRemove
            , ZFMP_IN(const ZFListener &, task)
            )
    ZFMETHOD_DECLARE_0(zfbool, taskQueueRunning)
 
protected:
    ZFMETHOD_DECLARE_PROTECTED_1(void, threadOnRun
            , ZFMP_IN(const ZFArgs &, zfargs)
            )
 
protected:
    virtual inline void threadOnRegister(void) {
        this->observerNotify(ZFThread::E_ThreadOnRegister());
    }

    virtual inline void threadOnUnregister(void) {
        this->observerNotify(ZFThread::E_ThreadOnUnregister());
    }

    virtual inline void threadOnStart(ZF_IN const ZFArgs &zfargs) {
        this->observerNotify(ZFThread::E_ThreadOnStart(), zfargs.param0(), zfargs.param1());
    }

    virtual inline void threadOnStop(ZF_IN const ZFArgs &zfargs) {
        this->observerNotify(ZFThread::E_ThreadOnStop(), zfargs.param0(), zfargs.param1());
    }

    virtual inline void threadOnStopRequested(void) {
        this->observerNotify(ZFThread::E_ThreadOnStopRequested());
    }

    virtual inline void threadTaskQueueOnFinish(void) {
        this->observerNotify(ZFThread::E_ThreadTaskQueueOnFinish());
    }
 
private:
    _ZFP_ZFThreadPrivate *d;
    friend zfclassFwd _ZFP_ZFThreadPrivate;
};
 
ZF_NAMESPACE_GLOBAL_END
#endif // #ifndef _ZFI_ZFThread_h_