A thread-safe hash map which stores indexed shared items. More...

#include <UT_IndexedHashMap.h>

Inheritance diagram for UT_IndexedHashMap:

Classes
class	IdRemapping

class	itemCompare

class	itemContainer

class	keyCompare

class	keyContainer

class	listContainer

class	unsafe_iterator
	Iterate over items in the map - this is arbitrary order. More...

class	unsafe_listiterator

Public Types
typedef void	InternalKeyT

typedef void	InternalItemT

Public Member Functions
	UT_IndexedHashMap (bool store_ids)

virtual	~UT_IndexedHashMap ()

void	clear ()

exint	entries () const

bool	empty () const
	Return whether the map is empty. More...

int64	getMemoryUsage (bool inclusive) const
	Return approximate memory usage (not including key or item storage) More...

UT_IndexedHashMapItemId	getItemIdUpperBound () const

fpreal	getOccupancy () const

bool	compactIds (IdRemapping &remapping)

bool	sortItems ()

exint	getReferenceCount (UT_IndexedHashMapItemId id) const

unsafe_iterator	begin () const

unsafe_iterator	end () const

unsafe_listiterator	beginList () const

unsafe_listiterator	endList () const

Protected Types
typedef UT_ConcurrentHashMap < keyContainer, itemContainer *, keyCompare >	UT_IndexedHashMapTable

typedef UT_ConcurrentVector < listContainer >	UT_IndexedHashMapVector

typedef UT_ConcurrentQueue < UT_IndexedHashMapItemId >	UT_IndexedHashMapHoleQueue

Protected Member Functions
virtual uint	hash (const InternalKeyT *key) const =0

virtual bool	areKeysEqual (const InternalKeyT k1, const InternalKeyT k2) const =0

virtual InternalKeyT *	copyKey (const InternalKeyT *key) const =0

virtual void	deleteKey (InternalKeyT *key) const =0

virtual InternalItemT *	newItem (const InternalKeyT *key) const =0

virtual void	deleteItem (InternalItemT *item) const =0

virtual bool	isItemLessThan (const InternalItemT a, const InternalItemT b) const =0


void	_replace (const UT_IndexedHashMap &src)

InternalItemT *	_add (const InternalKeyT key, InternalItemT item=NULL, UT_IndexedHashMapItemId *id=NULL)

InternalItemT *	_addReference (UT_IndexedHashMapItemId id, int inc)

InternalItemT *	_addReference (UT_IndexedHashMapItemId id)

InternalItemT *	_find (const InternalKeyT *key) const

exint	_findId (const InternalKeyT *key) const

InternalItemT *	_findItemAndId (const InternalKeyT *key, UT_IndexedHashMapItemId &id) const

InternalItemT *	_get (UT_IndexedHashMapItemId id) const

const InternalKeyT *	_getKey (UT_IndexedHashMapItemId id) const

InternalItemT *	_getOrderedItem (exint index, UT_IndexedHashMapItemId *id) const

bool	_remove (const InternalKeyT *key)

bool	_remove (UT_IndexedHashMapItemId id)

UT_IndexedHashMapItemId	_replaceItem (UT_IndexedHashMapItemId id, const InternalKeyT key, InternalItemT new_item=NULL)

exint	_extractItems (UT_Array< UT_IndexedHashMapItemId > &ids, UT_Array< InternalItemT * > &items, exint maxitems) const

exint	_extractItems (UT_Array< UT_IndexedHashMapItemId > &ids, UT_Array< InternalItemT * > &items) const

exint	_extractItems (UT_Array< InternalItemT * > &items) const

Friends
class	itemContainer

class	keyContainer

class	itemCompare

Detailed Description

A thread-safe hash map which stores indexed shared items.

Each item in the hash map is reference counted. That is, if objects are added multiple times, only a single object will be stored in the map.

Removing an item from the hash map (by id or key) will decrement the reference count on the item. When no longer referenced, the map will delete the item.

When the map stores 'ids', each item is assigned a unique id (UT_IndexedHashMapItemId). The item can then be retrieved efficiently from the map using the id (UT_IndexedHashMap::get())

Many methods on the map are thread-safe. Some methods are not (and are noted in the comments).

The KEY template parameter needs to have:

KEY(const KEY &src);                        // The copy constructor
uint        hash() const;                   // A hash method
bool        isEqual(const KEY &src) const;  // A comparison operator

Definition at line 47 of file UT_IndexedHashMap.h.

Member Typedef Documentation

typedef void UT_IndexedHashMap::InternalItemT

Definition at line 51 of file UT_IndexedHashMap.h.

typedef void UT_IndexedHashMap::InternalKeyT

Definition at line 50 of file UT_IndexedHashMap.h.

typedef UT_ConcurrentQueue<UT_IndexedHashMapItemId> UT_IndexedHashMap::UT_IndexedHashMapHoleQueue

protected

Definition at line 384 of file UT_IndexedHashMap.h.

typedef UT_ConcurrentHashMap<keyContainer, itemContainer *, keyCompare> UT_IndexedHashMap::UT_IndexedHashMapTable

protected

Definition at line 381 of file UT_IndexedHashMap.h.

typedef UT_ConcurrentVector<listContainer> UT_IndexedHashMap::UT_IndexedHashMapVector

protected

Definition at line 382 of file UT_IndexedHashMap.h.

Constructor & Destructor Documentation

UT_IndexedHashMap::UT_IndexedHashMap ( bool store_ids )

If store_ids is true, each item stored in the map will be given a unique id of type UT_IndexedHashMapItemId. These id's can be used to perform efficient lookup of items in the map.

If the store_ids parameter is false, then elements in the shared map will not store id's. The ids for the elements will always be -1 (invalid). The map won't store the structures required for indexed lookup, saving some memory and allowing some operations to be slightly more efficient. Operations which are invalid for maps that don't store id's are noted in the comments).

virtual UT_IndexedHashMap::~UT_IndexedHashMap ( )

virtual