Deliver/include/CcosThread.h

#pragma once

#include <pthread.h>
#include <semaphore.h>
#include <unistd.h>
#include <string>
#include <queue>
#include <sys/types.h> 

#define CcosTHREAD_API 

#include "CcosLock.h"
#include "ResDataObject.h"
#include "LinuxEvent.h"

#define MAX_CHECK_TIME_PERIOD (10000)

typedef void* PVOID;   

class CcosTHREAD_API Thread_Base {
protected:
    pthread_t m_Base_Thread;
    unsigned long m_ThreadID;

    std::shared_ptr<LinuxEvent> m_ExitFlag;
    std::shared_ptr<LinuxEvent> m_WorkFlag;
    std::shared_ptr<LinuxEvent> m_RunFlag;

    bool m_ThreadRunning;
    bool m_ExitRequested;
    pthread_cond_t m_StateCond;
    std::string m_strName;
    PVOID m_pThreadLogger;

    virtual bool Exec();
    virtual bool OnStartThread();
    virtual bool OnEndThread();
    virtual bool RegistThread();
    virtual bool UnRegistThread();

    std::shared_ptr<LinuxEvent> GetWorkEvt();
    std::shared_ptr<LinuxEvent> GetExitEvt();

    static void* Thread_Base_Thread(void* pPara);

public:
    Thread_Base();
    virtual ~Thread_Base();

    void SetLogger(PVOID pLoger);
    PVOID GetLogger();

    bool StartThread(bool Sync = true, bool Inherit = false);
    bool StopThread(unsigned long timeperiod = 10000);
    void NotifyExit();
    pthread_t GetTID();
    void SetName(const char* pszThreadName);
    const std::string& GetName() const { return m_strName; }

    int WaitTheIncommingEvent(unsigned long waittime = (unsigned long)-1);
    bool WaitTheThreadEnd(unsigned long waittime = (unsigned long)-1);
    bool WaitTheThreadEndSign(unsigned long waittime = (unsigned long)-1);
    bool WaitTheThreadOnTheRun(unsigned long waittime = (unsigned long)-1);


    bool SetThreadOnTheRun(bool OnTheRun);
    void NotifyThreadWork();
    bool IsThreadRunning() const { return m_ThreadRunning; }

    void ThreadExitProcedure();
};

class CcosTHREAD_API Work_Thread : public Thread_Base, public CcosLock {
protected:
    std::shared_ptr<LinuxEvent> m_PauseEvt;
    std::shared_ptr<LinuxEvent> m_SleepingEvt;
    std::shared_ptr<LinuxEvent> m_ResumeEvt;
    std::shared_ptr<LinuxEvent> m_WorkingEvt;//Ë«·½È·ÈϽáÊø½»»¥

    void* m_pWorkQueReq;//request 
    void* m_pWorkQueRes;//response

    bool PopReqDataObject(ResDataObject& obj);
    bool PopResDataObject(ResDataObject& obj);
    bool WaitForInQue(unsigned long m_Timeout = (unsigned long)-1);

    bool CheckForPause();
    bool WaitforResume();

public:
    Work_Thread();
    virtual ~Work_Thread();

    bool PushReqDataObject(ResDataObject& obj);
    bool PushResDataObject(ResDataObject& obj);

    bool PauseThread(unsigned long timeout = (unsigned long)-1);
    bool ResumeThread(unsigned long timeout = (unsigned long)-1);
};

class CcosTHREAD_API Ccos_Thread : public Thread_Base {
public:
    Ccos_Thread();
    virtual ~Ccos_Thread();
};

#define WAITROUTINE(x) { \
    int ret = WaitTheIncommingEvent(x); \
    if(ret == 0) return false; \
    if(ret == -1) return true; \
}

#define WAIT(p, time)    if(p->WaitTheThreadEndSign(time))
#define WAITRETURN(p, time, ret)    if(p->WaitTheThreadEndSign(time))    return ret
#define WAITRETURNVOID(p, time)    if(p->WaitTheThreadEndSign(time))    return