cHeapObject.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cHeapObject_H
#define _INC_cHeapObject_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "cHeap.h" // cHeap
 
#if defined(_DEBUG) || defined(_DEBUG_FAST)
#define USE_HEAPSIG
#endif
 
namespace Gray
{
        DECLARE_INTERFACE(IHeapObject)
        {
 
                IGNORE_WARN_INTERFACE(IHeapObject);
 
                virtual const void* get_HeapPtr() const noexcept = 0;   
 
                // Add this to each IHeapObject rooted object to get the base heap allocation pointer. Avoids problems with multiple inheritance and heap allocated objects.
#define CHEAPOBJECT_IMPL const void* get_HeapPtr() const noexcept override { return this; }
        };
 
        //*************************************************
 
        class GRAYCORE_LINK cHeapObject : public IHeapObject
        {
 
        protected:
                // Get the top level malloc() pointer in the case of multiple inheritance.
                CHEAPOBJECT_IMPL;
#ifdef USE_HEAPSIG
                cMemSignature<> m_Sig;  
#endif
 
        public:
                cHeapObject()
                {
                }
                virtual ~cHeapObject()
                {
                }
                bool IsValidInsideN(INT_PTR index) const
                {
#ifdef USE_HEAPSIG
                        if (!m_Sig.isValidSignature())
                                return false;
#endif
                        const void* pBase = get_HeapPtr();
                        return cHeapAlign::IsValidInside(pBase, index);
                }
                bool IsValidInsidePtr(void const* pTest) const
                {
                        if (pTest == nullptr)
                                return false;
#ifdef USE_HEAPSIG
                        if (!m_Sig.isValidSignature())
                                return false;
#endif
                        const void* pBase = get_HeapPtr();
                        return cHeapAlign::IsValidInside(pBase, cMem::Diff(pTest, pBase));
                }
                virtual size_t GetHeapStatsThis(OUT ITERATE_t& iAllocCount) const
                {
#ifdef USE_HEAPSIG
                        ASSERT(m_Sig.isValidSignature());
#endif
                        iAllocCount++;
                        return cHeapAlign::GetSize(get_HeapPtr());
                }
                virtual bool isValidCheck() const noexcept
                {
                        if (!cMem::IsValidApp(this))    // NOT be based on nullptr ? sanity check.
                                return false;
#ifdef USE_HEAPSIG
                        if (!m_Sig.isValidSignature())
                                return false;
#endif
                        if (!cHeapAlign::IsValidHeap(get_HeapPtr()))    // might be aligned.
                                return false;
                        return true;
                }
        };
 
        // Create an ^2 aligned pool for allocation of these objects.
#define DECLARE_HEAP_ALIGNED_ALLOCN(_CLASS,_IALIGN) public: \
        static void* operator new( size_t nCount) \
        { return cHeapAlign::AllocPtr( nCount, _IALIGN ); } \
        static void operator delete(void* pData) \
        { cHeapAlign::FreePtr(pData); }
 
#define DECLARE_HEAP_ALIGNED_ALLOC(_CLASS) DECLARE_HEAP_ALIGNED_ALLOCN(_CLASS,__alignof( _CLASS ))
};
 
#endif // _INC_cHeapObject_H