Overview

template<typename Key, typename T>
class pw::IntrusiveMap< Key, T >

A std::map<Key, T, Compare>-like class that uses intrusive items.

Since the map structure is stored in the items themselves, each item must outlive any map it is a part of and must be part of at most one map.

This map requires unique keys. Attempting to add an item with same key as an item already in the map will fail.

Since items are not allocated by this class, the following methods have no analogue:
- std::map<T>::operator=
- std::map<T>::operator[]
- std::map<T>::get_allocator
- std::map<T>::insert_or_assign
- std::map<T>::emplace
- std::map<T>::emplace_hint
- std::map<T>::try_emplace
Methods corresponding to the following take initializer lists of pointer to items rather than the items themselves:
- std::map<T>::(constructor)
- std::map<T>::insert
There are no overloads corresponding to the following methods that take r-value references.:
- std::map<T>::insert
- std::map<T>::merge
Since modifying the map modifies the items themselves, methods corresponding to those below only take iterators and not const_iterators:
- std::map<T>::insert
- std::map<T>::erase
An additional overload of erase is provided that takes a direct reference to an item.
C++23 methods are not (yet) supported.

Template Parameters

Key	Type to sort items on
T	Type of values stored in the map.

Classes
class	const_iterator

class	iterator

Public Types
using	Item = typename Tree::Item

using	Pair = typename Tree::Pair

using	key_type = Key

using	mapped_type = std::remove_cv_t< T >

using	value_type = Item

using	size_type = std::size_t

using	difference_type = std::ptrdiff_t

using	key_compare = Compare

using	reference = value_type &

using	const_reference = const value_type &

using	pointer = value_type *

using	const_pointer = const value_type *

using	reverse_iterator = std::reverse_iterator< iterator >

using	const_reverse_iterator = std::reverse_iterator< const_iterator >

Public Member Functions
constexpr	IntrusiveMap ()
	Constructs an empty map of items.

template<typename Comparator >
constexpr	IntrusiveMap (Comparator compare)

template<typename Comparator , typename KeyRetriever >
constexpr	IntrusiveMap (Comparator &&compare, KeyRetriever &&get_key)

template<typename Iterator , typename... Functors>
	IntrusiveMap (Iterator first, Iterator last, Functors &&... functors)

template<typename... Functors>
	IntrusiveMap (std::initializer_list< T * > items, Functors &&... functors)

T &	at (const key_type &key)

const T &	at (const key_type &key) const

iterator	begin () noexcept

const_iterator	begin () const noexcept

const_iterator	cbegin () const noexcept

iterator	end () noexcept

const_iterator	end () const noexcept

const_iterator	cend () const noexcept

reverse_iterator	rbegin () noexcept

const_reverse_iterator	rbegin () const noexcept

const_reverse_iterator	crbegin () const noexcept

reverse_iterator	rend () noexcept

const_reverse_iterator	rend () const noexcept

const_reverse_iterator	crend () const noexcept

bool	empty () const noexcept
	Returns whether the map has zero items or not.

size_t	size () const
	Returns the number of items in the map.

constexpr size_t	max_size () const noexcept

void	clear ()

std::pair< iterator, bool >	insert (T &item)

iterator	insert (iterator, T &item)

template<class Iterator >
void	insert (Iterator first, Iterator last)

void	insert (std::initializer_list< T * > ilist)

iterator	erase (T &item)

iterator	erase (iterator pos)

iterator	erase (iterator first, iterator last)

size_t	erase (const key_type &key)

void	swap (IntrusiveMap< Key, T > &other)
	Exchanges this map's items with the `other` map's items.

template<typename MapType >
void	merge (MapType &other)
	Splices items from the `other` map into this one.

size_t	count (const key_type &key) const

iterator	find (const key_type &key)

const_iterator	find (const key_type &key) const

std::pair< iterator, iterator >	equal_range (const key_type &key)

std::pair< const_iterator, const_iterator >	equal_range (const key_type &key) const

iterator	lower_bound (const key_type &key)

const_iterator	lower_bound (const key_type &key) const

iterator	upper_bound (const key_type &key)

const_iterator	upper_bound (const key_type &key) const

Friends
template<typename , typename >
class	IntrusiveMultiMap

The documentation for this class was generated from the following file:

pw_containers/public/pw_containers/intrusive_map.h

Overview

Classes

Public Types

Public Member Functions

Friends