Basically a bad std::vector without exceptions which can also work with foreign memory. More...

#include <THeapBuffer.hpp>

Inheritance diagram for tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >:

Collaboration diagram for tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >:

Public Types
using	Size = SIZE
	everything using the heapbuffer uses this type Always needs to be unsigned! More...

Public Member Functions
	HeapBuffer ()=default

	HeapBuffer (const Size size)
	Setup the buffer with a size. More...

template<int Alignment2, class Allocator2 , typename Size2 >
	HeapBuffer (const HeapBuffer< T, Alignment2, Allocator2, Size2 > &source)
	Copy Constructor, calls set() Failed allocations have to be checked. More...

	HeapBuffer (const T *data, Size size)

	HeapBuffer (HeapBuffer &&source)
	Move contructor, will mark the original buffer as injected. More...

HeapBuffer &	operator= (HeapBuffer &&source)

HeapBuffer &	operator= (const HeapBuffer &)=delete

	HeapBuffer (const HeapBuffer *)=delete

	~HeapBuffer ()

template<int Alignment2, class Allocator2 , typename Size2 >
bool	set (const HeapBuffer< T, Alignment2, Allocator2, Size2 > &source)
	Resizes and copies the contents of the source Buffer This will do a memory::copy,so none of the object contructors will called. More...

bool	set (const T *data, Size size)
	Set data from array. More...

void	inject (T *mem, const Size size, const Size realSize=0)
	Provide foreign memory to borrow. More...

void	inject (const T *mem, const Size size, const Size realSize=0)
	Provide const foreign memory to use Using non const accessors will cause assertions in debug mode. More...

void	disown ()
	The memory is no longer manager by this instance. More...

bool	empty () const

T *	data ()

const T *	data () const

const T &	operator[] (const Size index) const

T &	operator[] (const Size index)

const T *	begin () const

const T *	end () const

T *	begin ()

T *	end ()

T &	last ()

T &	first ()

bool	reserve (const Size size)
	Will make sure the desired space is allocated. More...

bool	resize (const Size size, const bool downsize=true)
	Resize the buffer If the memory is borrowed it will become unique and owned by this instance as soon as an allocation happens. More...

bool	push (const T &object)
	Push the object to the back of the buffer TODO tklb move version. More...

bool	pop (T *object)
	Get the last element in the buffer. More...

bool	remove (const Size index)
	Removes the object at a given index and fills the gap with another Will never shrink the buffer/allocate. More...

bool	remove (const T &object)
	If a == comparisin is possible the object itself can be used. More...

bool	remove (const T *object)
	Otherwise use memory location. More...

bool	destroyPointers ()
	If T is a pointer type, delete will be called for all pointers in buffer and resize(0) is called. More...

void	clear ()
	Clears the buffer but doesn't free the memory. More...

bool	injected () const
	Whether the memory is managed by the instance or is borrowed. More...

Size	size () const
	Returns the amount of elements in the container. More...

Size	reserved () const
	Returns the real allocated size in elements. More...

Size	allocated () const
	Returns the size of the allocated space. More...

Static Public Member Functions
static Size	closestChunkSize (Size size, Size chunk)

static bool	isAligned (const void *ptr)

Static Public Attributes
static constexpr size_t	Alignment = ALIGNMENT

static constexpr size_t	ChunkSize = 16

Private Member Functions
bool	allocate (Size chunk) noexcept
	Allocated the exact size requsted and copies existing objects. More...

Private Attributes
ALLOCATOR	mAllocator

T *	mBuf = nullptr

Size	mSize = 0

Size	mRealSize = 0
	the actually allocated size if it's 0 the memory is not actually owned by the buffer and won't be delete with the object. More...

Detailed Description

template<typename T, size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>
class tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >

Basically a bad std::vector without exceptions which can also work with foreign memory.

Template Parameters

T	Element type need to have a default contructor
ALIGNMENT	Memory alignment in bytes needs to be a power of 2. Defaults to 0
ALLOCATOR	Normal allocator class defaults to non basic malloc/free wrapper
SIZE	Size type used for index, defaults to unsigned int to save some space

Definition at line 49 of file THeapBuffer.hpp.

Member Typedef Documentation

◆ Size

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

using tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::Size = SIZE

everything using the heapbuffer uses this type Always needs to be unsigned!

Definition at line 55 of file THeapBuffer.hpp.

Constructor & Destructor Documentation

◆ HeapBuffer() [1/6]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::HeapBuffer ( )

default

◆ HeapBuffer() [2/6]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::HeapBuffer ( const Size size )

