TCS::Heap< T > Class Template Reference

#include <Heap.h>

Collaboration diagram for TCS::Heap< T >:

Classes
class	HeapStructure

Public Member Functions
	Heap (const std::string &name, size_t capacity=120)
	~Heap ()
void	clear ()
T *	create (const T &obj)
	create an object on the heap
size_t	size () const
size_t	capacity () const

Private Member Functions
void *	allocate (size_t size)
void	deallocate (void *&mem)
void	extend ()

Private Attributes
HeapStructure	m_heap
std::string	m_name {}
size_t	m_originalCapacity {0}

Detailed Description

template<class T>
class TCS::Heap< T >

Definition at line 13 of file Heap.h.

Constructor & Destructor Documentation

Heap()

template<class T>

TCS::Heap< T >::Heap ( const std::string & name, size_t capacity = 120 )

inline

Definition at line 15 of file Heap.h.

                                                          :
         m_name(name),
         m_originalCapacity(capacity)
      {
         m_heap.heap = allocate(m_originalCapacity);
         m_heap.pos = (T*)m_heap.heap;
      }

~Heap()

template<class T>

TCS::Heap< T >::~Heap ( )

inline

Definition at line 23 of file Heap.h.

              {
         clear();
         deallocate(m_heap.heap);
         m_heap.heap = nullptr;
         m_heap.pos = nullptr;
      }

Member Function Documentation

allocate()

template<class T>

void * TCS::Heap< T >::allocate ( size_t size )

inlineprivate

Definition at line 80 of file Heap.h.

                            {
         return ::operator new ( size * sizeof(T) );
      }

capacity()

template<class T>

size_t TCS::Heap< T >::capacity ( ) const

inline

Definition at line 62 of file Heap.h.

                              {
         return (m_heap.heapCollection.size() + 1) * m_originalCapacity;
      }

clear()

template<class T>

void TCS::Heap< T >::clear ( )

inline

Definition at line 32 of file Heap.h.

              {
         // destruct objects on the currently active memory block
         T * p = (T*)m_heap.heap;
         while(p != m_heap.pos) {
            (p++)->~T();
         }
         m_heap.pos = (T*)m_heap.heap; // reset the position to the beginning of the active memory block
         // destroy objects on all other memory blocks
         for(void * heap : m_heap.heapCollection) {
            T * p = (T*)heap;
            for(unsigned int t=0; t<m_originalCapacity; ++t)
               (p++)->~T();
            deallocate(heap); // destroy other blocks
         }
         m_heap.heapCollection.clear(); // clear the collection of memory blocks
      }

create()

template<class T>

T * TCS::Heap< T >::create ( const T & obj )

inline

create an object on the heap

Definition at line 50 of file Heap.h.

                               {
         if(  (int)(m_heap.pos - (T*)m_heap.heap) == (int)m_originalCapacity ) {
            extend();
         }
         T* newObject = new(m_heap.pos++) T(obj);
         return newObject;
      }

deallocate()

template<class T>

void TCS::Heap< T >::deallocate ( void *& mem )

inlineprivate

Definition at line 85 of file Heap.h.

                              {
         ::operator delete ( mem );
         mem = nullptr;
      }

extend()

template<class T>

void TCS::Heap< T >::extend ( )

inlineprivate

Definition at line 91 of file Heap.h.

               {
         m_heap.heapCollection.push_back(m_heap.heap); // park the old heap which has grown too small
         m_heap.heap = allocate(m_originalCapacity); // create a new heap the same size as the original one
         m_heap.pos = (T*)m_heap.heap; // make current position point to it
      }

size()

template<class T>

size_t TCS::Heap< T >::size ( ) const

inline

Definition at line 58 of file Heap.h.

                          {
         return (m_heap.pos - (T*)m_heap.heap) + m_heap.heapCollection.size() * m_originalCapacity;
      }

Member Data Documentation

m_heap

template<class T>

HeapStructure TCS::Heap< T >::m_heap

private

Definition at line 75 of file Heap.h.

m_name

template<class T>

std::string TCS::Heap< T >::m_name {}

private

Definition at line 76 of file Heap.h.

{};

m_originalCapacity

template<class T>

size_t TCS::Heap< T >::m_originalCapacity {0}

private

Definition at line 77 of file Heap.h.

{0};

---

The documentation for this class was generated from the following file:

• Heap.h