cJobBase.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cJobBase_H
#define _INC_cJobBase_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
#include "cSysEvent.h"
#include "GrayCore/include/cTimeInt.h"
#include "GrayCore/include/cSingleton.h"
#include "GrayCore/include/cArrayRef.h"
#include "GrayCore/include/cOSHandle.h"
#include "GrayCore/include/cThreadArray.h"
 
namespace GrayLib
{
        class cJobArray;
 
        class GRAYLIB_LINK cJobBase : public cRefBase, public cThreadState
        {
                friend class cJobArray;
 
        private:
                cJobArray* m_pArrayParent;      
                TIMESYS_t m_timeLast;           
                TIMESYS_t m_timeNext;           
 
        public:
                static const TIMESYS_t k_ASAP = 1;
 
        protected:
                virtual HRESULT RunJob() = 0;
 
        public:
                cJobBase(cJobArray* pArrayParent = nullptr) noexcept
                : m_pArrayParent(pArrayParent)
                , m_timeLast(cTimeSys::k_CLEAR)
                , m_timeNext(cTimeSys::k_CLEAR)
                {
                }
 
                STDMETHOD_(cString, get_Name)() const = 0;
 
                virtual HRESULT DisposeThis()
                {
                        RequestStopThread(false);
                        m_timeLast = cTimeSys::k_CLEAR;
                        ClearJob();
                        m_pArrayParent = nullptr;       // detach.
                        return S_OK;
                }
 
                virtual void put_JobParam(INT_PTR iParam)
                {
                        UNREFERENCED_PARAMETER(iParam);
                }
 
                bool isJobScheduled() const noexcept
                {
                        return m_timeNext > cTimeSys::k_CLEAR ;
                }
                TIMESYS_t get_SortValue() const noexcept
                {
                        // Allow sort by time.
                        return m_timeNext;
                }
                TIMESYS_t get_TimeNext() const noexcept
                {
                        return m_timeNext;
                }
                TIMESECD_t get_TimeNextSec() const noexcept
                {
                        if (!isJobScheduled())
                        {
                                return INT_MAX; // Never - not scheduled.
                        }
                        TIMESYSD_t idmSec = m_timeNext - cTimeSys::GetTimeNow();
                        return idmSec / cTimeSys::k_FREQ ;
                }
                TIMESECD_t get_TimeLastSec() const noexcept
                {
                        if (m_timeLast <= cTimeSys::k_CLEAR)
                                return -1; // never before.
                        TIMESYSD_t idmSec = cTimeSys::GetTimeNow() - m_timeLast;
                        return idmSec / cTimeSys::k_FREQ;
                }
 
                HRESULT RunJobX();
 
                HRESULT ClearJob()
                {
                        return put_TimeNext(cTimeSys::k_CLEAR); // unschedule this.
                }
                HRESULT ScheduleJob(TIMESYSD_t mSecDelay)
                {
                        return put_TimeNext(cTimeSys::GetTimeNow() + mSecDelay);
                }
                HRESULT ScheduleJobX(TIMESYSD_t mSecDelay)
                {
                        TIMESYS_t nTimeNext;
                        if (mSecDelay <= 0)
                        {
                                nTimeNext = cTimeSys::k_CLEAR;  // never.
                        }
                        else if (m_timeLast == 0)
                        {
                                nTimeNext = cTimeSys::GetTimeNow() + mSecDelay;
                        }
                        else
                        {
                                // do in n Seconds from m_timeLast
                                nTimeNext = m_timeLast + mSecDelay;
                        }
                        return put_TimeNext(nTimeNext);
                }
                HRESULT ScheduleJobParam(INT_PTR iParam)
                {
                        put_JobParam(iParam);
                        return put_TimeNext(cTimeSys::GetTimeNow()); // do now
                }
 
                virtual void ResetJobTime()     
                {
                        ClearJob();     // default = never run this more than once.
                }
 
                HRESULT put_TimeNext(TIMESYS_t nTimeNext);
        };
        typedef cRefPtr<cJobBase> cJobPtr;
 
        class cJobWaiter : public cJobBase
        {
        };
 
        class cJobPender : public cJobBase
        {
                // TODO ?
        };
 
        //****************************************************************
 
        class GRAYLIB_LINK cJobArray : public cThreadLockArrayValue<cJobBase, TIMESYS_t>
        {
 
        protected:
                cSysEvent m_Wake;       
 
        public:
                HRESULT SetWake();                      
 
                cJobPtr PopNextJobToRun();
                HRESULT RunJobsCheck();
 
                cSysEvent& ref_Wake()
                {
                        return m_Wake;
                }
 
                void InitAllJobs();
                void RemoveAllJobs();
        };
 
} 
 
#endif