413 lines
14 KiB
C++
413 lines
14 KiB
C++
//
|
|
// MODULE: COUNTER.H
|
|
//
|
|
// PURPOSE: interface for the counter classes:
|
|
// CPeriodicTotals (utility class)
|
|
// CAbstractCounter (abstract base class).
|
|
// CCounter (simple counter)
|
|
// CHourlyCounter (counter with "bins" for each hour of the day)
|
|
// CDailyCounter (counter with "bins" for day of the week)
|
|
// CHourlyDailyCounter (counter with "bins" for each hour of the day and each day of the week)
|
|
//
|
|
// PROJECT: Generic Troubleshooter DLL for Microsoft AnswerPoint
|
|
//
|
|
// COMPANY: Saltmine Creative, Inc. (206)-284-7511 support@saltmine.com
|
|
//
|
|
// AUTHOR: Joe Mabel
|
|
// MODIFIED: Oleg Kalosha 10-20-98
|
|
//
|
|
// ORIGINAL DATE: 7-20-1998
|
|
//
|
|
// NOTES:
|
|
// 1. CPeriodicTotals might better be implemented using STL vectors. We wrote this
|
|
// before we really started bringing STL into this application. JM 10/98
|
|
//
|
|
// Version Date By Comments
|
|
//--------------------------------------------------------------------
|
|
// V3.0 7-20-98 JM Original
|
|
//
|
|
//////////////////////////////////////////////////////////////////////
|
|
|
|
#if !defined(AFX_COUNTER_H__07B5ABBD_2005_11D2_95D0_00C04FC22ADD__INCLUDED_)
|
|
#define AFX_COUNTER_H__07B5ABBD_2005_11D2_95D0_00C04FC22ADD__INCLUDED_
|
|
|
|
#if _MSC_VER >= 1000
|
|
#pragma once
|
|
#endif // _MSC_VER >= 1000
|
|
|
|
#include <time.h>
|
|
#include "apgtsstr.h"
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// a utility class to allow the expression of a series of time periods & associated counts
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CPeriodicTotals
|
|
{
|
|
public:
|
|
CPeriodicTotals(long nPeriods);
|
|
virtual ~CPeriodicTotals();
|
|
|
|
void Reset();
|
|
bool SetNext(time_t time, long Count);
|
|
private:
|
|
void ReleaseMem();
|
|
protected:
|
|
CString & DisplayPeriod(long i, CString & str) const;
|
|
public:
|
|
virtual CString HTMLDisplay() const = 0;
|
|
protected:
|
|
long m_nPeriods; // number of periods, based on initialization in constructor.
|
|
// typically 25 (hours in a day + 1) or 8 (days in a week + 1)
|
|
long m_nPeriodsSet; // number of periods for which we have data filled in.
|
|
long m_iPeriod; // index. 0 <= m_iPeriod < m_nPeriodsSet. Zeroed by InitEnum,
|
|
// incremented by GetNext or SetNext.
|
|
time_t *m_ptime; // points to array of times: start time of relevant time period
|
|
// (typically beginning of a clock hour or calendar day).
|
|
long *m_pCount; // points to array totals, each the total for correspondingly
|
|
// indexed time period
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CHourlyTotals class declaration
|
|
// CHourlyTotals intended for displaying hourly totals
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CHourlyTotals : public CPeriodicTotals
|
|
{
|
|
public:
|
|
CHourlyTotals();
|
|
~CHourlyTotals();
|
|
virtual CString HTMLDisplay() const;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CDailyTotals class declaration
|
|
// CDailyTotals intended for displaying dayly totals
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CDailyTotals : public CPeriodicTotals
|
|
{
|
|
public:
|
|
CDailyTotals();
|
|
~CDailyTotals();
|
|
virtual CString HTMLDisplay() const;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CCounterLocation class declaration
|
|
// CCounterLocation is a mean to identify counter within the global counter pool
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CCounterLocation
|
|
{
|
|
public:
|
|
// prefixes for scope names
|
|
static LPCTSTR m_GlobalStr;
|
|
static LPCTSTR m_TopicStr;
|
|
static LPCTSTR m_ThreadStr;
|
|
|
|
// counter IDs
|
|
enum EId {
|
|
eIdGeneric,
|
|
|
|
// counters that are realized
|
|
eIdProgramContemporary,
|
|
eIdStatusAccess,
|
|
eIdActionAccess,
|
|
eIdTotalAccessStart,
|
|
eIdTotalAccessFinish,
|
|
eIdRequestUnknown,
|
|
eIdRequestRejected,
|
|
eIdErrorLogged,
|
|
|
|
// status information that I see as counters.
|
|
// Oleg 10-20-98
|
|
eIdWorkingThread,
|
|
eIdQueueItem,
|
|
eIdProgressItem,
|
|
|
|
// status information that I think can be emulated as counters
|
|
// Oleg 10-21-98
|
|
eIdKnownTopic,
|
|
eIdTopicNotTriedLoad,
|
|
eIdTopicFailedLoad,
|
|
|
|
// topic - bound counters
|
|
eIdTopicLoad,
|
|
eIdTopicLoadOK,
|
|
eIdTopicEvent,
|
|
eIdTopicHit,
|
|
eIdTopicHitNewCookie,
|
|
eIdTopicHitOldCookie,
|
|
};
|
|
|
|
private:
|
|
const CString m_Scope; // scope where the counter is used (i.e. "Topic start", "Thread 1" and so on)
|
|
EId m_Id; // identifier of the counter within the scope
|
|
|
|
public:
|
|
CCounterLocation(EId id, LPCTSTR scope =m_GlobalStr);
|
|
virtual ~CCounterLocation();
|
|
|
|
public:
|
|
bool operator == (const CCounterLocation& sib) {return m_Scope == sib.m_Scope && m_Id == sib.m_Id;}
|
|
|
|
public:
|
|
CString GetScope() {return m_Scope;}
|
|
EId GetId() {return m_Id;}
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CAbstractCounter class declaration
|
|
// CAbstractCounter* are saved in counter pool
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// >>>(probably ignore for V3.0) There has been some disagreement over whether it is
|
|
// appropriate for CAbstractCounter to inherit from CCounterLocation.
|
|
// JM says (10/29/98):
|
|
// This seems to me to be the same type of thinking as when pointers to the previous and
|
|
// next item are made part of a class that someone intends to put in a doubly linked list.
|
|
// They are NOT inherent to the class. They ought instead to be part of some other class
|
|
// that manages CAbstractCounters.
|
|
// Oleg replies (11/2/98)
|
|
// Since all counters are elements of a global pool, we have somehow to identify them
|
|
// in this pool. If the way, we are identifying counters, changes (from name - id to
|
|
// name1 - name2 - id for example), we change only CCounterLocation part of counter classes.
|
|
// I see no reasons to make CCounterLocation an instance in counter class:
|
|
// 1. we definitely have only one CCounterLocation per counter
|
|
// 2. in case if inheritance we do not need additional interface for accessing CCounterLocation
|
|
// JM follows this up (11/5/98):
|
|
// There is nothing wrong with this approach as such. There is, however, an issue of design
|
|
// philosophy that at some point we should address. For the most part, we follow the style
|
|
// of STL. Classes are normally designed with no regard to the fact that they will be
|
|
// contained in a collection. Here, the counter class knows about the enumeration type
|
|
// used to identify counters. This is sort of as if the values in an STL map had to know
|
|
// about the keys mapped to those values.
|
|
// I would have designed CCounterMgr as an "object factory", providing a means to
|
|
// manufacture named counters much as Win32 manufactures named synchronization primitives
|
|
// (e.g. a named Mutex or Semaphore). To indicate that an event has occurred, you would
|
|
// increment a named counter; for status reporting, you would ask for values of that
|
|
// named counter. (In theory, the "names" might either be text or numbers. The scheme
|
|
// would have to allow for some means of manufacturing several distinct counters for
|
|
// each topic in the catalog.)
|
|
class CAbstractCounter : public CCounterLocation
|
|
{
|
|
protected: // we do not get instances of this class (evermore this is an abstract class)
|
|
CAbstractCounter(EId id =eIdGeneric, CString scope =m_GlobalStr);
|
|
virtual ~CAbstractCounter();
|
|
|
|
public:
|
|
virtual void Increment() = 0;
|
|
virtual void Clear() = 0;
|
|
virtual void Init(long count) = 0; // init counter with a number - in order to emulate
|
|
// counting process
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CCounter class declaration
|
|
// A simple counter
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CCounter : public CAbstractCounter
|
|
{
|
|
public:
|
|
CCounter(EId id =eIdGeneric, CString scope =m_GlobalStr);
|
|
~CCounter();
|
|
|
|
// overrides
|
|
void Increment();
|
|
void Clear();
|
|
void Init(long count);
|
|
// specific to this class
|
|
long Get() const;
|
|
|
|
private:
|
|
long m_Count;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CHourlyCounter class declaration
|
|
// CHourlyCounter is not supposed to be instantiated by user
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CHourlyCounter : public CAbstractCounter
|
|
{
|
|
friend class CHourlyDailyCounter;
|
|
protected:
|
|
CHourlyCounter();
|
|
public:
|
|
~CHourlyCounter();
|
|
|
|
// overrides
|
|
void Increment();
|
|
void Clear();
|
|
void Init(long count);
|
|
// specific to this class
|
|
long GetDayCount();
|
|
void GetHourlies(CHourlyTotals & totals);
|
|
private:
|
|
void SetHour();
|
|
|
|
private:
|
|
long m_ThisHour; // hour of the day, 0-24. -1 means uninitialized.
|
|
time_t m_ThisTime; // time corresponding to START of hour.
|
|
|
|
CCounter m_arrCount[24]; // 24 "bins", one for each hour of the day.
|
|
long m_nThisHourYesterday; // maintains a whole hour count for the hour 24 hours ago.
|
|
|
|
HANDLE m_hMutex;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CDailyCounter class declaration
|
|
// CDailyCounter is not supposed to be instantiated by user
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CDailyCounter : public CAbstractCounter
|
|
{
|
|
friend class CHourlyDailyCounter;
|
|
protected:
|
|
CDailyCounter();
|
|
public:
|
|
~CDailyCounter();
|
|
|
|
// overrides
|
|
void Increment();
|
|
void Clear();
|
|
void Init(long count);
|
|
// specific to this class
|
|
long GetWeekCount();
|
|
void GetDailies(CDailyTotals & totals);
|
|
private:
|
|
void SetDay();
|
|
|
|
private:
|
|
long m_ThisDay; // day of the week, 0(Sunday)-6(Saturday). -1 means uninitialized.
|
|
time_t m_ThisTime; // time corresponding to START of day.
|
|
|
|
CCounter m_arrCount[7]; // 7 "bins", one for each day of the week.
|
|
long m_nThisDayLastWeek; // maintains a whole day count for the same day last week.
|
|
|
|
HANDLE m_hMutex;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// CHourlyDailyCounter class declaration
|
|
// CHourlyDailyCounter is an ONLY class used for counting events
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CHourlyDailyCounter : public CAbstractCounter
|
|
{
|
|
public:
|
|
CHourlyDailyCounter(EId id =eIdGeneric, CString scope =m_GlobalStr);
|
|
~CHourlyDailyCounter();
|
|
|
|
// overrides
|
|
void Increment();
|
|
void Clear();
|
|
void Init(long count);
|
|
// specific to this class
|
|
long GetDayCount();
|
|
void GetHourlies(CHourlyTotals & totals);
|
|
long GetWeekCount();
|
|
void GetDailies(CDailyTotals & totals);
|
|
long GetTotal() const;
|
|
time_t GetTimeFirst() const;
|
|
time_t GetTimeLast() const;
|
|
time_t GetTimeCleared() const;
|
|
time_t GetTimeCreated() const;
|
|
time_t GetTimeNow() const; // time the object is being questioned
|
|
|
|
private:
|
|
CHourlyCounter m_hourly;
|
|
CDailyCounter m_daily;
|
|
|
|
long m_Total; // total since system startup or count cleared
|
|
time_t m_timeFirst; // chronologically first time count was incremented
|
|
time_t m_timeLast; // chronologically last time count was incremented
|
|
time_t m_timeCleared; // last time init'd or cleared
|
|
time_t m_timeCreated; // time the object was instantiated
|
|
|
|
HANDLE m_hMutex;
|
|
};
|
|
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
// DisplayCounter classes
|
|
////////////////////////////////////////////////////////////////////////////////////
|
|
class CAbstractDisplayCounter
|
|
{
|
|
protected:
|
|
CAbstractCounter* m_pAbstractCounter;
|
|
|
|
public:
|
|
CAbstractDisplayCounter(CAbstractCounter* counter) : m_pAbstractCounter(counter) {}
|
|
virtual ~CAbstractDisplayCounter() {}
|
|
|
|
public:
|
|
virtual CString Display() = 0;
|
|
};
|
|
|
|
class CDisplayCounterTotal : public CAbstractDisplayCounter
|
|
{
|
|
public:
|
|
CDisplayCounterTotal(CHourlyDailyCounter* counter) : CAbstractDisplayCounter(counter) {}
|
|
~CDisplayCounterTotal() {}
|
|
|
|
public:
|
|
virtual CString Display();
|
|
};
|
|
|
|
class CDisplayCounterCurrentDateTime : public CAbstractDisplayCounter
|
|
{
|
|
public:
|
|
CDisplayCounterCurrentDateTime(CHourlyDailyCounter* counter) : CAbstractDisplayCounter(counter) {}
|
|
~CDisplayCounterCurrentDateTime() {}
|
|
|
|
public:
|
|
virtual CString Display();
|
|
};
|
|
|
|
class CDisplayCounterCreateDateTime : public CAbstractDisplayCounter
|
|
{
|
|
public:
|
|
CDisplayCounterCreateDateTime(CHourlyDailyCounter* counter) : CAbstractDisplayCounter(counter) {}
|
|
~CDisplayCounterCreateDateTime() {}
|
|
|
|
public:
|
|
virtual CString Display();
|
|
};
|
|
|
|
class CDisplayCounterFirstDateTime : public CAbstractDisplayCounter
|
|
{
|
|
public:
|
|
CDisplayCounterFirstDateTime(CHourlyDailyCounter* counter) : CAbstractDisplayCounter(counter) {}
|
|
~CDisplayCounterFirstDateTime() {}
|
|
|
|
public:
|
|
virtual CString Display();
|
|
};
|
|
|
|
class CDisplayCounterLastDateTime : public CAbstractDisplayCounter
|
|
{
|
|
public:
|
|
CDisplayCounterLastDateTime(CHourlyDailyCounter* counter) : CAbstractDisplayCounter(counter) {}
|
|
~CDisplayCounterLastDateTime() {}
|
|
|
|
public:
|
|
virtual CString Display();
|
|
};
|
|
|
|
class CDisplayCounterDailyHourly : public CAbstractDisplayCounter
|
|
{
|
|
protected:
|
|
CDailyTotals* m_pDailyTotals;
|
|
CHourlyTotals* m_pHourlyTotals;
|
|
|
|
public:
|
|
CDisplayCounterDailyHourly(CHourlyDailyCounter* counter,
|
|
CDailyTotals* daily,
|
|
CHourlyTotals* hourly)
|
|
: CAbstractDisplayCounter(counter),
|
|
m_pDailyTotals(daily),
|
|
m_pHourlyTotals(hourly)
|
|
{}
|
|
~CDisplayCounterDailyHourly() {}
|
|
|
|
public:
|
|
virtual CString Display();
|
|
};
|
|
|
|
#endif // !defined(AFX_COUNTER_H__07B5ABBD_2005_11D2_95D0_00C04FC22ADD__INCLUDED_)
|