Nebula
|
#include <idallocator.h>
An ID allocator associates an id with a slice in an N number of arrays.
There are two versions of this type, an unsafe and a safe one. Both are implemented in the same way, providing a variadic list of types which is to be contained in the allocator and fetching each value by providing the index into the list of types, which means the members are nameless.
The thread safe allocator requires the Get-methods to be within an Enter/Leave lockstep phase.
Inherits Util::ArrayAllocator< TYPES... >.
Public Member Functions | |
IdAllocator (Ids::Id32 maxid=0xFFFFFFFF) | |
constructor | |
Ids::Id32 | Alloc () |
Allocate an object. | |
void | Dealloc (Ids::Id32 index) |
Deallocate an object. Just places it in freeids array for recycling. | |
Util::Array< Ids::Id32 > & | FreeIds () |
Returns the list of free ids. | |
const Ids::Id32 | Size () const |
return number of allocated ids | |
Public Member Functions inherited from Util::ArrayAllocator< TYPES... > | |
ArrayAllocator () | |
constructor | |
ArrayAllocator (ArrayAllocator< TYPES... > &&rhs) | |
move constructor | |
ArrayAllocator (const ArrayAllocator< TYPES... > &rhs) | |
copy constructor | |
~ArrayAllocator () | |
destructor | |
void | operator= (const ArrayAllocator< TYPES... > &rhs) |
assign operator | |
void | operator= (ArrayAllocator< TYPES... > &&rhs) |
move operator | |
uint32_t | Alloc () |
allocate a new resource | |
void | EraseIndex (const uint32_t id) |
Erase element for each. | |
void | EraseIndexSwap (const uint32_t id) |
Erase element for each. | |
void | EraseRange (const uint32_t start, const uint32_t end) |
erase range | |
tuple_array_t< MEMBER, TYPES... > & | Get (const uint32_t index) |
get single item from resource | |
const tuple_array_t< MEMBER, TYPES... > & | ConstGet (const uint32_t index) const |
same as 32 bit get, but const | |
void | Set (const uint32_t index, const tuple_array_t< MEMBER, TYPES... > &type) |
set single item | |
void | Set (const uint32_t index, TYPES...) |
set for each in tuple | |
const Util::Array< tuple_array_t< MEMBER, TYPES... > > & | GetArray () const |
get array const reference | |
Util::Array< tuple_array_t< MEMBER, TYPES... > > & | GetArray () |
get array | |
const uint32_t | Size () const |
get number of used indices | |
void | Reserve (uint32_t size) |
grow capacity of arrays to size | |
void | SetSize (uint32_t size) |
set size of arrays to param size | |
void | Clear () |
clear entire allocator and start from scratch. | |
void | UpdateSize () |
Any reserve and direct array access might mess with the size. | |
Private Attributes | |
Ids::Id32 | maxId = 0xFFFFFFFF |
Util::Array< Ids::Id32 > | freeIds |
Additional Inherited Members | |
Protected Attributes inherited from Util::ArrayAllocator< TYPES... > | |
uint32_t | size |
std::tuple< Util::Array< TYPES >... > | objects |
|
inline |
constructor
|
inline |
Allocate an object.
|
inline |
Deallocate an object. Just places it in freeids array for recycling.
|
inline |
Returns the list of free ids.
|
inline |
return number of allocated ids
|
private |
|
private |