855 lines
19 KiB
C++
855 lines
19 KiB
C++
/*++
|
|
|
|
Copyright (C) 2000-2001 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
Cache.h
|
|
|
|
Abstract:
|
|
|
|
Contains all caching classes and objects.
|
|
|
|
History:
|
|
|
|
a-dcrews 01-Mar-00 Created
|
|
|
|
ivanbrug 23-Jun-2000 mostly rewritten
|
|
|
|
--*/
|
|
|
|
#ifndef _CACHE_H_
|
|
#define _CACHE_H_
|
|
|
|
#include <windows.h>
|
|
#include <wbemcli.h>
|
|
#include <wbemint.h>
|
|
#include <wstlallc.h>
|
|
|
|
#include "RawCooker.h"
|
|
#include "CookerUtils.h"
|
|
#include "DynArray.h"
|
|
|
|
#include <wstring.h>
|
|
#include <map>
|
|
#include <vector>
|
|
#include <functional>
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// Macro Definitions
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
#define WMI_COOKER_CACHE_INCREMENT 8 // The cache size adjustment increment
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CProperty
|
|
// =========
|
|
//
|
|
// The base property - used for raw properties and the base
|
|
// class for the CookedProperty.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
class CProperty
|
|
{
|
|
protected:
|
|
LPWSTR m_wszName; // The property name
|
|
long m_lPropHandle; // The property handle
|
|
CIMTYPE m_ct;
|
|
|
|
public:
|
|
CProperty( LPWSTR wszName, long lHandle, CIMTYPE ct );
|
|
~CProperty();
|
|
|
|
LPWSTR GetName();
|
|
CIMTYPE GetType();
|
|
long GetHandle();
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CCookingProperty
|
|
// ================
|
|
//
|
|
// The cooked property - used to model the data required to
|
|
// cook a property of a cooekd class
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
class CCookingProperty : public CProperty
|
|
{
|
|
DWORD m_dwCounterType; // Counter type
|
|
DWORD m_dwReqProp; // which property are needed to perform calculation
|
|
CRawCooker m_Cooker; // The cooker object
|
|
|
|
CProperty* m_pRawCounterProp; // The raw counter property
|
|
CProperty* m_pTimeProp; // The raw time property
|
|
CProperty* m_pFrequencyProp; // The raw frequency property
|
|
|
|
CProperty* m_pBaseProp; // The raw base property OPTIONAL for most counters
|
|
|
|
__int32 m_nSampleWindow; // The number of samples used for the computation
|
|
__int32 m_nTimeWindow; // The period used for the samples
|
|
|
|
unsigned __int64 m_nTimeFreq; // The timer frequency;
|
|
long m_lScale; // The Scale factor (10 ^ (m_lScale))
|
|
BOOL m_bUseWellKnownIfNeeded;
|
|
|
|
public:
|
|
CCookingProperty( LPWSTR wszName,
|
|
DWORD dwCounterType,
|
|
long lPropHandle,
|
|
CIMTYPE ct,
|
|
DWORD dwReqProp,
|
|
BOOL bUseWellKnownIfNeeded);
|
|
virtual ~CCookingProperty();
|
|
|
|
WMISTATUS Initialize( IWbemQualifierSet* pCookingPropQualifierSet,
|
|
IWbemObjectAccess* pRawAccess,
|
|
IWbemQualifierSet* pCookingClassQSet);
|
|
|
|
WMISTATUS Cook( DWORD dwNumSamples,
|
|
__int64* aRawCounter,
|
|
__int64* aBaseCounter,
|
|
__int64* aTimeStamp,
|
|
__int64* pnResult );
|
|
|
|
CProperty* GetRawCounterProperty();
|
|
CProperty* GetBaseProperty();
|
|
CProperty* GetTimeProperty();
|
|
|
|
HRESULT SetFrequency(IWbemObjectAccess * pObjAcc);
|
|
unsigned __int64 GetFrequency(void);
|
|
BOOL IsReq(DWORD ReqProp) { return (m_dwReqProp&ReqProp); };
|
|
|
|
DWORD NumberOfActiveSamples() { return m_nSampleWindow; };
|
|
DWORD MinSamplesRequired() { return m_nSampleWindow; };
|
|
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CPropertySampleCache
|
|
// ====================
|
|
//
|
|
// For every property in each instance, we must maintain a history of
|
|
// previous samples for the cooking. The type of cooking determines the
|
|
// number of required samples
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
class CPropertySampleCache
|
|
{
|
|
DWORD m_dwNumSamples; // The number of current samples
|
|
DWORD m_dwTotSamples; // The size of the sample array
|
|
DWORD m_dwRefreshID;
|
|
|
|
__int64* m_aRawCounterVals; // The array of raw counter values
|
|
__int64* m_aBaseCounterVals; // The array of base counter values
|
|
__int64* m_aTimeStampVals; // The array of timestamp values
|
|
|
|
public:
|
|
CPropertySampleCache();
|
|
~CPropertySampleCache();
|
|
|
|
WMISTATUS SetSampleInfo( DWORD dwNumActiveSamples, DWORD dwMinReqSamples );
|
|
WMISTATUS SetSampleData( DWORD dwRefreshID, __int64 nRawCounter, __int64 nRawBase, __int64 nTimeStamp );
|
|
WMISTATUS GetData( DWORD* pdwNumSamples, __int64** paRawCounter, __int64** paBaseCounter, __int64** paTimeStamp );
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CCookingInstance
|
|
// ================
|
|
//
|
|
// The cooking instance - used to model an instance of a cooked object. Each
|
|
// property maintains a cache of values that will be used to compute the
|
|
// final cooked value.
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
class CCookingInstance
|
|
{
|
|
LPWSTR m_wszKey; // The instance key
|
|
|
|
IWbemObjectAccess* m_pCookingInstance; // Cooking instance data
|
|
IWbemObjectAccess* m_pRawInstance; // Raw sample source
|
|
|
|
CPropertySampleCache* m_aPropertySamples; // The cache of property samples for this instance
|
|
DWORD m_dwNumProps;
|
|
|
|
public:
|
|
CCookingInstance( IWbemObjectAccess *pCookingInstance, DWORD dwNumProps );
|
|
virtual ~CCookingInstance();
|
|
|
|
WMISTATUS InitProperty( DWORD dwProp, DWORD dwNumActiveSamples, DWORD dwMinReqSamples );
|
|
|
|
WMISTATUS SetRawSourceInstance( IWbemObjectAccess* pRawSampleSource );
|
|
WMISTATUS GetRawSourceInstance( IWbemObjectAccess** ppRawSampleSource );
|
|
|
|
WMISTATUS AddSample( DWORD dwRefresherInc, DWORD dwProp, __int64 nRawCounter, __int64 nRawBase, __int64 nTimeStamp );
|
|
|
|
WMISTATUS GetCachedSamples( IWbemObjectAccess** ppOldSample, IWbemObjectAccess** ppNewSample );
|
|
IWbemObjectAccess* GetInstance();
|
|
|
|
WMISTATUS UpdateSamples();
|
|
WMISTATUS CookProperty( DWORD dwProp, CCookingProperty* pProperty );
|
|
|
|
LPWSTR GetKey() { return m_wszKey; }
|
|
WMISTATUS Refresh( IWbemObjectAccess* pRawData, IWbemObjectAccess** ppCookedData );
|
|
|
|
BOOL IsValid() {
|
|
return (m_dwNumProps && m_aPropertySamples);
|
|
};
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CRecord
|
|
// =======
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<class T>
|
|
class CRecord
|
|
{
|
|
static long m_lRefIDGen; // The ID generator
|
|
long m_lID; // Instance ID
|
|
CRecord* m_pNext; // The next pointer in the list
|
|
|
|
public:
|
|
CRecord() : m_lID( m_lRefIDGen++ ), m_pNext( NULL ) {}
|
|
virtual ~CRecord() {}
|
|
|
|
void SetNext( CRecord* pRecord ) { m_pNext = pRecord; }
|
|
void SetID( long lID ) { m_lID = lID; }
|
|
|
|
CRecord* GetNext() { return m_pNext; }
|
|
long GetID() { return m_lID; }
|
|
|
|
virtual T* GetData() = 0;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CUnkRecord
|
|
// ==========
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<class T>
|
|
class CUnkRecord : public CRecord<T>
|
|
{
|
|
T* m_pUnk;
|
|
|
|
public:
|
|
CUnkRecord( T* pUnk ) : m_pUnk( pUnk ) {}
|
|
~CUnkRecord(){ if ( NULL != m_pUnk ) m_pUnk->Release(); }
|
|
|
|
T* GetData(){ if ( NULL != m_pUnk ) m_pUnk->AddRef(); return m_pUnk; }
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CObjRecord
|
|
// ==========
|
|
//
|
|
// A hidden class used by the cache to manage elements
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<class T>
|
|
class CObjRecord : public CRecord<T>
|
|
{
|
|
WCHAR* m_wszKey;
|
|
T* m_pObj;
|
|
|
|
public:
|
|
CObjRecord( T* pObj, WCHAR* wszKey ) : m_pObj( pObj ), m_wszKey( NULL )
|
|
{
|
|
if ( NULL != wszKey )
|
|
{
|
|
m_wszKey = new WCHAR[ wcslen( wszKey ) + 1 ];
|
|
wcscpy( m_wszKey, wszKey );
|
|
}
|
|
}
|
|
|
|
~CObjRecord()
|
|
{
|
|
if ( NULL != m_pObj ) delete m_pObj;
|
|
if ( NULL != m_wszKey ) delete m_wszKey;
|
|
}
|
|
|
|
T* GetData(){ return m_pObj; }
|
|
|
|
bool IsValueByKey( WCHAR* wszKey )
|
|
{
|
|
return ( 0 == _wcsicmp( m_wszKey, wszKey ) );
|
|
}
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
//
|
|
// CCache
|
|
// ======
|
|
//
|
|
// BT - base type
|
|
// RT - record type
|
|
//
|
|
///////////////////////////////////////////////////////////////////////////////
|
|
|
|
template<class BT, class RT>
|
|
class CCache
|
|
{
|
|
RT* m_pHead; // Head of list
|
|
RT* m_pTail; // Tail of list
|
|
RT* m_pEnumNode; // Enumerator pointer
|
|
|
|
public:
|
|
|
|
CCache();
|
|
virtual ~CCache();
|
|
|
|
WMISTATUS Add( BT* pData, WCHAR* wszKey, long* plID );
|
|
WMISTATUS Remove( long lID );
|
|
WMISTATUS RemoveAll();
|
|
|
|
WMISTATUS GetData( long lID, BT** ppData );
|
|
|
|
WMISTATUS BeginEnum();
|
|
WMISTATUS Next( BT** ppData );
|
|
WMISTATUS EndEnum();
|
|
|
|
bool FindByKey( WCHAR* wszKey, BT* pData );
|
|
};
|
|
|
|
template<class T>
|
|
long CRecord<T>::m_lRefIDGen = 0;
|
|
|
|
template<class BT, class RT>
|
|
CCache<BT,RT>::CCache() : m_pHead( NULL ), m_pTail( NULL ), m_pEnumNode( NULL )
|
|
{
|
|
}
|
|
|
|
template<class BT, class RT>
|
|
CCache<BT,RT>::~CCache()
|
|
{
|
|
RT* pNode = m_pHead;
|
|
RT* pNext = NULL;
|
|
|
|
while ( NULL != pNode )
|
|
{
|
|
pNext = (RT*)pNode->GetNext();
|
|
delete pNode;
|
|
pNode = pNext;
|
|
}
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::Add( BT *pData, WCHAR* wszKey, long* plID )
|
|
{
|
|
WMISTATUS dwStatus = S_OK;
|
|
|
|
if ( NULL == pData )
|
|
{
|
|
dwStatus = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
if ( SUCCEEDED( dwStatus ) )
|
|
{
|
|
RT* pNewRecord = new RT( pData, wszKey );
|
|
|
|
if ( NULL != pNewRecord )
|
|
{
|
|
if ( NULL == m_pHead )
|
|
{
|
|
m_pHead = pNewRecord;
|
|
m_pTail = pNewRecord;
|
|
}
|
|
else
|
|
{
|
|
m_pTail->SetNext( pNewRecord );
|
|
m_pTail = pNewRecord;
|
|
}
|
|
|
|
*plID = pNewRecord->GetID();
|
|
}
|
|
else
|
|
{
|
|
dwStatus = WBEM_E_OUT_OF_MEMORY;
|
|
}
|
|
}
|
|
|
|
return dwStatus;
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::Remove( long lID )
|
|
{
|
|
WMISTATUS dwStatus = S_FALSE;
|
|
|
|
RT* pNode = m_pHead;
|
|
RT* pNext = (RT*)pNode->GetNext();
|
|
RT* pPrev = NULL;
|
|
|
|
while ( NULL != pNode )
|
|
{
|
|
if ( pNode->GetID() == lID )
|
|
{
|
|
if ( NULL == pNext )
|
|
m_pTail = pPrev;
|
|
|
|
if ( NULL == pPrev )
|
|
m_pHead = pNext;
|
|
else
|
|
pPrev->SetNext( pNext );
|
|
|
|
delete pNode;
|
|
|
|
dwStatus = S_OK;
|
|
}
|
|
|
|
pPrev = pNode;
|
|
pNode = pNext;
|
|
|
|
if ( NULL != pNode )
|
|
pNext = (RT*)pNode->GetNext();
|
|
}
|
|
|
|
return dwStatus;
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::RemoveAll()
|
|
{
|
|
WMISTATUS dwStatus = S_FALSE;
|
|
|
|
RT* pNode = m_pHead;
|
|
RT* pNext = NULL;
|
|
|
|
while ( NULL != pNode )
|
|
{
|
|
pNext = (RT*)pNode->GetNext();
|
|
delete pNode;
|
|
pNode = pNext;
|
|
}
|
|
|
|
m_pHead = m_pTail = NULL;
|
|
|
|
return dwStatus;
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::GetData( long lID, BT** ppData )
|
|
{
|
|
WMISTATUS dwStatus = S_FALSE;
|
|
|
|
RT* pNode = m_pHead;
|
|
|
|
while ( NULL != pNode )
|
|
{
|
|
if ( pNode->GetID() == lID )
|
|
{
|
|
*ppData = pNode->GetData();
|
|
dwStatus = S_OK;
|
|
break;
|
|
}
|
|
else
|
|
{
|
|
pNode = (RT*)pNode->GetNext();
|
|
}
|
|
}
|
|
|
|
return dwStatus;
|
|
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::BeginEnum()
|
|
{
|
|
WMISTATUS dwStatus = S_OK;
|
|
|
|
m_pEnumNode = m_pHead;
|
|
|
|
return dwStatus;
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::Next( BT** ppData )
|
|
{
|
|
WMISTATUS dwStatus = WBEM_S_FALSE;
|
|
|
|
if ( NULL != m_pEnumNode )
|
|
{
|
|
*ppData = m_pEnumNode->GetData();
|
|
m_pEnumNode = (RT*)m_pEnumNode->GetNext();
|
|
dwStatus = S_OK;
|
|
}
|
|
|
|
return dwStatus;
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
WMISTATUS CCache<BT,RT>::EndEnum()
|
|
{
|
|
WMISTATUS dwStatus = S_OK;
|
|
|
|
m_pEnumNode = NULL;
|
|
|
|
return dwStatus;
|
|
};
|
|
|
|
template<class BT, class RT>
|
|
bool CCache<BT,RT>::FindByKey( WCHAR* wszKey, BT* pData )
|
|
{
|
|
BT Data;
|
|
bool bRet = FALSE;
|
|
|
|
BeginEnum();
|
|
|
|
while( WBEM_S_FALSE != Next( &Data ) )
|
|
{
|
|
if ( pData->IsValueByKey( wszKey ) )
|
|
{
|
|
*pData = Data;
|
|
bRet = TRUE;
|
|
break;
|
|
}
|
|
}
|
|
|
|
EndEnum();
|
|
|
|
return bRet;
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
//
|
|
// CInstanceCache
|
|
// ==============
|
|
//
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
|
|
|
|
class CInstanceCache : public CCache<CCookingInstance,CObjRecord<CCookingInstance> >
|
|
{
|
|
public:
|
|
};
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
//
|
|
// CEnumInstanceRecord
|
|
// ===================
|
|
//
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
class CInstanceRecord
|
|
{
|
|
long m_lID;
|
|
LPWSTR m_wszName;
|
|
|
|
public:
|
|
CInstanceRecord( LPWSTR wszName, long lID );
|
|
virtual ~CInstanceRecord();
|
|
|
|
long GetID(){ return m_lID; }
|
|
LPWSTR GetKey(){ return m_wszName; }
|
|
};
|
|
|
|
|
|
//
|
|
// used to add/remove an instance from the coooker
|
|
// and from the fastprox enumerator
|
|
//
|
|
|
|
typedef struct tagEnumCookId {
|
|
long CookId;
|
|
long EnumId;
|
|
} EnumCookId;
|
|
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
//
|
|
// CEnumeratorManager
|
|
// ==================
|
|
//
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
class CWMISimpleObjectCooker;
|
|
|
|
class BstrAlloc : public wbem_allocator<WString>
|
|
{
|
|
};
|
|
|
|
class CEnumeratorManager
|
|
// Manages a single enumerator
|
|
{
|
|
DWORD m_dwSignature;
|
|
LONG m_cRef;
|
|
HRESULT m_InithRes;
|
|
CRITICAL_SECTION m_cs;
|
|
|
|
CWMISimpleObjectCooker* m_pCooker; // The class' cooker
|
|
long m_lRawID; // RawID
|
|
IWbemHiPerfEnum* m_pRawEnum; // The hiperf cooked enumerator
|
|
IWbemHiPerfEnum* m_pCookedEnum; // The hiperf cooked enumerator
|
|
|
|
IWbemClassObject* m_pCookedClass; // The class definition for the cooking class
|
|
|
|
std::vector<WString,BstrAlloc> m_pKeyProps;
|
|
WCHAR* m_wszCookingClassName;
|
|
BOOL m_IsSingleton;
|
|
|
|
// to keep track of the differences
|
|
// between the raw enum and our enum
|
|
DWORD m_dwUsage;
|
|
std::map< ULONG_PTR , EnumCookId , std::less<ULONG_PTR> ,wbem_allocator<EnumCookId> > m_mapID;
|
|
std::vector< ULONG_PTR , wbem_allocator<ULONG_PTR> > m_Delta[2];
|
|
DWORD m_dwVector;
|
|
|
|
// members
|
|
WMISTATUS Initialize( IWbemClassObject* pRawClass );
|
|
|
|
WMISTATUS CreateCookingObject( IWbemObjectAccess* pRawObject, IWbemObjectAccess** ppCookedObject );
|
|
|
|
WMISTATUS InsertCookingRecord( IWbemObjectAccess* pRawObject, EnumCookId * pStruct, DWORD dwRefreshStamp );
|
|
|
|
WMISTATUS RemoveCookingRecord( EnumCookId * pEnumCookId );
|
|
|
|
WMISTATUS GetRawEnumObjects( std::vector<IWbemObjectAccess*, wbem_allocator<IWbemObjectAccess*> > & refArray,
|
|
std::vector<ULONG_PTR, wbem_allocator<ULONG_PTR> > & refObjHashKeys);
|
|
|
|
WMISTATUS SortRawArray(std::vector<IWbemObjectAccess*, wbem_allocator<IWbemObjectAccess*> > & refArray );
|
|
|
|
WMISTATUS UpdateEnums(std::vector<ULONG_PTR, wbem_allocator<ULONG_PTR> > & apObjAccess);
|
|
|
|
public:
|
|
CEnumeratorManager( LPCWSTR wszCookingClass, IWbemClassObject* pCookedClass, IWbemClassObject* pRawClass, IWbemHiPerfEnum* pCookedEnum, IWbemHiPerfEnum* pRawEnum, long lRawID );
|
|
virtual ~CEnumeratorManager();
|
|
|
|
HRESULT GetInithResult(){ return m_InithRes; };
|
|
|
|
WMISTATUS Refresh( DWORD dwRefreshStamp );
|
|
long GetRawId(void){ return m_lRawID; };
|
|
LONG AddRef();
|
|
LONG Release();
|
|
|
|
};
|
|
|
|
///////////////////////////////////////////////////////////////
|
|
//
|
|
// CEnumeratorCache
|
|
// ================
|
|
//
|
|
///////////////////////////////////////////////////////////////
|
|
|
|
class CEnumeratorCache
|
|
{
|
|
DWORD m_dwRefreshStamp; // The refresh counter
|
|
DWORD m_dwEnum; // The enumerator index
|
|
|
|
std::vector<CEnumeratorManager*, wbem_allocator<CEnumeratorManager*> > m_apEnumerators;
|
|
CRITICAL_SECTION m_cs;
|
|
|
|
WMISTATUS Initialize();
|
|
|
|
public:
|
|
CEnumeratorCache();
|
|
virtual ~CEnumeratorCache();
|
|
|
|
WMISTATUS AddEnum(
|
|
LPCWSTR wszCookingClass,
|
|
IWbemClassObject* pCookedClass,
|
|
IWbemClassObject* pRawClass,
|
|
IWbemHiPerfEnum* pCookedEnum,
|
|
IWbemHiPerfEnum* pRawEnum,
|
|
long lID,
|
|
DWORD* pdwID );
|
|
|
|
WMISTATUS RemoveEnum( DWORD dwID , long * pRawId);
|
|
|
|
WMISTATUS Refresh(DWORD dwRefreshStamp);
|
|
};
|
|
|
|
//
|
|
// Simple Cache based on the std::map
|
|
// It will use the ID semantics:
|
|
// Insertion will return an ID that need to be
|
|
// used for deletion
|
|
// ids are unique for the lifetime of the Cache object
|
|
//
|
|
|
|
template <class T>
|
|
class IdCache {
|
|
|
|
private:
|
|
|
|
std::map<DWORD, T> m_map;
|
|
DWORD m_NextId;
|
|
std::map<DWORD, T>::iterator m_it;
|
|
CRITICAL_SECTION m_cs;
|
|
|
|
public:
|
|
IdCache():m_NextId(0){
|
|
InitializeCriticalSection(&m_cs);
|
|
};
|
|
virtual ~IdCache(){
|
|
DeleteCriticalSection(&m_cs);
|
|
};
|
|
void Lock(){
|
|
EnterCriticalSection(&m_cs);
|
|
}
|
|
void Unlock(){
|
|
LeaveCriticalSection(&m_cs);
|
|
};
|
|
|
|
// traditional interfaces
|
|
HRESULT Add( DWORD * pId, T Elem);
|
|
HRESULT GetData(DWORD Id, T * pElem);
|
|
HRESULT Remove(DWORD Id, T * pRemovedElem);
|
|
|
|
// before calling this, delete the elements !!!!
|
|
HRESULT RemoveAll(void);
|
|
|
|
// Enumerator Style
|
|
HRESULT BeginEnum(void);
|
|
HRESULT Next(T * pElem);
|
|
HRESULT EndEnum(void);
|
|
};
|
|
|
|
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::Add( DWORD * pId, T Elem){
|
|
HRESULT hr;
|
|
Lock();
|
|
if (pId) {
|
|
|
|
std::map<DWORD, T>::iterator it = m_map.find(m_NextId);
|
|
|
|
if (it != m_map.end()) {
|
|
|
|
// should never happen
|
|
hr = E_FAIL;
|
|
|
|
} else {
|
|
|
|
m_map[m_NextId] = Elem;
|
|
*pId = m_NextId;
|
|
|
|
InterlockedIncrement((PLONG)&m_NextId);
|
|
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
} else {
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
Unlock();
|
|
return hr;
|
|
}
|
|
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::GetData(DWORD Id, T * pElem){
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
Lock();
|
|
std::map<DWORD, T>::iterator it = m_map.find(Id);
|
|
|
|
if (it != m_map.end()){
|
|
|
|
*pElem = (*it).second;
|
|
|
|
} else {
|
|
hr = WBEM_E_NOT_FOUND;
|
|
}
|
|
Unlock();
|
|
return hr;
|
|
}
|
|
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::Remove(DWORD Id, T * pRemovedElem){
|
|
|
|
HRESULT hr = WBEM_S_NO_ERROR;
|
|
Lock();
|
|
if (pRemovedElem) {
|
|
|
|
std::map<DWORD, T>::iterator it = m_map.find(Id);
|
|
|
|
if (it != m_map.end()) {
|
|
|
|
*pRemovedElem = (*it).second;
|
|
m_map.erase(it);
|
|
|
|
} else {
|
|
hr = WBEM_E_NOT_FOUND;
|
|
}
|
|
|
|
} else {
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
Unlock();
|
|
return hr;
|
|
|
|
}
|
|
|
|
//
|
|
// DEVDEV Empty the cache before removing from std::map
|
|
//
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::RemoveAll(void){
|
|
Lock();
|
|
m_map.erase(m_map.begin(),m_map.end());
|
|
Unlock();
|
|
return WBEM_S_NO_ERROR;
|
|
};
|
|
|
|
//
|
|
// DEVDEV Consider using Lock if no exception ....
|
|
//
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::BeginEnum(void){
|
|
Lock();
|
|
m_it = m_map.begin();
|
|
return WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::Next(T * pElem){
|
|
HRESULT hr;
|
|
|
|
if (pElem){
|
|
if (m_it == m_map.end()){
|
|
hr = WBEM_S_NO_MORE_DATA;
|
|
} else {
|
|
* pElem = (*m_it).second;
|
|
++m_it;
|
|
hr = WBEM_S_NO_ERROR;
|
|
}
|
|
} else {
|
|
hr = WBEM_E_INVALID_PARAMETER;
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
template <class T>
|
|
HRESULT
|
|
IdCache<T>::EndEnum(void){
|
|
Unlock();
|
|
return WBEM_S_NO_ERROR;
|
|
}
|
|
|
|
|
|
#endif //_CACHE_H_
|