TODO broken don't use. More...

#include <THandleBuffer.hpp>

Inheritance diagram for tklb::HandleBuffer< T, Handle, MaskSplit >:

Collaboration diagram for tklb::HandleBuffer< T, Handle, MaskSplit >:

Public Member Functions
	HandleBuffer (Handle T::*member)
	Construct a new Handle Buffer object. More...

template<class Func >
void	forEach (const Func &&func)

T *	at (const Handle &handle)

Handle	create ()

Handle	push (const T &object)
	add element, may trigger resize More...

bool	pop (const Handle &handle, T *destination=nullptr)

bool	remove (const Size index)

bool	remove (const T &object)

Public Member Functions inherited from tklb::HeapBuffer< T, true >
	HeapBuffer ()=default

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

	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 (const HeapBuffer *)=delete

HeapBuffer &	operator= (HeapBuffer &&source)

HeapBuffer &	operator= (const HeapBuffer &)=delete

	~HeapBuffer ()

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

T *	begin ()

const T *	end () const

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 Attributes
static constexpr Handle	InvalidHandle = ~0
	Since 0 is a valid handle, this is used to indicate a invalid one. More...

Static Public Attributes inherited from tklb::HeapBuffer< T, true >
static constexpr size_t	Alignment

static constexpr size_t	ChunkSize

Private Types
using	Base = HeapBuffer< T, true >

using	Size = typename Base::Size

Private Attributes
Size	mLastFree = 0

Size	mOffset
	Offset to the member variable which is used to identify an object. More...

Static Private Attributes
static constexpr Handle	MaskId = (1 << (MaskSplit)) - 1

static constexpr Handle	MaskIndex = ~MaskId

Additional Inherited Members
Public Types inherited from tklb::HeapBuffer< T, true >
using	Size = unsigned int
	everything using the heapbuffer uses this type Always needs to be unsigned! More...

Static Public Member Functions inherited from tklb::HeapBuffer< T, true >
static Size	closestChunkSize (Size size, Size chunk)

static bool	isAligned (const void *ptr)

Detailed Description

template<class T, typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>
class tklb::HandleBuffer< T, Handle, MaskSplit >

TODO broken don't use.

A buffer to access contents via a Handle with validity checks

Type stored in here needs to store it's own id in a Handle member.

Template Parameters

T	type to store
Handle	type to index elements
MaskSplit	At what bit to split the Handle for validation

Definition at line 15 of file THandleBuffer.hpp.

Member Typedef Documentation

◆ Base

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

using tklb::HandleBuffer< T, Handle, MaskSplit >::Base = HeapBuffer<T, true>

private

Definition at line 17 of file THandleBuffer.hpp.

◆ Size

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

using tklb::HandleBuffer< T, Handle, MaskSplit >::Size = typename Base::Size

private

Definition at line 18 of file THandleBuffer.hpp.

Constructor & Destructor Documentation

◆ HandleBuffer()

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

tklb::HandleBuffer< T, Handle, MaskSplit >::HandleBuffer ( Handle T::* member )

inline

Construct a new Handle Buffer object.

Parameters

member Pointer to the member variable used for validation

Definition at line 41 of file THandleBuffer.hpp.

                                      {
            // nice
            mOffset = Size(((char*) &(((T*)nullptr)->*member)) - ((char*)nullptr));
        }

Member Function Documentation

◆ at()

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

T * tklb::HandleBuffer< T, Handle, MaskSplit >::at ( const Handle & handle )

inline

