|
|
//+---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1996.
//
// File: runobj.hxx
//
// Contents: CRun class definition.
//
// Classes: CRun
//
// Functions: None.
//
// History: 08-Sep-95 EricB Created.
// 01-Dec-95 MarkBl Split from util.hxx.
//
//----------------------------------------------------------------------------
#ifndef __RUNOBJ_HXX__
#define __RUNOBJ_HXX__
//#include "time.hxx"
#undef SetFlag
#undef ClearFlag
#undef IsFlagSet
//
// Run processing flags: values 0x00010000 through 0x80000000 for run state:
//
#define RUN_STATUS_RUNNING 0x00010000
#define RUN_STATUS_FINISHED 0x00020000
#define RUN_STATUS_ABORTED 0x00040000
#define RUN_STATUS_TIMED_OUT 0x00080000
#define RUN_STATUS_CLOSE_PENDING 0x00100000
#define RUN_STATUS_CLOSED 0x00200000 // (This is set, but not used yet)
#define RUN_STATUS_RESTART_ON_IDLE_RESUME 0x00400000
//+----------------------------------------------------------------------------
//
// Class: CRun
//
// Synopsis: Lightweight job object. A moniker of sorts to the real thing.
// Represents one run instance of a job.
//
// CODEWORK: (AnirudhS 11/7/96) The inheritance relationship should be:
// class CRun : protected CDLink (instead of public CDLink)
// class CRunList : private CRun (instead of having a private CRun member)
// This would assure us that only CRunList could call CRun's CDLink methods.
//
//-----------------------------------------------------------------------------
class CRun : public CDLink{public: CRun(LPFILETIME pft, LPFILETIME pftDeadline, FILETIME ftKill, DWORD MaxRunTime, DWORD rgFlags, WORD wIdleWait, BOOL fKeepAfterRunning); CRun(DWORD MaxRunTime, DWORD rgFlags, FILETIME ftDeadline, BOOL fKeepAfterRunning); CRun(DWORD MaxRunTime, DWORD rgFlags, WORD wIdleWait, FILETIME ftDeadline, BOOL fKeepAfterRunning); CRun(CRun * pRun); CRun(void); ~CRun();
HRESULT Initialize(LPCTSTR ptszName) { return(this->SetName(ptszName)); }
void GetSysTime(LPSYSTEMTIME pst) {FileTimeToSystemTime(&m_ft, pst);} void GetTime(LPFILETIME pft) {*pft = m_ft;} LPFILETIME GetTime(void) {return &m_ft;} LPFILETIME GetDeadline(void) {return &m_ftDeadline;} void RelaxDeadline(FILETIME ftDeadline) { if (CompareFileTime(&ftDeadline, &m_ftDeadline) > 0) m_ftDeadline = ftDeadline; } WORD GetWait(void) {return m_wIdleWait;} void ReduceWaitTo(WORD wIdleWait) { m_wIdleWait = min(m_wIdleWait, wIdleWait);}
FILETIME GetKillTime() { return m_ftKill; } void AdvanceKillTime(FILETIME ftKill) { if (CompareFileTime(&ftKill, &m_ftKill) < 0) m_ftKill = ftKill; } void AdjustKillTimeByMaxRunTime(FILETIME ftNow);
void SetMaxRunTime(DWORD dwMaxRunTime) {m_dwMaxRunTime = dwMaxRunTime;} DWORD GetMaxRunTime(void) {return(m_dwMaxRunTime);}
CRun * Next(void) { return (CRun *)CDLink::Next(); } CRun * Prev(void) { return (CRun *)CDLink::Prev(); }
BOOL IsNull(void) {return(m_ft.dwLowDateTime == 0 && m_ft.dwHighDateTime == 0);};
HRESULT SetName(LPCTSTR ptszName); LPTSTR GetName(void) { return m_ptszJobName; }
void SetHandle(HANDLE hJob) { m_hJob = hJob; this->SetFlag(RUN_STATUS_RUNNING); } HANDLE GetHandle(void) const { return(m_hJob); }
#if !defined(_CHICAGO_)
void SetProfileHandles(HANDLE hUser, HANDLE hProfile) { m_hUserToken = hUser; m_hProfile = hProfile; }
HRESULT SetDesktop( LPCTSTR ptszDesktop ); LPTSTR GetDesktop( void ) { return m_ptszDesktop; }
HRESULT SetStation( LPCTSTR ptszStation );
LPTSTR GetStation( void ) { return m_ptszStation; }
#endif // !defined(_CHICAGO_)
void SetFlag(DWORD rgFlag) { m_rgFlags |= rgFlag; } void ClearFlag(DWORD rgFlag) { m_rgFlags &= ~rgFlag; } DWORD GetFlags(void) { return(m_rgFlags); } BOOL IsFlagSet(DWORD rgFlag) {return (m_rgFlags & rgFlag);}
BOOL IsIdleTriggered() { return m_fKeepInList; }
void SetProcessId(DWORD dwProcessId) { m_dwProcessId = dwProcessId; } DWORD GetProcessId(void) { return(m_dwProcessId); }
private: FILETIME m_ft; // When this instance is to run
FILETIME m_ftDeadline; // Latest time when this instance may be started
FILETIME m_ftKill; // Time by which this instance must terminate
// (see the detailed comment on this field in
// procssr.cxx)
LPTSTR m_ptszJobName; // Job name.
HANDLE m_hJob; // The process handle when run
DWORD m_dwProcessId; // The process ID when run
#if !defined(_CHICAGO_)
HANDLE m_hUserToken; // User token
HANDLE m_hProfile; // User profile
LPTSTR m_ptszDesktop; //Windows Desktop
LPTSTR m_ptszStation; //WindowsStation
#endif // !defined(_CHICAGO_)
DWORD m_rgFlags; // Job Flags
DWORD m_dwMaxRunTime; // The remaining time to wait for the job to
// terminate (see the detailed comment on this
// field in procssr.cxx)
WORD m_wIdleWait; // The idle wait to determine when to run
// idle tasks.
BOOL m_fKeepInList; // Whether to keep this run in the idle list
// after starting it (set for jobs with idle
// triggers)
public: BOOL m_fStarted; // Whether the run was started since the last
// idle period began
};
//+----------------------------------------------------------------------------
//
// Run object list class
//
//-----------------------------------------------------------------------------
class CRunList{public: CRunList(); ~CRunList();
void FreeList(void); CRun * GetFirstJob(void) {return m_RunHead.Next();} BOOL IsEmpty() {return m_RunHead.Next() == &m_RunHead;} //
// The following members allow the list to be used as a simple, unsorted,
// (doubly) linked list.
//
void Add(CRun * pRun); HRESULT AddCopy(CRun * pRun);
protected: CRun m_RunHead;};
class CTimeRunList : private CRunList{public: void FreeList(void) {CRunList::FreeList();} CRun * GetFirstJob(void) {return CRunList::GetFirstJob();} BOOL IsEmpty() {return CRunList::IsEmpty();} //
// The following members allow the list to be used as a sorted queue:
//
HRESULT AddSorted(FILETIME ftRun, FILETIME ftDeadline, FILETIME ftKillTime, LPTSTR ptszJobName, DWORD dwJobFlags, DWORD dwMaxRunTime, WORD wIdleWait, WORD * pCount, WORD cLimit); CRun * Pop(void); HRESULT PeekHeadTime(LPFILETIME pft); HRESULT MakeSysTimeArray(LPSYSTEMTIME *, WORD *);};
class CIdleRunList : private CRunList{public: void FreeList(void); CRun * GetFirstJob(void) {return CRunList::GetFirstJob();} //
// The following members allow the list to be used as a sorted queue,
// sorted on idle wait times. The member at the head of the queue has
// the least idle wait time.
//
void AddSortedByIdleWait(CRun * pRun); WORD GetFirstWait(void); void MarkNoneStarted(void); void FreeExpiredOrRegenerated();};
//+----------------------------------------------------------------------------
//
// Method: CRunList::CRunList
//
// Synopsis: Constructor
//
//-----------------------------------------------------------------------------
inline CRunList::CRunList(void){ //
// Set the head node to point to itself. Note that the head node uses
// the default ctor which sets the FILETIME member to {0, 0}. This null
// FILETIME will be used as a marker for the head of the doubly linked
// list.
//
m_RunHead.SetNext(&m_RunHead); m_RunHead.SetPrev(&m_RunHead);}
//+----------------------------------------------------------------------------
//
// Method: CRunList::CRunList
//
// Synopsis: Destructor
//
//-----------------------------------------------------------------------------
inline CRunList::~CRunList(void){ FreeList();}
//+----------------------------------------------------------------------------
//
// Member: CRunList::Add
//
// Synopsis: Add an element to the unsorted list.
//
//-----------------------------------------------------------------------------
inline voidCRunList::Add(CRun * pAdd){ pAdd->LinkAfter(&m_RunHead);}
#endif // __RUNOBJ_HXX__
|
