SC::ArenaMap< T > Struct Template Reference

A sparse vector keeping objects at a stable memory location. More...

#include <ArenaMap.h>

Classes
struct	ArenaMapIterator

Public Types
using	Key = ArenaMapKey<T>
using	Gen = typename Key::Generation
using	ConstIterator = ArenaMapIterator<const ArenaMap>
using	Iterator = ArenaMapIterator<ArenaMap>

Public Member Functions
	ArenaMap (Globals::Type globalsType=Globals::Global)
	ArenaMap (const ArenaMap &other)
	ArenaMap (ArenaMap &&other)
ArenaMap &	operator= (const ArenaMap &other)
ArenaMap &	operator= (ArenaMap &&other)
uint32_t	getNumAllocated () const
	Get the maximum number of objects that can be stored in this map.
ConstIterator	cbegin () const
ConstIterator	cend () const
ConstIterator	begin () const
ConstIterator	end () const
Iterator	begin ()
Iterator	end ()
void	clear ()
size_t	size () const
	Get the number of used slots in the arena.
size_t	capacity () const
	Get the total number slots in the arena.
bool	isFull () const
	Returns true if size() == capacity(), that means the arena is full.
bool	resize (size_t newSize)
	Changes the size of the arena.
template<typename Value >
Key	insert (const Value &object)
Key	allocate ()
template<typename Value >
Key	insert (Value &&object)
bool	containsKey (Key key) const
template<typename ComparableToValue >
bool	containsValue (const ComparableToValue &value, Key *optionalKey=nullptr) const
bool	remove (Key key)
T *	get (Key key)
const T *	get (Key key) const

Detailed Description

template<typename T>
struct SC::ArenaMap< T >

A sparse vector keeping objects at a stable memory location.

Template Parameters

T	Type of items kept in this Arena

SC::ArenaMap is a container used to keep objects memory location stable.
Internally it hold sparse objects inside of a SC::Vector and for this reason it can only be SC::ArenaMap::resize-d when it's empty.
Objects can be inserted up to the SC::ArenaMap::size and insertion returns handle keys allowing to retrieve the inserted object in constant time.

    ArenaMap<String> map;
    SC_TRY(not map.insert("ASD").isValid());
    SC_TRY(map.resize(3));
    ArenaMap<String>::Key keys[3];
    keys[0] = map.insert("ASD");
    SC_TRY(map.size() == 1);
    SC_TRY(not map.resize(4)); // cannot resize unless is empty
    keys[1] = map.insert("DSA");
    keys[2] = map.insert("BDA");
    SC_TRY(map.size() == 3);
    SC_TRY(not map.insert("123").isValid()); // Arena is full
 
    SC_TRY(map.get(keys[0])->view() == "ASD"); // Get first element
    SC_TRY(map.get(keys[1])->view() == "DSA"); // Get second element
    SC_TRY(map.get(keys[2])->view() == "BDA"); // Get third element

Member Function Documentation

capacity()

template<typename T >

size_t SC::ArenaMap< T >::capacity ( ) const

inlinenodiscard

Get the total number slots in the arena.

getNumAllocated()

template<typename T >

uint32_t SC::ArenaMap< T >::getNumAllocated ( ) const

inline

Get the maximum number of objects that can be stored in this map.

isFull()

template<typename T >

bool SC::ArenaMap< T >::isFull ( ) const

inlinenodiscard

Returns true if size() == capacity(), that means the arena is full.

resize()

template<typename T >

bool SC::ArenaMap< T >::resize ( size_t newSize )

inlinenodiscard

Changes the size of the arena.

Note

Can only be called on empty arena (SC::ArenaMap::size == 0)

Parameters

newSize

The new wanted number of elements to be stored in the arena

Returns

true if resize succeeded

size()

template<typename T >

size_t SC::ArenaMap< T >::size ( ) const

inlinenodiscard

Get the number of used slots in the arena.

---

The documentation for this struct was generated from the following files:

• ArenaMap.h
• ArenaMapKey.h