ListMemBuf< T_t, MAX, idx_t > Class Template Reference
#include <ListMemBuf.h>
Inheritance diagram for ListMemBuf< T_t, MAX, idx_t >:
Detailed Description
template<class T_t, unsigned int MAX, class idx_t = unsigned short>
class ListMemBuf< T_t, MAX, idx_t >
Provides some degree of dynamic allocation of a templated type from a buffer of set size.
Think of this as a self-contained mini-malloc...
This is handy for classes which inhabit a shared memory region, where it's a bad idea to have pointers to other memory. By instantiating one of these in your class, you can allocate space internally for up to MAX objects of type T_t. ListMemBuf will worry about keeping track of which ones are in use or are free.
Each time you request a entry to be created, the destructor will be called followed by the the defaul constructor before it is given to you, so the fields should be reliably 'fresh', not what was in the entry last time it was used.
Definition at line 20 of file ListMemBuf.h.
Public Types | |
| typedef T_t | T |
| Allows outside access to storage type. | |
| typedef idx_t | index_t |
| Allows outside access to index type. | |
Public Member Functions | |
| ListMemBuf () | |
| constructor | |
| ~ListMemBuf () | |
| destructor | |
| index_t | size () const |
| returns the current number of objects in use | |
| index_t | countf () const |
| for debugging, should equal size | |
| index_t | countb () const |
| for debugging, should equal size | |
| bool | empty () const |
| returns true if no objects are in use | |
| T & | operator[] (unsigned int x) |
| allows direct access to elements - be careful, can access 'free' elements this way | |
| const T & | operator[] (unsigned int x) const |
| allows direct access to elements - be careful, can access 'free' elements this way | |
| index_t | begin () const |
| returns index of first used entry | |
| T & | front () |
| returns reference to first used entry | |
| const T & | front () const |
| returns const reference to first used entry | |
| index_t | end () const |
| returns the one-past-end index | |
| T & | back () |
| returns reference to last used entry | |
| const T & | back () const |
| returns const reference to last used entry | |
| index_t | new_front () |
| pushes a 'blank' entry on the front of the used list | |
| index_t | push_front (const T &data) |
| pushes an entry on the front of the used chain and assigns data to it | |
| void | pop_front () |
| pops the front of the used chain | |
| void | pop_front (T &ret) |
| pops the front of the chain into ret | |
| index_t | new_back () |
| pushes a 'blank' entry on the back of the used list | |
| index_t | push_back (const T &data) |
| pushes an entry on the back of the used chain and assigns data to it | |
| void | pop_back () |
| pops the last of the used chain | |
| void | pop_back (T &ret) |
| pops the last of the used chain into ret | |
| index_t | new_before (index_t x) |
| inserts a 'blank' entry before element x in the used chain | |
| index_t | push_before (index_t x, const T &data) |
| inserts a 'blank' entry before element x in the used chain and assigns data to it | |
| index_t | new_after (index_t x) |
| inserts a 'blank' entry after element x in the used chain | |
| index_t | push_after (index_t x, const T &data) |
| inserts a 'blank' entry after element x in the used chain and assigns data to it | |
| void | erase (index_t x) |
| removes element x from the used chain | |
| void | clear () |
| frees all used entries | |
| void | swap (index_t a, index_t b) |
| swaps the two entries' position in the list | |
| index_t | next (index_t x) const |
| returns the next used element following x | |
| index_t | prev (index_t x) const |
| returns the preceeding used element following x | |
Static Public Member Functions | |
| static index_t | getMaxCapacity () |
| returns the maximum number of objects which can be used at any given time | |
Static Public Attributes | |
| static const unsigned int | MAX_ENTRIES = MAX |
| Allows outside access to number of entries. | |
Protected Member Functions | |
| index_t | pop_free () |
| removes an element from the front of the free list, returns its index | |
| void | push_free (index_t x) |
| pushes x onto the back of the free list | |
Protected Attributes | |
| entry_t | entries [MAX_ENTRIES] |
| the main block of data | |
| index_t | activeBegin |
| beginning of used chain | |
| index_t | activeBack |
| end of used chain | |
| index_t | freeBegin |
| beginning of free chain | |
| index_t | freeBack |
| end of free chain | |
| index_t | cursize |
| current number of used elements | |
Classes | |
| struct | entry_t |
| holds data about an entry in the free/used lists More... | |
Member Function Documentation
| index_t ListMemBuf< T, MAX, index_t >::pop_free | ( | ) | [protected] |
removes an element from the front of the free list, returns its index
free list is a queue... pop front, push back - hopefully more robust with multi-threads is purposely sloppy with unused links, a little faster
Definition at line 319 of file ListMemBuf.h.
Referenced by ListMemBuf< T_t, MAX, idx_t >::new_back(), ListMemBuf< T_t, MAX, idx_t >::new_before(), and ListMemBuf< T_t, MAX, idx_t >::new_front().
| void ListMemBuf< T, MAX, index_t >::push_free | ( | index_t | x | ) | [protected] |
pushes x onto the back of the free list
- See also:
- pop_free()
Definition at line 335 of file ListMemBuf.h.
Referenced by ListMemBuf< T_t, MAX, idx_t >::erase(), ListMemBuf< T_t, MAX, idx_t >::pop_back(), and ListMemBuf< T_t, MAX, idx_t >::pop_front().
The documentation for this class was generated from the following file:
