cWinHeap.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cWinHeap_H
#define _INC_cWinHeap_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cOSHandle.h"
#include "cUnitTestDecl.h"
 
#if defined(_WIN32) && ! defined(UNDER_CE)
 
namespace Gray
{
        class GRAYCORE_LINK cWinHeap
        {
 
        private:
                HANDLE m_hHeap;         
                bool m_bManaged;        
 
        public:
                cWinHeap() noexcept
                : m_hHeap(::GetProcessHeap())
                , m_bManaged(false)             // This belongs to the process. leave it.
                {
                }
                cWinHeap(HANDLE hHeap, bool bManaged = true) noexcept
                : m_hHeap(hHeap)
                , m_bManaged(bManaged)
                {
                }
                cWinHeap(DWORD flOptions, SIZE_T dwInitialSize = 0, SIZE_T dwMaximumSize = 0) noexcept
                : m_hHeap(::HeapCreate(flOptions, dwInitialSize, dwMaximumSize))
                , m_bManaged(true)
                {
                }
                ~cWinHeap() noexcept
                {
                        if (m_bManaged)
                        {
                                ::HeapDestroy(m_hHeap);
                        }
                }
 
                HANDLE get_Handle() const noexcept
                {
                        return m_hHeap;
                }
                bool isValidHeap() const noexcept
                {
                        return m_hHeap != HANDLE_NULL;
                }
                SIZE_T Compact(DWORD dwFlags = 0) const noexcept
                {
                        return ::HeapCompact(m_hHeap, dwFlags);
                }
 
#ifndef UNDER_CE
                bool Lock()
                {
                        return ::HeapLock(m_hHeap);
                }
                bool Unlock()
                {
                        return ::HeapUnlock(m_hHeap);
                }
                bool QueryInformation(HEAP_INFORMATION_CLASS HeapInformationClass, void* pData, SIZE_T* pnSizeData) noexcept
                {
                        // HeapInformationClass = HeapEnableTerminationOnCorruption, HeapCompatibilityInformation
                        return ::HeapQueryInformation(m_hHeap, HeapInformationClass, pData, *pnSizeData, pnSizeData);
                }
                bool SetInformation(HEAP_INFORMATION_CLASS HeapInformationClass, const void* pData, SIZE_T nSizeData) noexcept
                {
                        // HeapInformationClass = HeapEnableTerminationOnCorruption, HeapCompatibilityInformation
                        return ::HeapSetInformation(m_hHeap, HeapInformationClass, const_cast<void*>(pData), nSizeData);
                }
#endif
 
#if 0
                // HeapWalk
#endif
 
                bool IsValidHeapPtr(void* pMem = nullptr, DWORD dwFlags = 0) const noexcept
                {
                        return ::HeapValidate(m_hHeap, dwFlags, pMem);
                }
 
                void* AllocPtr(SIZE_T dwBytes, DWORD dwFlags = 0)
                {
                        return ::HeapAlloc(m_hHeap, dwFlags, dwBytes);
                }
                void* ReAllocPtr(void* pMem, SIZE_T dwBytes, DWORD dwFlags = 0)
                {
                        return ::HeapReAlloc(m_hHeap, dwFlags, pMem, dwBytes);
                }
                bool FreePtr(void* pMem, DWORD dwFlags = 0)
                {
                        return ::HeapFree(m_hHeap, dwFlags, pMem);
                }
                SIZE_T GetAllocPtrSize(const void* pMem, DWORD dwFlags = 0) const noexcept
                {
                        return ::HeapSize(m_hHeap, dwFlags, pMem);
                }
 
                UNITTEST_FRIEND(cWinHeap);
        };
}
 
#endif
#endif // _INC_cWinHeap_H