Collaboration diagram for CComCatCachedCategory:

[legend]

Public Member Functions
	CComCatCachedCategory ()

virtual	~CComCatCachedCategory ()

HRESULT	WriteCacheToDSA (HDSA pDest)

HRESULT STDMETHODCALLTYPE	Initialize (CATID &catID, BOOL reloadCache)

Private Member Functions
BOOL	LoadFromRegistry ()

HRESULT	LoadFromComCatMgr ()

HRESULT	CacheDSA ()

Private Attributes
CATID	fCategory

HDSA	fLocalDsa

Detailed Description

Definition at line 44 of file CSHEnumClassesOfCategories.cpp.

Constructor & Destructor Documentation

◆ CComCatCachedCategory()

CComCatCachedCategory::CComCatCachedCategory ( )

Definition at line 59 of file CSHEnumClassesOfCategories.cpp.

{
    fLocalDsa = DSA_Create(sizeof(GUID), 5);
}

◆ ~CComCatCachedCategory()

CComCatCachedCategory::~CComCatCachedCategory ( )

virtual

Definition at line 82 of file CSHEnumClassesOfCategories.cpp.

{
    DSA_Destroy(fLocalDsa);
}

Member Function Documentation

◆ CacheDSA()

HRESULT CComCatCachedCategory::CacheDSA ( )

private

Definition at line 121 of file CSHEnumClassesOfCategories.cpp.

{
    WCHAR                               bufKey[MAX_PATH];
    WCHAR                               guidStr[MAX_PATH];
    UINT                                elemCount;
    UINT                                i;
    UINT                                bufferSize;
    CComHeapPtr<CATCACHEHDR>            buffer;
    GUID                                *guidArray;
    GUID                                *tmp;
 
    elemCount = DSA_GetItemCount(fLocalDsa);
    bufferSize = sizeof(CATCACHEHDR) + elemCount * sizeof(GUID);
    if (!StringFromGUID2(fCategory, guidStr, MAX_PATH))
        return E_FAIL;
 
    buffer.Attach((PCATCACHEHDR)CoTaskMemAlloc(bufferSize));
    if (!buffer)
        return E_OUTOFMEMORY;
 
    // Correctly fill cache header
    buffer->dwSize = sizeof(CATCACHEHDR);
    buffer->version = 1;
    GetSystemTime(&buffer->writeTime);
    buffer->classCount = (DWORD)elemCount;
 
    guidArray = (GUID*)(buffer + 1);
    wsprintf(bufKey, L"%s\\%s\\%s", REGPATH , guidStr, L"Enum");
 
    // Write DSA contents inside the memory buffer allocated
    for(i = 0; i < elemCount; i++)
    {
        tmp = (GUID*)DSA_GetItemPtr(fLocalDsa, i);
        if (tmp)
        {
            guidArray[i] = *tmp;
        }
    }
 
    // Save items to registry
    SHSetValue(HKEY_CURRENT_USER, bufKey, IMPLEMENTING, REG_BINARY, buffer, bufferSize);
 
    guidArray = NULL;
    return S_OK;
}

Referenced by Initialize().

◆ Initialize()

HRESULT STDMETHODCALLTYPE CComCatCachedCategory::Initialize	(	CATID &	catID,
		BOOL	reloadCache
	)

Definition at line 64 of file CSHEnumClassesOfCategories.cpp.

{
    HRESULT hr;
 
    fCategory = catID;
    if (reloadCache || !LoadFromRegistry())
    {
        hr = LoadFromComCatMgr();
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
 
        hr = CacheDSA();
        if (FAILED_UNEXPECTEDLY(hr))
            return hr;
    }
    return S_OK;
}

Referenced by CSHEnumClassesOfCategories::Initialize().

◆ LoadFromComCatMgr()

HRESULT CComCatCachedCategory::LoadFromComCatMgr ( )

private

Definition at line 167 of file CSHEnumClassesOfCategories.cpp.

{
    HRESULT hr;
    CComPtr<ICatInformation> pCatInformation;
    CComPtr<IEnumGUID> pEnumGUID;
    ULONG pFetched;
    CLSID tmp;
 
    // Get component categories manager instance
    hr = CoCreateInstance(CLSID_StdComponentCategoriesMgr, NULL, CLSCTX_INPROC_SERVER,
        IID_PPV_ARG(ICatInformation, &pCatInformation));
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    // Get the proper enumerator
    hr = pCatInformation->EnumClassesOfCategories(1, &fCategory, NULL, NULL, &pEnumGUID);
    if (FAILED_UNEXPECTEDLY(hr))
        return hr;
 
    // Enumerate elements
    do
    {
        pFetched = 0;
        pEnumGUID->Next(1, &tmp, &pFetched);
        if (pFetched)
        {
            if (DSA_InsertItem(fLocalDsa, DSA_APPEND, &tmp) == E_OUTOFMEMORY)
                return E_OUTOFMEMORY;
        }
    }
    while (pFetched > 0);
    return S_OK;
}

Referenced by Initialize().

◆ LoadFromRegistry()

BOOL CComCatCachedCategory::LoadFromRegistry ( )

private

Definition at line 87 of file CSHEnumClassesOfCategories.cpp.

{
    WCHAR bufKey[MAX_PATH];
    WCHAR guidStr[MAX_PATH];
    DWORD dataSize, i;
    CComHeapPtr<CATCACHEHDR> buffer;
    GUID *guidArray;
 
    if (!fLocalDsa)
        return FALSE;
 
    dataSize = 0;
    if (!StringFromGUID2(fCategory, guidStr, MAX_PATH))
        return FALSE;
 
    wsprintf(bufKey, L"%s\\%s\\%s", REGPATH , guidStr, L"Enum");
 
    // Try to read key and get proper value size
    if (SHGetValue(HKEY_CURRENT_USER, bufKey, IMPLEMENTING, NULL, NULL, &dataSize))
        return FALSE;
 
    buffer.Attach((PCATCACHEHDR)CoTaskMemAlloc(dataSize));
 
    SHGetValue(HKEY_CURRENT_USER, bufKey, IMPLEMENTING, NULL, buffer, &dataSize);
    guidArray = (GUID*)(buffer + 1);
    for (i = 0; i < buffer->classCount; i++)
    {
        // Add class to cache
        DSA_InsertItem(fLocalDsa, DSA_APPEND, guidArray + i);
    }
 
    return TRUE;
}

Referenced by Initialize().

◆ WriteCacheToDSA()

HRESULT CComCatCachedCategory::WriteCacheToDSA ( HDSA pDest )

Definition at line 201 of file CSHEnumClassesOfCategories.cpp.

{
    INT i;
    for(i = 0; i < DSA_GetItemCount(fLocalDsa); i++)
    {
        if (DSA_InsertItem(pDest, DSA_APPEND, DSA_GetItemPtr(fLocalDsa, i)) == DSA_ERR)
            return E_OUTOFMEMORY;
    }
    return S_OK;
}