inline

Setup the buffer with a size.

User has to check if allocation was successful.

Parameters

size	Size in elements of the buffer

Definition at line 83 of file THeapBuffer.hpp.

                                    {
            if (size != 0) { resize(size); }
        }

Here is the call graph for this function:

◆ HeapBuffer() [3/6]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

template<int Alignment2, class Allocator2 , typename Size2 >

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::HeapBuffer ( const HeapBuffer< T, Alignment2, Allocator2, Size2 > & source )

inline

Copy Constructor, calls set() Failed allocations have to be checked.

Definition at line 92 of file THeapBuffer.hpp.

92{ set(source); }

tklb::HeapBuffer::set

bool set(const HeapBuffer< T, Alignment2, Allocator2, Size2 > &source)

Resizes and copies the contents of the source Buffer This will do a memory::copy,so none of the objec...

Definition: THeapBuffer.hpp:132

Here is the call graph for this function:

◆ HeapBuffer() [4/6]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::HeapBuffer	(	const T *	data,
		Size	size
	)

inline

Definition at line 94 of file THeapBuffer.hpp.

94{ set(data, size); }

tklb::HeapBuffer::data

T * data()

Definition: THeapBuffer.hpp:193

Here is the call graph for this function:

◆ HeapBuffer() [5/6]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::HeapBuffer ( HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE > && source )

inline

Move contructor, will mark the original buffer as injected.

Definition at line 99 of file THeapBuffer.hpp.

                                        :
            mBuf(source.mBuf),
            mSize(source.mSize),
            mRealSize(source.mRealSize)
        {
            TKLB_ASSERT_STATE(IS_CONST = source.IS_CONST)
            source.disown();
        }

◆ HeapBuffer() [6/6]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::HeapBuffer ( const HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE > * )

delete

◆ ~HeapBuffer()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::~HeapBuffer ( )

inline

Definition at line 120 of file THeapBuffer.hpp.

                      {
            if (injected()) { return; }
            resize(0);
        }

Here is the call graph for this function:

Member Function Documentation

◆ allocate()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::allocate ( Size chunk )

inlineprivatenoexcept

Allocated the exact size requsted and copies existing objects.

Will not call their destructors or constructors!