Definition at line 53 of file THandleBuffer.hpp.

                                    {
            const Handle index = (handle & MaskIndex) >> MaskSplit;
            if (index == mLastFree) { return nullptr; } // element deleted
            if (Base::size() <= index) { return nullptr; }  // out of range
            T* element = Base::data() + index;
            const Handle refernceId = handle & MaskId;
            const Handle id = (*((Handle*)(((char*) element) + mOffset))) & MaskId;
            if (id != refernceId) { return nullptr; }   // Id mismatch, so object was replaced
            return element;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ create()

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

Handle tklb::HandleBuffer< T, Handle, MaskSplit >::create ( )

inline

Definition at line 64 of file THandleBuffer.hpp.

                        {
            Size index = 0;
            const Size s = Base::size();
            if (s <= mLastFree || mLastFree < 0) {
                index = s;
                Base::resize(s + 1);
            }
            Size zero = 0; // should underflow
            mLastFree = zero - 1; // make sure free slot is not in size any more
            Handle ret = index << MaskSplit;
            Handle id = (*((Handle*)(((char*) (Base::data() + index)) + mOffset))) & MaskId;
            ret = ret | id;
            return ret;
        }

Here is the call graph for this function:

◆ forEach()

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

template<class Func >

void tklb::HandleBuffer< T, Handle, MaskSplit >::forEach ( const Func && func )

inline

Definition at line 47 of file THandleBuffer.hpp.

                                        {
            for (Size i = 0; i < Base::size(); i++) {
                // if (*(Base::data() + i))
            }
        }

Here is the call graph for this function:

◆ pop()

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

bool tklb::HandleBuffer< T, Handle, MaskSplit >::pop	(	const Handle &	handle,
		T *	destination = `nullptr`
	)

inline

Definition at line 103 of file THandleBuffer.hpp.

                                                                 {
            T* element = at(handle);
            if (element == nullptr) { return false; }
            if (destination != nullptr) {
                memory::copy(destination, element, sizeof(T));
            }
            return remove(*element);
        }

Here is the call graph for this function:

◆ push()

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

Handle tklb::HandleBuffer< T, Handle, MaskSplit >::push ( const T & object )

inline

add element, may trigger resize

Definition at line 82 of file THandleBuffer.hpp.

                                     {
            Handle ret = 0;
            if (Base::size() <= mLastFree || mLastFree < 0) {
                // no free slot
                ret = Base::size();
                if (!Base::push(object)) {
                    return InvalidHandle; // something went wrong
                }
            } else {
                // use free slot
                ret = mLastFree;
                new (Base::data() + mLastFree) T(object);
            }
            ret = ret << MaskSplit;
            Handle id = (*((Handle*)(((char*) &object) + mOffset))) & MaskId;
            ret = ret | id;
            Size zero = 0; // should underflow
            mLastFree = zero - 1; // make sure free slot is not in size any more
            return ret;
        }

Here is the call graph for this function:

◆ remove() [1/2]

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

bool tklb::HandleBuffer< T, Handle, MaskSplit >::remove ( const Size index )

inline

Definition at line 112 of file THandleBuffer.hpp.

                                      {
            if (Base::size() <= index) { return false; }
            if (index == mLastFree) { return false; }
            Base::data()[index].~T();
            mLastFree = index;
            return true;
        }

Here is the call graph for this function:

Here is the caller graph for this function:

◆ remove() [2/2]

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

bool tklb::HandleBuffer< T, Handle, MaskSplit >::remove ( const T & object )

inline

Definition at line 120 of file THandleBuffer.hpp.

                                     {
            T* arr = Base::data();
            for (Size i = 0; i < Base::size(); i++) {
                if ((arr + i) == &object) {
                    return remove(i);
                }
            }
            return false;
        }

Here is the call graph for this function:

Member Data Documentation

◆ InvalidHandle

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

constexpr Handle tklb::HandleBuffer< T, Handle, MaskSplit >::InvalidHandle = ~0

staticconstexpr

Since 0 is a valid handle, this is used to indicate a invalid one.

Definition at line 35 of file THandleBuffer.hpp.

◆ MaskId

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

constexpr Handle tklb::HandleBuffer< T, Handle, MaskSplit >::MaskId = (1 << (MaskSplit)) - 1

staticconstexprprivate

Definition at line 20 of file THandleBuffer.hpp.

◆ MaskIndex

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

constexpr Handle tklb::HandleBuffer< T, Handle, MaskSplit >::MaskIndex = ~MaskId

staticconstexprprivate

Definition at line 21 of file THandleBuffer.hpp.

◆ mLastFree

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

Size tklb::HandleBuffer< T, Handle, MaskSplit >::mLastFree = 0

private

Definition at line 23 of file THandleBuffer.hpp.

◆ mOffset

template<class T , typename Handle = unsigned int, int MaskSplit = sizeof(Handle) * 4>

Size tklb::HandleBuffer< T, Handle, MaskSplit >::mOffset

private

Offset to the member variable which is used to identify an object.

in bytes Should get optimized away since it depends on template arguments.

Definition at line 28 of file THandleBuffer.hpp.

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

THandleBuffer.hpp

Public Member Functions

Static Public Attributes

Private Types

Private Attributes

Static Private Attributes

Additional Inherited Members

Detailed Description

Member Typedef Documentation

◆ Base

◆ Size

Constructor & Destructor Documentation

◆ HandleBuffer()

Member Function Documentation

◆ at()

◆ create()

◆ forEach()

◆ pop()

◆ push()

◆ remove() [1/2]

◆ remove() [2/2]

Member Data Documentation

◆ InvalidHandle

◆ MaskId

◆ MaskIndex

◆ mLastFree

◆ mOffset