fe::BiNodeMap< L, R, LHash, LEq, RHash, REq > Class Template Reference

A bijection between L and R that stores every pair once, in an ankerl::unordered_dense::segmented_map. More...

#include <fe/bimap.h>

Public Types
using	Left = ankerl::unordered_dense::segmented_map<L, R, LHash, LEq>
using	value_type = typename Left::value_type

Public Member Functions
	BiNodeMap ()=default
	BiNodeMap (const BiNodeMap &other)
	BiNodeMap (BiNodeMap &&) noexcept=default
BiNodeMap &	operator= (const BiNodeMap &other)
BiNodeMap &	operator= (BiNodeMap &&) noexcept=default
Getters
const Left &	left () const noexcept
size_t	size () const noexcept
bool	empty () const noexcept
auto	begin () const noexcept
auto	end () const noexcept
Lookup
at_left() and at_right() throw std::out_of_range if the key is unbound.
bool	contains_left (const auto &l) const
bool	contains_right (const auto &r) const
const R &	at_left (const auto &l) const
const L &	at_right (const auto &r) const
template<class K>
Ptr	find_right (const K &r) const
	Yields the pair whose right side is r, or nullptr.
Modifiers
They take their arguments by value, so a reference into this BiNodeMap cannot dangle halfway through.
bool	insert (L l, R r)
	Binds l to r unless either is already bound; yields whether it did.
void	insert_or_assign (L l, R r)
	Binds l to r after unbinding whatever either was bound to.
bool	erase_left (const auto &l)
	Unbinds l and its partner; yields whether l was bound.
bool	erase_right (const auto &r)
	Unbinds r and its partner; yields whether r was bound.
void	reserve (size_t n)
void	clear () noexcept

Friends
bool	operator== (const BiNodeMap &a, const BiNodeMap &b)

Detailed Description

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>
class fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >

A bijection between L and R that stores every pair once, in an ankerl::unordered_dense::segmented_map.

The right side is a set of pointers to those pairs, hashed and compared by their R. An insert never moves a pair, and neither does moving the BiNodeMap itself. An erase, however, moves the last pair into the freed slot, as it does in any ankerl::unordered_dense map. Its interface is that of BiMap, except that right() has no map to yield; find_right() takes its place.

Definition at line 136 of file bimap.h.

Member Typedef Documentation

Left

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

using fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::Left = ankerl::unordered_dense::segmented_map<L, R, LHash, LEq>

Definition at line 138 of file bimap.h.

value_type

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

using fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::value_type = typename Left::value_type

Definition at line 139 of file bimap.h.

Constructor & Destructor Documentation

BiNodeMap() [1/3]

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::BiNodeMap ( )

default

Referenced by BiNodeMap(), BiNodeMap(), operator=(), operator=(), and operator==.

BiNodeMap() [2/3]

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::BiNodeMap ( const BiNodeMap< L, R, LHash, LEq, RHash, REq > & other )

inline

Definition at line 171 of file bimap.h.

References BiNodeMap().

BiNodeMap() [3/3]

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::BiNodeMap ( BiNodeMap< L, R, LHash, LEq, RHash, REq > && )

defaultnoexcept

References BiNodeMap().

Member Function Documentation

at_left()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

const R & fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::at_left ( const auto & l ) const

inlinenodiscard

Definition at line 199 of file bimap.h.

at_right()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

const L & fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::at_right ( const auto & r ) const

inlinenodiscard

Definition at line 200 of file bimap.h.

References find_right().

begin()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

auto fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::begin ( ) const

inlinenodiscardnoexcept

Definition at line 190 of file bimap.h.

clear()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

void fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::clear ( )

inlinenoexcept

Definition at line 256 of file bimap.h.

contains_left()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::contains_left ( const auto & l ) const

inlinenodiscard

Definition at line 197 of file bimap.h.

contains_right()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::contains_right ( const auto & r ) const

inlinenodiscard

Definition at line 198 of file bimap.h.

References find_right().

empty()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::empty ( ) const

inlinenodiscardnoexcept

Definition at line 189 of file bimap.h.

end()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

auto fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::end ( ) const

inlinenodiscardnoexcept

Definition at line 191 of file bimap.h.

erase_left()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::erase_left ( const auto & l )

inline

Unbinds l and its partner; yields whether l was bound.

Definition at line 236 of file bimap.h.

Referenced by insert_or_assign().

erase_right()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::erase_right ( const auto & r )

inline

Unbinds r and its partner; yields whether r was bound.

Definition at line 244 of file bimap.h.

References find_right().

Referenced by insert_or_assign().

find_right()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

template<class K>

Ptr fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::find_right ( const K & r ) const

inlinenodiscard

Yields the pair whose right side is r, or nullptr.

Definition at line 207 of file bimap.h.

References find_right().

Referenced by at_right(), contains_right(), erase_right(), and find_right().

insert()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::insert ( L l, R r )

inline

Binds l to r unless either is already bound; yields whether it did.

Definition at line 223 of file bimap.h.

insert_or_assign()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

void fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::insert_or_assign ( L l, R r )

inline

Binds l to r after unbinding whatever either was bound to.

Definition at line 229 of file bimap.h.

References erase_left(), and erase_right().

left()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

const Left & fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::left ( ) const

inlinenodiscardnoexcept

Definition at line 187 of file bimap.h.

References left().

Referenced by left().

operator=() [1/2]

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

BiNodeMap & fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::operator= ( BiNodeMap< L, R, LHash, LEq, RHash, REq > && )

defaultnoexcept

References BiNodeMap().

operator=() [2/2]

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

BiNodeMap & fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::operator= ( const BiNodeMap< L, R, LHash, LEq, RHash, REq > & other )

inline

Definition at line 179 of file bimap.h.

References BiNodeMap().

reserve()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

void fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::reserve ( size_t n )

inline

Definition at line 251 of file bimap.h.

size()

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

size_t fe::BiNodeMap< L, R, LHash, LEq, RHash, REq >::size ( ) const

inlinenodiscardnoexcept

Definition at line 188 of file bimap.h.

Friends And Related Symbol Documentation

operator==

template<class L, class R, class LHash = ankerl::unordered_dense::hash<L>, class LEq = std::equal_to<L>, class RHash = ankerl::unordered_dense::hash<R>, class REq = std::equal_to<R>>

bool operator== ( const BiNodeMap< L, R, LHash, LEq, RHash, REq > & a, const BiNodeMap< L, R, LHash, LEq, RHash, REq > & b )

friend

Definition at line 262 of file bimap.h.

References BiNodeMap().

---

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

• fe/bimap.h