mirror of
https://github.com/nillerusr/source-engine.git
synced 2026-08-09 02:09:35 +00:00
1
This commit is contained in:
FluorescentCIAAfricanAmerican
@@ -0,0 +1,854 @@
|
||||
/*******************************************************************************
|
||||
* SPDDKHLP.h *
|
||||
*------------*
|
||||
* Description:
|
||||
* This is the header file for core helper functions implementation.
|
||||
*
|
||||
* Copyright (c) Microsoft Corporation. All rights reserved.
|
||||
*
|
||||
*******************************************************************************/
|
||||
#ifndef SPDDKHLP_h
|
||||
#define SPDDKHLP_h
|
||||
|
||||
#ifndef SPHelper_h
|
||||
#include <sphelper.h>
|
||||
#endif
|
||||
|
||||
#include <sapiddk.h>
|
||||
|
||||
#ifndef SPError_h
|
||||
#include <SPError.h>
|
||||
#endif
|
||||
|
||||
#ifndef SPDebug_h
|
||||
#include <SPDebug.h>
|
||||
#endif
|
||||
|
||||
#ifndef _INC_LIMITS
|
||||
#include <limits.h>
|
||||
#endif
|
||||
|
||||
#ifndef _INC_CRTDBG
|
||||
#include <crtdbg.h>
|
||||
#endif
|
||||
|
||||
#ifndef _INC_MALLOC
|
||||
#include <malloc.h>
|
||||
#endif
|
||||
|
||||
#ifndef _INC_MMSYSTEM
|
||||
#include <mmsystem.h>
|
||||
#endif
|
||||
|
||||
#ifndef __comcat_h__
|
||||
#include <comcat.h>
|
||||
#endif
|
||||
|
||||
//=== Constants ==============================================================
|
||||
#define sp_countof(x) ((sizeof(x) / sizeof(*(x))))
|
||||
|
||||
#define SP_IS_BAD_WRITE_PTR(p) ( SPIsBadWritePtr( p, sizeof(*(p)) ))
|
||||
#define SP_IS_BAD_READ_PTR(p) ( SPIsBadReadPtr( p, sizeof(*(p)) ))
|
||||
#define SP_IS_BAD_CODE_PTR(p) ( ::IsBadCodePtr((FARPROC)(p) )
|
||||
#define SP_IS_BAD_INTERFACE_PTR(p) ( SPIsBadInterfacePtr( (p) ) )
|
||||
#define SP_IS_BAD_VARIANT_PTR(p) ( SPIsBadVARIANTPtr( (p) ) )
|
||||
#define SP_IS_BAD_STRING_PTR(p) ( SPIsBadStringPtr( (p) ) )
|
||||
|
||||
#define SP_IS_BAD_OPTIONAL_WRITE_PTR(p) ((p) && SPIsBadWritePtr( p, sizeof(*(p)) ))
|
||||
#define SP_IS_BAD_OPTIONAL_READ_PTR(p) ((p) && SPIsBadReadPtr( p, sizeof(*(p)) ))
|
||||
#define SP_IS_BAD_OPTIONAL_INTERFACE_PTR(p) ((p) && SPIsBadInterfacePtr(p))
|
||||
#define SP_IS_BAD_OPTIONAL_STRING_PTR(p) ((p) && SPIsBadStringPtr(p))
|
||||
|
||||
//=== Class, Enum, Struct, Template, and Union Declarations ==================
|
||||
|
||||
//=== Inlines ================================================================
|
||||
|
||||
/*** Pointer validation functions
|
||||
*/
|
||||
|
||||
// TODO: Add decent debug output for bad parameters
|
||||
|
||||
inline BOOL SPIsBadStringPtr( const WCHAR * psz, ULONG cMaxChars = 0xFFFF )
|
||||
{
|
||||
BOOL IsBad = false;
|
||||
__try
|
||||
{
|
||||
do
|
||||
{
|
||||
if( *psz++ == 0 ) return IsBad;
|
||||
}
|
||||
while( --cMaxChars );
|
||||
}
|
||||
__except( GetExceptionCode() == EXCEPTION_ACCESS_VIOLATION )
|
||||
{
|
||||
IsBad = true;
|
||||
}
|
||||
|
||||
return IsBad;
|
||||
}
|
||||
|
||||
inline BOOL SPIsBadReadPtr( const void* pMem, UINT Size )
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
BOOL bIsBad = ::IsBadReadPtr( pMem, Size );
|
||||
SPDBG_ASSERT(!bIsBad);
|
||||
return bIsBad;
|
||||
#else
|
||||
return ::IsBadReadPtr( pMem, Size );
|
||||
#endif
|
||||
}
|
||||
|
||||
inline BOOL SPIsBadWritePtr( void* pMem, UINT Size )
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
BOOL bIsBad = ::IsBadWritePtr( pMem, Size );
|
||||
SPDBG_ASSERT(!bIsBad);
|
||||
return bIsBad;
|
||||
#else
|
||||
return ::IsBadWritePtr( pMem, Size );
|
||||
#endif
|
||||
}
|
||||
|
||||
inline BOOL SPIsBadInterfacePtr( const IUnknown* pUnknown )
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
BOOL bIsBad = ( ::IsBadReadPtr( pUnknown, sizeof( *pUnknown ) ) ||
|
||||
::IsBadCodePtr( (FARPROC)((void**)pUnknown)[0] ))?
|
||||
(true):(false);
|
||||
SPDBG_ASSERT(!bIsBad);
|
||||
return bIsBad;
|
||||
#else
|
||||
return ( ::IsBadReadPtr( pUnknown, sizeof( *pUnknown ) ) ||
|
||||
::IsBadCodePtr( (FARPROC)((void**)pUnknown)[0] ))?
|
||||
(true):(false);
|
||||
#endif
|
||||
}
|
||||
|
||||
inline BOOL SPIsBadVARIANTPtr( const VARIANT* pVar )
|
||||
{
|
||||
#ifdef _DEBUG
|
||||
BOOL bIsBad = ::IsBadReadPtr( pVar, sizeof( *pVar ) );
|
||||
SPDBG_ASSERT(!bIsBad);
|
||||
return bIsBad;
|
||||
#else
|
||||
return ::IsBadReadPtr( pVar, sizeof( *pVar ) );
|
||||
#endif
|
||||
}
|
||||
|
||||
#ifdef __ATLCOM_H__ //--- Only enable these if ATL is being used
|
||||
|
||||
//
|
||||
// Helper functions can be used to implement GetObjectToken/SetObjectToken for objects that
|
||||
// support ISpObjectWithToken
|
||||
//
|
||||
inline HRESULT SpGenericSetObjectToken(ISpObjectToken * pCallersToken, CComPtr<ISpObjectToken> & cpObjToken)
|
||||
{
|
||||
HRESULT hr = S_OK;
|
||||
if (SP_IS_BAD_INTERFACE_PTR(pCallersToken))
|
||||
{
|
||||
hr = E_INVALIDARG;
|
||||
}
|
||||
else
|
||||
{
|
||||
if (cpObjToken)
|
||||
{
|
||||
hr = SPERR_ALREADY_INITIALIZED;
|
||||
}
|
||||
else
|
||||
{
|
||||
cpObjToken = pCallersToken;
|
||||
}
|
||||
}
|
||||
return hr;
|
||||
}
|
||||
|
||||
|
||||
inline HRESULT SpGenericGetObjectToken(ISpObjectToken ** ppCallersToken, CComPtr<ISpObjectToken> & cpObjToken)
|
||||
{
|
||||
HRESULT hr = S_OK;
|
||||
if (SP_IS_BAD_WRITE_PTR(ppCallersToken))
|
||||
{
|
||||
hr = E_POINTER;
|
||||
}
|
||||
else
|
||||
{
|
||||
*ppCallersToken = cpObjToken;
|
||||
if (*ppCallersToken)
|
||||
{
|
||||
(*ppCallersToken)->AddRef();
|
||||
}
|
||||
else
|
||||
{
|
||||
hr = S_FALSE;
|
||||
}
|
||||
}
|
||||
return hr;
|
||||
}
|
||||
|
||||
#endif // __ATLCOM_H__
|
||||
|
||||
|
||||
//
|
||||
// Helper class for SPSTATEINFO sturcture automatically initializes and cleans up
|
||||
// the structure + provides a few helper functions.
|
||||
//
|
||||
class CSpStateInfo : public SPSTATEINFO
|
||||
{
|
||||
public:
|
||||
CSpStateInfo()
|
||||
{
|
||||
cAllocatedEntries = NULL;
|
||||
pTransitions = NULL;
|
||||
}
|
||||
~CSpStateInfo()
|
||||
{
|
||||
::CoTaskMemFree(pTransitions);
|
||||
}
|
||||
SPTRANSITIONENTRY * FirstEpsilon()
|
||||
{
|
||||
return pTransitions;
|
||||
}
|
||||
SPTRANSITIONENTRY * FirstRule()
|
||||
{
|
||||
return pTransitions + cEpsilons;
|
||||
}
|
||||
SPTRANSITIONENTRY * FirstWord()
|
||||
{
|
||||
return pTransitions + cEpsilons + cRules;
|
||||
}
|
||||
SPTRANSITIONENTRY * FirstSpecialTransition()
|
||||
{
|
||||
return pTransitions + cEpsilons + cRules + cWords;
|
||||
}
|
||||
};
|
||||
|
||||
|
||||
//
|
||||
// This basic queue implementation can be used to maintin linked lists of classes. The class T
|
||||
// must contain the member m_pNext which is used by this template to point to the next element.
|
||||
// If the bPurgeWhenDeleted is TRUE then all of the elements in the queue will be deleted
|
||||
// when the queue is deleted, otherwise they will not.
|
||||
// If bMaintainCount is TRUE then a running count will be maintained, and GetCount() will be
|
||||
// efficent. If it is FALSE then a running count will not be maintained, and GetCount() will
|
||||
// be an order N operation. If you do not require a count, then
|
||||
//
|
||||
|
||||
template <class T, BOOL bPurgeWhenDeleted> class CSpBasicList;
|
||||
|
||||
template <class T, BOOL bPurgeWhenDeleted = TRUE, BOOL bMaintainCount = FALSE>
|
||||
class CSpBasicQueue
|
||||
{
|
||||
public:
|
||||
T * m_pHead;
|
||||
T * m_pTail;
|
||||
ULONG m_cElements; // Warning! Use GetCount() -- Not maintained if bMaintainCount is FALSE.
|
||||
|
||||
CSpBasicQueue()
|
||||
{
|
||||
m_pHead = NULL;
|
||||
if (bMaintainCount)
|
||||
{
|
||||
m_cElements = 0;
|
||||
}
|
||||
}
|
||||
|
||||
~CSpBasicQueue()
|
||||
{
|
||||
if (bPurgeWhenDeleted)
|
||||
{
|
||||
Purge();
|
||||
}
|
||||
}
|
||||
|
||||
HRESULT CreateNode(T ** ppNode)
|
||||
{
|
||||
*ppNode = new T;
|
||||
if (*ppNode)
|
||||
{
|
||||
return S_OK;
|
||||
}
|
||||
else
|
||||
{
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
}
|
||||
|
||||
T * GetNext(const T * pNode)
|
||||
{
|
||||
return pNode->m_pNext;
|
||||
}
|
||||
|
||||
|
||||
T * Item(ULONG i)
|
||||
{
|
||||
T * pNode = m_pHead;
|
||||
while (pNode && i)
|
||||
{
|
||||
i--;
|
||||
pNode = pNode->m_pNext;
|
||||
}
|
||||
return pNode;
|
||||
}
|
||||
|
||||
void InsertAfter(T * pPrev, T * pNewNode)
|
||||
{
|
||||
if (pPrev)
|
||||
{
|
||||
pNewNode->m_pNext = pPrev->m_pNext;
|
||||
pPrev->m_pNext = pNewNode;
|
||||
if (pNewNode->m_pNext == NULL)
|
||||
{
|
||||
m_pTail = pNewNode;
|
||||
}
|
||||
if (bMaintainCount) ++m_cElements;
|
||||
}
|
||||
else
|
||||
{
|
||||
InsertHead(pNewNode);
|
||||
}
|
||||
}
|
||||
|
||||
void InsertTail(T * pNode)
|
||||
{
|
||||
pNode->m_pNext = NULL;
|
||||
if (m_pHead)
|
||||
{
|
||||
m_pTail->m_pNext = pNode;
|
||||
}
|
||||
else
|
||||
{
|
||||
m_pHead = pNode;
|
||||
}
|
||||
m_pTail = pNode;
|
||||
if (bMaintainCount) ++m_cElements;
|
||||
}
|
||||
|
||||
void InsertHead(T * pNode)
|
||||
{
|
||||
pNode->m_pNext = m_pHead;
|
||||
if (m_pHead == NULL)
|
||||
{
|
||||
m_pTail = pNode;
|
||||
}
|
||||
m_pHead = pNode;
|
||||
if (bMaintainCount) ++m_cElements;
|
||||
}
|
||||
|
||||
T * RemoveHead()
|
||||
{
|
||||
T * pNode = m_pHead;
|
||||
if (pNode)
|
||||
{
|
||||
m_pHead = pNode->m_pNext;
|
||||
if (bMaintainCount) --m_cElements;
|
||||
}
|
||||
return pNode;
|
||||
}
|
||||
|
||||
T * RemoveTail()
|
||||
{
|
||||
T * pNode = m_pHead;
|
||||
if (pNode)
|
||||
{
|
||||
if (pNode == m_pTail)
|
||||
{
|
||||
m_pHead = NULL;
|
||||
}
|
||||
else
|
||||
{
|
||||
T * pPrev;
|
||||
do
|
||||
{
|
||||
pPrev = pNode;
|
||||
pNode = pNode->m_pNext;
|
||||
} while ( pNode != m_pTail );
|
||||
pPrev->m_pNext = NULL;
|
||||
m_pTail = pPrev;
|
||||
}
|
||||
if (bMaintainCount) --m_cElements;
|
||||
}
|
||||
return pNode;
|
||||
}
|
||||
|
||||
void Purge()
|
||||
{
|
||||
while (m_pHead)
|
||||
{
|
||||
T * pDie = m_pHead;
|
||||
m_pHead = pDie->m_pNext;
|
||||
delete pDie;
|
||||
}
|
||||
if (bMaintainCount) m_cElements = 0;
|
||||
}
|
||||
|
||||
void ExplicitPurge()
|
||||
{
|
||||
T * pDie;
|
||||
BYTE * pb;
|
||||
|
||||
while (m_pHead)
|
||||
{
|
||||
pDie = m_pHead;
|
||||
m_pHead = pDie->m_pNext;
|
||||
|
||||
pDie->~T();
|
||||
|
||||
pb = reinterpret_cast<BYTE *>(pDie);
|
||||
delete [] pb;
|
||||
}
|
||||
if (bMaintainCount) m_cElements = 0;
|
||||
}
|
||||
|
||||
|
||||
T * GetTail() const
|
||||
{
|
||||
if (m_pHead)
|
||||
{
|
||||
return m_pTail;
|
||||
}
|
||||
return NULL;
|
||||
}
|
||||
|
||||
T * GetHead() const
|
||||
{
|
||||
return m_pHead;
|
||||
}
|
||||
|
||||
BOOL IsEmpty() const
|
||||
{
|
||||
return m_pHead == NULL;
|
||||
}
|
||||
|
||||
BOOL Remove(T * pNode)
|
||||
{
|
||||
if (m_pHead == pNode)
|
||||
{
|
||||
m_pHead = pNode->m_pNext;
|
||||
if (bMaintainCount) --m_cElements;
|
||||
return TRUE;
|
||||
}
|
||||
else
|
||||
{
|
||||
T * pCur = m_pHead;
|
||||
while (pCur)
|
||||
{
|
||||
T * pNext = pCur->m_pNext;
|
||||
if (pNext == pNode)
|
||||
{
|
||||
if ((pCur->m_pNext = pNode->m_pNext) == NULL)
|
||||
{
|
||||
m_pTail = pCur;
|
||||
}
|
||||
if (bMaintainCount) --m_cElements;
|
||||
return TRUE;
|
||||
}
|
||||
pCur = pNext;
|
||||
}
|
||||
}
|
||||
return FALSE;
|
||||
}
|
||||
|
||||
void MoveAllToHeadOf(CSpBasicQueue & DestQueue)
|
||||
{
|
||||
if (m_pHead)
|
||||
{
|
||||
m_pTail->m_pNext = DestQueue.m_pHead;
|
||||
if (DestQueue.m_pHead == NULL)
|
||||
{
|
||||
DestQueue.m_pTail = m_pTail;
|
||||
}
|
||||
DestQueue.m_pHead = m_pHead;
|
||||
m_pHead = NULL;
|
||||
if (bMaintainCount)
|
||||
{
|
||||
DestQueue.m_cElements += m_cElements;
|
||||
m_cElements = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void MoveAllToList(CSpBasicList<T, bPurgeWhenDeleted> & List)
|
||||
{
|
||||
if (m_pHead)
|
||||
{
|
||||
m_pTail->m_pNext = List.m_pFirst;
|
||||
List.m_pFirst = m_pHead;
|
||||
m_pHead = NULL;
|
||||
}
|
||||
if (bMaintainCount)
|
||||
{
|
||||
m_cElements = 0;
|
||||
}
|
||||
}
|
||||
|
||||
BOOL MoveToList(T * pNode, CSpBasicList<T, bPurgeWhenDeleted> & List)
|
||||
{
|
||||
BOOL bFound = Remove(pNode);
|
||||
if (bFound)
|
||||
{
|
||||
List.AddNode(pNode);
|
||||
}
|
||||
return bFound;
|
||||
}
|
||||
|
||||
ULONG GetCount() const
|
||||
{
|
||||
if (bMaintainCount)
|
||||
{
|
||||
return m_cElements;
|
||||
}
|
||||
else
|
||||
{
|
||||
ULONG c = 0;
|
||||
for (T * pNode = m_pHead;
|
||||
pNode;
|
||||
pNode = pNode->m_pNext, c++) {}
|
||||
return c;
|
||||
}
|
||||
}
|
||||
|
||||
//
|
||||
// The following functions require the class T to implement a static function:
|
||||
//
|
||||
// LONG Compare(const T * pElem1, const T * pElem2)
|
||||
//
|
||||
// which returns < 0 if pElem1 is less than pElem2, 0 if they are equal, and > 0 if
|
||||
// pElem1 is greater than pElem2.
|
||||
//
|
||||
void InsertSorted(T * pNode)
|
||||
{
|
||||
if (m_pHead)
|
||||
{
|
||||
if (T::Compare(pNode, m_pTail) >= 0)
|
||||
{
|
||||
pNode->m_pNext = NULL;
|
||||
m_pTail->m_pNext = pNode;
|
||||
m_pTail = pNode;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// We don't have to worry about walking off of the end of the list here since
|
||||
// we have already checked the tail.
|
||||
//
|
||||
T ** ppNext = &m_pHead;
|
||||
while (T::Compare(pNode, *ppNext) >= 0)
|
||||
{
|
||||
ppNext = &((*ppNext)->m_pNext);
|
||||
}
|
||||
pNode->m_pNext = *ppNext;
|
||||
*ppNext = pNode;
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pNode->m_pNext = NULL;
|
||||
m_pHead = m_pTail = pNode;
|
||||
}
|
||||
if (bMaintainCount) ++m_cElements;
|
||||
}
|
||||
|
||||
HRESULT InsertSortedUnique(T * pNode)
|
||||
{
|
||||
HRESULT hr = S_OK;
|
||||
if (m_pHead)
|
||||
{
|
||||
if (T::Compare(pNode, m_pTail) > 0)
|
||||
{
|
||||
pNode->m_pNext = NULL;
|
||||
m_pTail->m_pNext = pNode;
|
||||
m_pTail = pNode;
|
||||
}
|
||||
else
|
||||
{
|
||||
//
|
||||
// We don't have to worry about walking off of the end of the list here since
|
||||
// we have already checked the tail.
|
||||
//
|
||||
T ** ppNext = &m_pHead;
|
||||
while (T::Compare(pNode, *ppNext) > 0)
|
||||
{
|
||||
ppNext = &((*ppNext)->m_pNext);
|
||||
}
|
||||
if (T::Compare(pNode, *ppNext) != 0)
|
||||
{
|
||||
pNode->m_pNext = *ppNext;
|
||||
*ppNext = pNode;
|
||||
}
|
||||
else
|
||||
{
|
||||
delete pNode;
|
||||
hr = S_FALSE;
|
||||
}
|
||||
}
|
||||
}
|
||||
else
|
||||
{
|
||||
pNode->m_pNext = NULL;
|
||||
m_pHead = m_pTail = pNode;
|
||||
}
|
||||
if (bMaintainCount) ++m_cElements;
|
||||
return hr;
|
||||
}
|
||||
|
||||
//
|
||||
// These functions must support the "==" operator for the TFIND type.
|
||||
//
|
||||
template <class TFIND>
|
||||
T * Find(TFIND & FindVal) const
|
||||
{
|
||||
for (T * pNode = m_pHead; pNode && (!(*pNode == FindVal)); pNode = pNode->m_pNext)
|
||||
{}
|
||||
return pNode;
|
||||
}
|
||||
|
||||
template <class TFIND>
|
||||
T * FindNext(const T * pCurNode, TFIND & FindVal) const
|
||||
{
|
||||
for (T * pNode = pCurNode->m_pNext; pNode && (!(*pNode == FindVal)); pNode = pNode->m_pNext)
|
||||
{}
|
||||
return pNode;
|
||||
}
|
||||
|
||||
//
|
||||
// Searches for and removes a single list element
|
||||
//
|
||||
template <class TFIND>
|
||||
T * FindAndRemove(TFIND & FindVal)
|
||||
{
|
||||
T * pNode = m_pHead;
|
||||
if (pNode)
|
||||
{
|
||||
if (*pNode == FindVal)
|
||||
{
|
||||
m_pHead = pNode->m_pNext;
|
||||
if (bMaintainCount) --m_cElements;
|
||||
}
|
||||
else
|
||||
{
|
||||
T * pPrev = pNode;
|
||||
for (pNode = pNode->m_pNext;
|
||||
pNode;
|
||||
pPrev = pNode, pNode = pNode->m_pNext)
|
||||
{
|
||||
if (*pNode == FindVal)
|
||||
{
|
||||
pPrev->m_pNext = pNode->m_pNext;
|
||||
if (pNode->m_pNext == NULL)
|
||||
{
|
||||
m_pTail = pPrev;
|
||||
}
|
||||
if (bMaintainCount) --m_cElements;
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
return pNode;
|
||||
}
|
||||
|
||||
//
|
||||
// Searches for and deletes all list elements that match
|
||||
//
|
||||
template <class TFIND>
|
||||
void FindAndDeleteAll(TFIND & FindVal)
|
||||
{
|
||||
T * pNode = m_pHead;
|
||||
while (pNode && *pNode == FindVal)
|
||||
{
|
||||
m_pHead = pNode->m_pNext;
|
||||
delete pNode;
|
||||
if (bMaintainCount) --m_cElements;
|
||||
pNode = m_pHead;
|
||||
}
|
||||
T * pPrev = pNode;
|
||||
while (pNode)
|
||||
{
|
||||
T * pNext = pNode->m_pNext;
|
||||
if (*pNode == FindVal)
|
||||
{
|
||||
pPrev->m_pNext = pNext;
|
||||
delete pNode;
|
||||
if (bMaintainCount) --m_cElements;
|
||||
}
|
||||
else
|
||||
{
|
||||
pPrev = pNode;
|
||||
}
|
||||
pNode = pNext;
|
||||
}
|
||||
m_pTail = pPrev; // Just always set it in case we removed the tail.
|
||||
}
|
||||
|
||||
|
||||
};
|
||||
|
||||
template <class T, BOOL bPurgeWhenDeleted = TRUE>
|
||||
class CSpBasicList
|
||||
{
|
||||
public:
|
||||
T * m_pFirst;
|
||||
CSpBasicList() : m_pFirst(NULL) {}
|
||||
~CSpBasicList()
|
||||
{
|
||||
if (bPurgeWhenDeleted)
|
||||
{
|
||||
Purge();
|
||||
}
|
||||
}
|
||||
|
||||
void Purge()
|
||||
{
|
||||
while (m_pFirst)
|
||||
{
|
||||
T * pNext = m_pFirst->m_pNext;
|
||||
delete m_pFirst;
|
||||
m_pFirst = pNext;
|
||||
}
|
||||
}
|
||||
|
||||
void ExplicitPurge()
|
||||
{
|
||||
T * pDie;
|
||||
BYTE * pb;
|
||||
|
||||
while (m_pFirst)
|
||||
{
|
||||
pDie = m_pFirst;
|
||||
m_pFirst = pDie->m_pNext;
|
||||
|
||||
pDie->~T();
|
||||
|
||||
pb = reinterpret_cast<BYTE *>(pDie);
|
||||
delete [] pb;
|
||||
}
|
||||
}
|
||||
|
||||
HRESULT RemoveFirstOrAllocateNew(T ** ppNode)
|
||||
{
|
||||
if (m_pFirst)
|
||||
{
|
||||
*ppNode = m_pFirst;
|
||||
m_pFirst = m_pFirst->m_pNext;
|
||||
}
|
||||
else
|
||||
{
|
||||
*ppNode = new T;
|
||||
if (*ppNode == NULL)
|
||||
{
|
||||
return E_OUTOFMEMORY;
|
||||
}
|
||||
}
|
||||
return S_OK;
|
||||
}
|
||||
|
||||
void AddNode(T * pNode)
|
||||
{
|
||||
pNode->m_pNext = m_pFirst;
|
||||
m_pFirst = pNode;
|
||||
}
|
||||
T * GetFirst()
|
||||
{
|
||||
return m_pFirst;
|
||||
}
|
||||
T * RemoveFirst()
|
||||
{
|
||||
T * pNode = m_pFirst;
|
||||
if (pNode)
|
||||
{
|
||||
m_pFirst = pNode->m_pNext;
|
||||
}
|
||||
return pNode;
|
||||
}
|
||||
};
|
||||
|
||||
#define STACK_ALLOC(TYPE, COUNT) (TYPE *)_alloca(sizeof(TYPE) * (COUNT))
|
||||
#define STACK_ALLOC_AND_ZERO(TYPE, COUNT) (TYPE *)memset(_alloca(sizeof(TYPE) * (COUNT)), 0, (sizeof(TYPE) * (COUNT)))
|
||||
#define STACK_ALLOC_AND_COPY(TYPE, COUNT, SOURCE) (TYPE *)memcpy(_alloca(sizeof(TYPE) * (COUNT)), (SOURCE), (sizeof(TYPE) * (COUNT)))
|
||||
|
||||
inline HRESULT SpGetSubTokenFromToken(
|
||||
ISpObjectToken * pToken,
|
||||
const WCHAR * pszSubKeyName,
|
||||
ISpObjectToken ** ppToken,
|
||||
BOOL fCreateIfNotExist = FALSE)
|
||||
{
|
||||
SPDBG_FUNC("SpGetTokenFromDataKey");
|
||||
HRESULT hr = S_OK;
|
||||
|
||||
if (SP_IS_BAD_INTERFACE_PTR(pToken) ||
|
||||
SP_IS_BAD_STRING_PTR(pszSubKeyName) ||
|
||||
SP_IS_BAD_WRITE_PTR(ppToken))
|
||||
{
|
||||
hr = E_POINTER;
|
||||
}
|
||||
|
||||
// First, either create or open the datakey for the new token
|
||||
CComPtr<ISpDataKey> cpDataKeyForNewToken;
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
if (fCreateIfNotExist)
|
||||
{
|
||||
hr = pToken->CreateKey(pszSubKeyName, &cpDataKeyForNewToken);
|
||||
}
|
||||
else
|
||||
{
|
||||
hr = pToken->OpenKey(pszSubKeyName, &cpDataKeyForNewToken);
|
||||
}
|
||||
}
|
||||
|
||||
// The sub token's category will be the token id of it's parent token
|
||||
CSpDynamicString dstrCategoryId;
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = pToken->GetId(&dstrCategoryId);
|
||||
}
|
||||
|
||||
// The sub token's token id will be it's category id + "\\" the key name
|
||||
CSpDynamicString dstrTokenId;
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
dstrTokenId = dstrCategoryId;
|
||||
dstrTokenId.Append2(L"\\", pszSubKeyName);
|
||||
}
|
||||
|
||||
// Now create the token and initalize it
|
||||
CComPtr<ISpObjectTokenInit> cpTokenInit;
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = cpTokenInit.CoCreateInstance(CLSID_SpObjectToken);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = cpTokenInit->InitFromDataKey(dstrCategoryId, dstrTokenId, cpDataKeyForNewToken);
|
||||
}
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
*ppToken = cpTokenInit.Detach();
|
||||
}
|
||||
|
||||
SPDBG_REPORT_ON_FAIL(hr);
|
||||
return hr;
|
||||
}
|
||||
|
||||
template<class T>
|
||||
HRESULT SpCreateObjectFromSubToken(ISpObjectToken * pToken, const WCHAR * pszSubKeyName, T ** ppObject,
|
||||
IUnknown * pUnkOuter = NULL, DWORD dwClsCtxt = CLSCTX_ALL)
|
||||
{
|
||||
SPDBG_FUNC("SpCreateObjectFromSubToken");
|
||||
HRESULT hr;
|
||||
|
||||
CComPtr<ISpObjectToken> cpSubToken;
|
||||
hr = SpGetSubTokenFromToken(pToken, pszSubKeyName, &cpSubToken);
|
||||
|
||||
if (SUCCEEDED(hr))
|
||||
{
|
||||
hr = SpCreateObjectFromToken(cpSubToken, ppObject, pUnkOuter, dwClsCtxt);
|
||||
}
|
||||
|
||||
SPDBG_REPORT_ON_FAIL(hr);
|
||||
return hr;
|
||||
}
|
||||
|
||||
#endif /* This must be the last line in the file */
|
||||
Reference in New Issue
Block a user