Template Class ListMap

Inheritance Relationships

Base Type

Class Documentation

template<typename HandleT, typename ValueT>
class ListMap : public lvr2::AttributeMap<HandleT, ValueT>

A simple implementation of AttributeMap for a small number of values.

This implementation uses a simple, unordered list of key-value pairs to represent the map. This means that nearly all operations have a complexity of O(number_of_values), which is rather suboptimal. Thus this implementation only makes sense when the number of values is expected to be very small. A modern computer can easily search linearly through, like, 16 things. When we’re dealing with a small number of things, often linear search will be faster than something fancy (like hashing or binary search).

However, this implementation doesn’t use its whole potential right now. The biggest speed gain is possible by using small buffer optimization (SBO). This still needs to be implemented, but should be fairly straight forward.

Public Functions

inline ListMap()

Creates an empty map without default element set.

ListMap(const ValueT &defaultValue)

Creates a map with a given default value.

Whenever you request a value for a key and there isn’t a value associated with that key, the default value is returned. Note that if you set a default value (which you do by calling this constructor), you can’t remove it. Neither erase() nor clear() will do it. Calls to get() will always return a non-none value and operator[] won’t ever panic.

One additional important detail: if you call get() to obtain a mutable reference, the default value is inserted into the map. This is the only sane way to return a mutably reference.

ListMap(size_t countElements, const ValueT &defaultValue)

Creates a map with a given default value and calls reserve.

This works exactly as the ListMap(const Value&) constructor, but also calls reserve(countElements) immediately afterwards.

virtual bool containsKey(HandleT key) const final

Returns true iff the map contains a value associated with the given key.

virtual boost::optional<ValueT> insert(HandleT key, const ValueT &value) final

Inserts the given value at the given key position.

Returns:

If there was a value associated with the given key before inserting the new value, the old value is returned. None otherwise.

virtual boost::optional<ValueT> erase(HandleT key) final

Removes the value associated with the given key.

Returns:

If there was a value associated with the key, it is returned. None otherwise.

virtual void clear() final

Removes all values from the map.

virtual boost::optional<ValueT&> get(HandleT key) final

Returns the value associated with the given key or None if there is no associated value.

Note: this method can not be used to insert a new value. It only allows reading and modifying an already inserted value.

virtual boost::optional<const ValueT&> get(HandleT key) const final

Returns the value associated with the given key or None if there is no associated value.

Note: this method can not be used to insert a new value. It only allows reading an already inserted value.

virtual size_t numValues() const final

Returns the number of values in this map.

virtual AttributeMapHandleIteratorPtr<HandleT> begin() const final

Returns an iterator over all keys of this map. The order of iteration is unspecified.

You can simply iterate over all keys of this map with a range-based for-loop:

for (auto handle: attributeMap) { ... }
virtual AttributeMapHandleIteratorPtr<HandleT> end() const final

Returns an iterator to the end of all keys.

void reserve(size_t newCap)

Allocates space for at least newCap more elements.