Definition at line 401 of file THeapBuffer.hpp.

                                           {
            T* oldBuf = mBuf;
            if (0 < chunk) {
                const Size bytes = chunk * sizeof(T);
                // TODO tklb Consider using realloc
                void* newBuf = mAllocator.allocate(bytes + Alignment);
                if (newBuf == nullptr) {
                    TKLB_ASSERT(false);
                    return false;
                }
 
                if (Alignment != 0) {
                    // Mask with zeroes at the end to floor the pointer to an aligned block
                    // for these casts to work, the type needs to be as wide as void*
                    const size_t _align = Alignment;
                    const size_t mask = ~(size_t(Alignment - 1));
                    const size_t pointer = reinterpret_cast<size_t>(newBuf);
                    const size_t floored = pointer & mask;
                    const size_t aligned = floored + Alignment;
 
                    // Not enough space before aligned memory to store original ptr
                    // This only happens when malloc doesn't align to sizeof(size_t)
                    TKLB_ASSERT(sizeof(size_t) <= (aligned - pointer))
 
                    newBuf = reinterpret_cast<void*>(aligned);
                    size_t* original = reinterpret_cast<size_t*>(newBuf) - 1;
                    *(original) = pointer;
                    TKLB_ASSERT(isAligned(newBuf))
                }
 
 
                if (0 < mSize && oldBuf != nullptr && newBuf != nullptr) {
                    // copy existing content
                    // TODO tklb only copy the new realsize which might be smaller
                    memcpy(newBuf, oldBuf, std::min(mSize, chunk) * sizeof(T));
                }
                mBuf = (T*) newBuf;
            } else {
                mBuf = nullptr;
            }
 
            if (oldBuf != nullptr && !injected() && mRealSize > 0) {
                // Get rif of oldbuffer, object destructors were already called
                if (Alignment == 0) {
                    mAllocator.deallocate(reinterpret_cast<unsigned char*>(oldBuf), mRealSize);
                } else {
                    auto original = *(reinterpret_cast<void**>(oldBuf) - 1);
                    mAllocator.deallocate(reinterpret_cast<unsigned char*>(original), mRealSize);
                }
            }
            TKLB_ASSERT_STATE(IS_CONST = false)
            mRealSize = chunk;
            // TKLB_CHECK_HEAP()
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ allocated()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

Size tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::allocated ( ) const

inline

Returns the size of the allocated space.

Definition at line 384 of file THeapBuffer.hpp.

384{ return mRealSize * sizeof(T); }

◆ begin() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T * tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::begin ( )

inline

Definition at line 220 of file THeapBuffer.hpp.

220{ return mBuf; }

◆ begin() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

const T * tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::begin ( ) const

inline

Definition at line 217 of file THeapBuffer.hpp.

217{ return mBuf; }

◆ clear()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

void tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::clear ( )

inline

Clears the buffer but doesn't free the memory.

Definition at line 364 of file THeapBuffer.hpp.

364{ resize(0, false); }

Here is the call graph for this function:

◆ closestChunkSize()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

static Size tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::closestChunkSize	(	Size	size,
		Size	chunk
	)

inlinestatic

Definition at line 386 of file THeapBuffer.hpp.

                                                            {
            const double chunkMin = std::max(double(chunk), 1.0);
            return chunk * Size(std::ceil(size / double(chunkMin)));
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ data() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T * tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::data ( )

inline

Definition at line 193 of file THeapBuffer.hpp.

                  {
            // Don't use non const access when using injected const memory
            TKLB_ASSERT(!IS_CONST)
            return mBuf;
        }

Here is the caller graph for this function:

◆ data() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

const T * tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::data ( ) const

inline

Definition at line 199 of file THeapBuffer.hpp.

199{ return mBuf; }

◆ destroyPointers()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::destroyPointers ( )

inline

If T is a pointer type, delete will be called for all pointers in buffer and resize(0) is called.

Definition at line 349 of file THeapBuffer.hpp.

                               {
            if (!std::is_pointer<T>::value) {
                TKLB_ASSERT(false)
                return false;
            }
            for (Size i = 0; i < mSize; i++) {
                delete mBuf[i];
            }
            resize(0);
            return true;
        }

Here is the call graph for this function:

◆ disown()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

void tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::disown ( )

inline

The memory is no longer manager by this instance.

Leak prone.

Definition at line 185 of file THeapBuffer.hpp.

                      {
            if (empty()) { return; }
            TKLB_ASSERT(mRealSize != 0)
            mRealSize = 0;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ empty()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::empty ( ) const

inline

Definition at line 191 of file THeapBuffer.hpp.

191{ return mSize == 0; }

Here is the caller graph for this function:

◆ end() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T * tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::end ( )

inline

Definition at line 221 of file THeapBuffer.hpp.

221{ return mBuf + mSize; }

◆ end() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

const T * tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::end ( ) const

inline

Definition at line 218 of file THeapBuffer.hpp.

218{ return mBuf + mSize; }

◆ first()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T & tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::first ( )

inline

Definition at line 228 of file THeapBuffer.hpp.

                   {
            TKLB_ASSERT(0 < mSize)
            return mBuf[0];
        }

◆ inject() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

void tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::inject	(	const T *	mem,
		const Size	size,
		const Size	realSize = `0`
	)

inline

Provide const foreign memory to use Using non const accessors will cause assertions in debug mode.

Parameters

mem	Non modifyable memory to use
size	Size of the memory in elements
realSize	The actual size if it's chunk allocated

Definition at line 176 of file THeapBuffer.hpp.

                                                                            {
            inject(const_cast<T*>(mem), size, realSize);
            TKLB_ASSERT_STATE(IS_CONST = true)
        }

Here is the call graph for this function:

◆ inject() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

void tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::inject	(	T *	mem,
		const Size	size,
		const Size	realSize = `0`
	)

inline

Provide foreign memory to borrow.

Parameters

mem	Modifyable memory to use
size	Size of the memory in elements
realSize	The actual size if it's chunk allocated

Definition at line 161 of file THeapBuffer.hpp.

                                                                      {
            if (!injected() && mBuf != nullptr) { resize(0); };
            TKLB_ASSERT_STATE(IS_CONST = false)
            disown();
            mBuf = mem;
            mSize = size;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ injected()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::injected ( ) const

inline

Whether the memory is managed by the instance or is borrowed.

Definition at line 369 of file THeapBuffer.hpp.

369{ return mRealSize == 0 && 0 < mSize && mBuf != nullptr; }

Here is the caller graph for this function:

◆ isAligned()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

static bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::isAligned ( const void * ptr )

inlinestatic

Definition at line 391 of file THeapBuffer.hpp.

                                               {
            if (Alignment == 0) { return true; }
            return size_t(ptr) % Alignment == 0;
        }

Here is the caller graph for this function:

◆ last()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T & tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::last ( )

inline

Definition at line 223 of file THeapBuffer.hpp.

                  {
            TKLB_ASSERT(0 < mSize)
            return mBuf[mSize - 1];
        }

◆ operator=() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

HeapBuffer & tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::operator= ( const HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE > & )

delete

◆ operator=() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

HeapBuffer & tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::operator= ( HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE > && source )

inline

Definition at line 108 of file THeapBuffer.hpp.

                                                    {
            TKLB_ASSERT_STATE(IS_CONST = source.IS_CONST)
            mBuf = source.mBuf;
            mSize = source.mSize;
            mRealSize = source.mRealSize;
            source.disown();
            return *this;
        }

◆ operator[]() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T & tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::operator[] ( const Size index )

inline

Definition at line 208 of file THeapBuffer.hpp.

                                               {
            #ifdef TKLB_MEM_TRACE
                TKLB_ASSERT(index < mSize)
            #endif
            // Don't use non const access when using injected const memory
            TKLB_ASSERT(!IS_CONST)
            return mBuf[index];
        }

◆ operator[]() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

const T & tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::operator[] ( const Size index ) const

inline

Definition at line 201 of file THeapBuffer.hpp.

                                                           {
            #ifdef TKLB_MEM_TRACE
                TKLB_ASSERT(index < mSize)
            #endif
            return mBuf[index];
        }

◆ pop()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::pop ( T * object )

inline

Get the last element in the buffer.

Will never shrink the buffer/allocate

Definition at line 300 of file THeapBuffer.hpp.

                            {
            if (0 == mSize) { return false; }
            new (object) T(*(mBuf + mSize - 1));
            mSize--;
            return true;
        }

◆ push()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::push ( const T & object )

inline

Push the object to the back of the buffer TODO tklb move version.

Definition at line 280 of file THeapBuffer.hpp.

                                   {
            Size newSize = mSize + 1;
            if (mRealSize < newSize) {
                if (allocate(closestChunkSize(newSize, ChunkSize))) {
                    new (mBuf + mSize) T(object);
                } else {
                    TKLB_ASSERT(false)
                    return false; // ! Allocation failed
                }
            } else {
                new (mBuf + mSize) T(object);
            }
            mSize = newSize;
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove() [1/3]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::remove ( const Size index )

inline

Removes the object at a given index and fills the gap with another Will never shrink the buffer/allocate.

Definition at line 311 of file THeapBuffer.hpp.

                                      {
            if (mSize <= index) { return false; }
            mBuf[index].~T(); // Call destructor
            if (index != mSize - 1) { // fill the gap with the last element
                memcpy(mBuf + index, mBuf + (mSize - 1), sizeof(T));
            }
            mSize--;
            return true;
        }

Here is the caller graph for this function:

◆ remove() [2/3]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::remove ( const T & object )

inline

If a == comparisin is possible the object itself can be used.

Definition at line 324 of file THeapBuffer.hpp.

                                     {
            for (Size i = 0; i < mSize; i++) {
                if (mBuf[i] == object) {
                    return remove(i);
                }
            }
            return false;
        }

Here is the call graph for this function:

◆ remove() [3/3]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::remove ( const T * object )

inline

Otherwise use memory location.

Definition at line 336 of file THeapBuffer.hpp.

                                     {
            for (Size i = 0; i < mSize; i++) {
                if ((mBuf + i) == object) {
                    return remove(i);
                }
            }
            return false;
        }

Here is the call graph for this function:

◆ reserve()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::reserve ( const Size size )

inline

Will make sure the desired space is allocated.

Returns: Whether the allocation was succesful

Definition at line 237 of file THeapBuffer.hpp.

                                      {
            if (size  < mRealSize) { return true; }
            return allocate(size);
        }

Here is the call graph for this function:

◆ reserved()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

Size tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::reserved ( ) const

inline

Returns the real allocated size in elements.

Definition at line 379 of file THeapBuffer.hpp.

379{ return mRealSize; }

◆ resize()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::resize	(	const Size	size,
		const bool	downsize = `true`
	)

inline

Resize the buffer If the memory is borrowed it will become unique and owned by this instance as soon as an allocation happens.

Parameters

size	The new size
downsize	Whether to downsize and reallocate

Returns: Whether the allocation was successful

Definition at line 250 of file THeapBuffer.hpp.

                                                                 {
            const Size chunked = closestChunkSize(size, ChunkSize);
 
            if (size < mSize && mBuf != nullptr && !injected()) { // downsize means destroy objects
                for (Size i = size; i < mSize; i++) {
                    mBuf[i].~T(); // Call destructor
                }
            }
 
            if (mRealSize < chunked || (downsize && (mRealSize > chunked)) ) {
                // Upsize or downsize + downsize requested
                if (!allocate(chunked)) {
                    return false; // ! Allocation failed
                }
            }
 
            if (mSize < size) { // upsize means construct objects
                for (Size i = mSize; i < size; i++) {
                    T* test = new (mBuf + i) T();
                }
            }
 
            mSize = size;
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set() [1/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

template<int Alignment2, class Allocator2 , typename Size2 >

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::set ( const HeapBuffer< T, Alignment2, Allocator2, Size2 > & source )

inline

Resizes and copies the contents of the source Buffer This will do a memory::copy,so none of the object contructors will called.

Returns: True on success

Definition at line 132 of file THeapBuffer.hpp.

                                                                             {
            return set(source.data(), source.size());
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ set() [2/2]

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

bool tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::set	(	const T *	data,
		Size	size
	)

inline

Set data from array.

Parameters

data	data array to copy
size	size in elements of the data array

Returns: True on success

Definition at line 142 of file THeapBuffer.hpp.

                                           {
            if (mBuf != nullptr) {
                resize(0); // Clear first so no old data gets copied on resize
            }
            if (!resize(size)) {
                return false; // ! Allocation failed
            }
            for (Size i = 0; i < mSize; i++) {
                new (mBuf + i) T(*(data + i));
            }
            return true;
        }

Here is the call graph for this function:

◆ size()

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

Size tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::size ( ) const

inline

Returns the amount of elements in the container.

Definition at line 374 of file THeapBuffer.hpp.

374{ return mSize; }

Here is the caller graph for this function:

Member Data Documentation

◆ Alignment

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

constexpr size_t tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::Alignment = ALIGNMENT

staticconstexpr

Definition at line 57 of file THeapBuffer.hpp.

◆ ChunkSize

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

constexpr size_t tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::ChunkSize = 16

staticconstexpr

Definition at line 59 of file THeapBuffer.hpp.

◆ mAllocator

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

ALLOCATOR tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::mAllocator

private

Definition at line 62 of file THeapBuffer.hpp.

◆ mBuf

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

T* tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::mBuf = nullptr

private

Definition at line 63 of file THeapBuffer.hpp.

◆ mRealSize

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

Size tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::mRealSize = 0

private

the actually allocated size if it's 0 the memory is not actually owned by the buffer and won't be delete with the object.

No safety mechanism if memory becomes invalid

Definition at line 72 of file THeapBuffer.hpp.

◆ mSize

template<typename T , size_t ALIGNMENT = 0, class ALLOCATOR = StdAllocator <unsigned char>, typename SIZE = unsigned int>

Size tklb::HeapBuffer< T, ALIGNMENT, ALLOCATOR, SIZE >::mSize = 0

private

Definition at line 64 of file THeapBuffer.hpp.

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

THeapBuffer.hpp

Public Types

Public Member Functions

Static Public Member Functions

Static Public Attributes

Private Member Functions

Private Attributes

Detailed Description

Member Typedef Documentation

◆ Size

Constructor & Destructor Documentation

◆ HeapBuffer() [1/6]

◆ HeapBuffer() [2/6]

◆ HeapBuffer() [3/6]

◆ HeapBuffer() [4/6]

◆ HeapBuffer() [5/6]

◆ HeapBuffer() [6/6]

◆ ~HeapBuffer()

Member Function Documentation

◆ allocate()

◆ allocated()

◆ begin() [1/2]

◆ begin() [2/2]

◆ clear()

◆ closestChunkSize()

◆ data() [1/2]

◆ data() [2/2]

◆ destroyPointers()

◆ disown()

◆ empty()

◆ end() [1/2]

◆ end() [2/2]

◆ first()

◆ inject() [1/2]

◆ inject() [2/2]

◆ injected()

◆ isAligned()

◆ last()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ operator[]() [1/2]

◆ operator[]() [2/2]

◆ pop()

◆ push()

◆ remove() [1/3]

◆ remove() [2/3]

◆ remove() [3/3]

◆ reserve()

◆ reserved()

◆ resize()

◆ set() [1/2]

◆ set() [2/2]

◆ size()

Member Data Documentation

◆ Alignment

◆ ChunkSize

◆ mAllocator

◆ mBuf

◆ mRealSize

◆ mSize