Maipa's Standard Library Extension 1.5.6
mstd
Loading...
Searching...
No Matches
mstd::bimap< Key, T, Map > Class Template Reference

#include <bimap.hpp>

Inheritance diagram for mstd::bimap< Key, T, Map >:
[legend]
Collaboration diagram for mstd::bimap< Key, T, Map >:
[legend]

Public Types

using key_type = remove_cvref_t<Key>
using mapped_type = remove_cvref_t<T>
using value_type = std::pair<key_type, mapped_type>
using reference = value_type&
using const_reference = const value_type&
using size_type = _MSTD_TYPENAME17 _data_type::size_type
using difference_type = _MSTD_TYPENAME17 _data_type::difference_type
using iterator = _MSTD_TYPENAME17 _data_type::const_iterator
using const_iterator = _MSTD_TYPENAME17 _data_type::const_iterator
using reverse_iterator = _MSTD_TYPENAME17 _data_type::const_reverse_iterator
using const_reverse_iterator = _MSTD_TYPENAME17 _data_type::const_reverse_iterator

Public Member Functions

_MSTD_CONSTEXPR20 bimap ()=default
_MSTD_CONSTEXPR20 bimap (std::initializer_list< value_type > init)
_MSTD_CONSTEXPR20 bimap (const bimap &other)=default
_MSTD_CONSTEXPR20 bimap (bimap &&other) noexcept=default
template<mstd::iterator_of< value_type > Iter>
_MSTD_CONSTEXPR20 bimap (Iter begin, Iter end)
_MSTD_CONSTEXPR20 ~bimap ()=default
_MSTD_CONSTEXPR20 bimap & operator= (const bimap &other)=default
_MSTD_CONSTEXPR20 bimap & operator= (bimap &&other) noexcept=default
_MSTD_CONSTEXPR20 mapped_type & emplace (const key_type &key, const mapped_type &value)
_MSTD_CONSTEXPR20 mapped_type & emplace (key_type &&key, mapped_type &&value)
_MSTD_CONSTEXPR20 mapped_type & insert (const value_type &value)
_MSTD_CONSTEXPR20 mapped_type & insert (value_type &&value)
template<mstd::iterator_of< value_type > Iter>
_MSTD_CONSTEXPR20 void insert (Iter begin, Iter end)
_MSTD_CONSTEXPR20 void erase (const key_type &key)
_MSTD_CONSTEXPR20 void erase (key_type &&key)
_MSTD_CONSTEXPR20 void erase_value (const mapped_type &value)
_MSTD_CONSTEXPR20 void erase_value (mapped_type &&value)
_MSTD_CONSTEXPR20 mapped_type & at (const key_type &key)
_MSTD_CONSTEXPR20 mapped_type & at (key_type &&key)
_MSTD_CONSTEXPR20 const mapped_type & at (const key_type &key) const
_MSTD_CONSTEXPR20 const mapped_type & at (key_type &&key) const
_MSTD_CONSTEXPR20 key_type & at_value (const mapped_type &value)
_MSTD_CONSTEXPR20 key_type & at_value (mapped_type &&value)
_MSTD_CONSTEXPR20 const key_type & at_value (const mapped_type &value) const
_MSTD_CONSTEXPR20 const key_type & at_value (mapped_type &&value) const
_MSTD_CONSTEXPR20 size_t size () const
_MSTD_CONSTEXPR20 bool empty () const
_MSTD_CONSTEXPR20 bool contains (const key_type &key) const
_MSTD_CONSTEXPR20 bool contains (key_type &&key) const
_MSTD_CONSTEXPR20 bool contains_value (const mapped_type &value) const
_MSTD_CONSTEXPR20 bool contains_value (mapped_type &&value) const
_MSTD_CONSTEXPR20 iterator find (const key_type &key)
_MSTD_CONSTEXPR20 iterator find (key_type &&key)
_MSTD_CONSTEXPR20 const_iterator find (const key_type &key) const
_MSTD_CONSTEXPR20 const_iterator find (key_type &&key) const
_MSTD_CONSTEXPR20 iterator find_value (const mapped_type &value)
_MSTD_CONSTEXPR20 iterator find_value (mapped_type &&value)
_MSTD_CONSTEXPR20 const_iterator find_value (const mapped_type &value) const
_MSTD_CONSTEXPR20 const_iterator find_value (mapped_type &&value) const
_MSTD_CONSTEXPR20 void clear ()
_MSTD_CONSTEXPR20 iterator begin ()
_MSTD_CONSTEXPR20 iterator end ()
_MSTD_CONSTEXPR20 const_iterator begin () const
_MSTD_CONSTEXPR20 const_iterator end () const
_MSTD_CONSTEXPR20 const_iterator cbegin () const
_MSTD_CONSTEXPR20 const_iterator cend () const
_MSTD_CONSTEXPR20 reverse_iterator rbegin ()
_MSTD_CONSTEXPR20 reverse_iterator rend ()
_MSTD_CONSTEXPR20 const_reverse_iterator rbegin () const
_MSTD_CONSTEXPR20 const_reverse_iterator rend () const
_MSTD_CONSTEXPR20 const_reverse_iterator crbegin () const
_MSTD_CONSTEXPR20 const_reverse_iterator crend () const
_MSTD_CONSTEXPR20 mapped_type & operator[] (const key_type &key)
_MSTD_CONSTEXPR20 mapped_type & operator[] (key_type &&key)
_MSTD_CONSTEXPR20 const mapped_type & operator[] (const key_type &key) const
_MSTD_CONSTEXPR20 const mapped_type & operator[] (key_type &&key) const
_MSTD_CONSTEXPR20 bool operator== (const bimap &other) const
_MSTD_CONSTEXPR20 bool operator!= (const bimap &other) const

Private Types

using _data_type = std::vector<value_type>
using _map_type = Map<key_type, size_type>
using _inverted_map_type = Map<mapped_type, size_type>

Private Member Functions

_MSTD_CONSTEXPR20 void _update_indexes (const size_type from)
template<class UK, class U>
_MSTD_CONSTEXPR20 mapped_type & _emplace (UK &&key, U &&value)
template<class U>
_MSTD_CONSTEXPR20 mapped_type & _insert (U &&value)
template<class UK>
_MSTD_CONSTEXPR20 void _erase (UK &&key)
template<class U>
_MSTD_CONSTEXPR20 void _erase_value (U &&value)
template<class UK>
_MSTD_CONSTEXPR20 mapped_type & _at (UK &&key)
template<class UK>
_MSTD_CONSTEXPR20 const mapped_type & _at (UK &&key) const
template<class U>
_MSTD_CONSTEXPR20 key_type & _at_value (U &&value)
template<class U>
_MSTD_CONSTEXPR20 const key_type & _at_value (U &&value) const
template<class UK>
_MSTD_CONSTEXPR20 bool _contains (UK &&key) const
template<class U>
_MSTD_CONSTEXPR20 bool _contains_value (U &&value) const
template<class UK>
_MSTD_CONSTEXPR20 key_type & _at_with_construct (UK &&key)
template<class UK>
_MSTD_CONSTEXPR20 iterator _find (UK &&key)
template<class UK>
_MSTD_CONSTEXPR20 const_iterator _find (UK &&key) const
template<class U>
_MSTD_CONSTEXPR20 iterator _find_value (U &&value)
template<class U>
_MSTD_CONSTEXPR20 const_iterator _find_value (U &&value) const

Private Attributes

_data_type _data
_map_type _map
_inverted_map_type _invertedMap

Member Typedef Documentation

◆ _data_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::_data_type = std::vector<value_type>
private

◆ _inverted_map_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::_inverted_map_type = Map<mapped_type, size_type>
private

◆ _map_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::_map_type = Map<key_type, size_type>
private

◆ const_iterator

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::const_iterator = _MSTD_TYPENAME17 _data_type::const_iterator

◆ const_reference

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::const_reference = const value_type&

◆ const_reverse_iterator

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::const_reverse_iterator = _MSTD_TYPENAME17 _data_type::const_reverse_iterator

◆ difference_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::difference_type = _MSTD_TYPENAME17 _data_type::difference_type

◆ iterator

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::iterator = _MSTD_TYPENAME17 _data_type::const_iterator

◆ key_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::key_type = remove_cvref_t<Key>

◆ mapped_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::mapped_type = remove_cvref_t<T>

◆ reference

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::reference = value_type&

◆ reverse_iterator

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::reverse_iterator = _MSTD_TYPENAME17 _data_type::const_reverse_iterator

◆ size_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::size_type = _MSTD_TYPENAME17 _data_type::size_type

◆ value_type

template<class Key, class T, template< class, class, class... > class Map>
using mstd::bimap< Key, T, Map >::value_type = std::pair<key_type, mapped_type>

Constructor & Destructor Documentation

◆ bimap() [1/5]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mstd::bimap< Key, T, Map >::bimap ( )
default

◆ bimap() [2/5]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mstd::bimap< Key, T, Map >::bimap ( std::initializer_list< value_type > init)
inline

◆ bimap() [3/5]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mstd::bimap< Key, T, Map >::bimap ( const bimap< Key, T, Map > & other)
default

◆ bimap() [4/5]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mstd::bimap< Key, T, Map >::bimap ( bimap< Key, T, Map > && other)
defaultnoexcept

◆ bimap() [5/5]

template<class Key, class T, template< class, class, class... > class Map>
template<mstd::iterator_of< value_type > Iter>
_MSTD_CONSTEXPR20 mstd::bimap< Key, T, Map >::bimap ( Iter begin,
Iter end )
inline

◆ ~bimap()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mstd::bimap< Key, T, Map >::~bimap ( )
default

Member Function Documentation

◆ _at() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::_at ( UK && key)
inlinenodiscardprivate

◆ _at() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 const mapped_type & mstd::bimap< Key, T, Map >::_at ( UK && key) const
inlinenodiscardprivate

◆ _at_value() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 key_type & mstd::bimap< Key, T, Map >::_at_value ( U && value)
inlinenodiscardprivate

◆ _at_value() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 const key_type & mstd::bimap< Key, T, Map >::_at_value ( U && value) const
inlinenodiscardprivate

◆ _at_with_construct()

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 key_type & mstd::bimap< Key, T, Map >::_at_with_construct ( UK && key)
inlinenodiscardprivate

◆ _contains()

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::_contains ( UK && key) const
inlinenodiscardprivate

◆ _contains_value()

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::_contains_value ( U && value) const
inlinenodiscardprivate

◆ _emplace()

template<class Key, class T, template< class, class, class... > class Map>
template<class UK, class U>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::_emplace ( UK && key,
U && value )
inlineprivate

◆ _erase()

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::_erase ( UK && key)
inlineprivate

◆ _erase_value()

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::_erase_value ( U && value)
inlineprivate

◆ _find() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::_find ( UK && key)
inlinenodiscardprivate

◆ _find() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class UK>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::_find ( UK && key) const
inlinenodiscardprivate

◆ _find_value() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::_find_value ( U && value)
inlinenodiscardprivate

◆ _find_value() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::_find_value ( U && value) const
inlinenodiscardprivate

◆ _insert()

template<class Key, class T, template< class, class, class... > class Map>
template<class U>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::_insert ( U && value)
inlineprivate

◆ _update_indexes()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::_update_indexes ( const size_type from)
inlineprivate

◆ at() [1/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::at ( const key_type & key)
inlinenodiscard

◆ at() [2/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const mapped_type & mstd::bimap< Key, T, Map >::at ( const key_type & key) const
inlinenodiscard

◆ at() [3/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::at ( key_type && key)
inlinenodiscard

◆ at() [4/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const mapped_type & mstd::bimap< Key, T, Map >::at ( key_type && key) const
inlinenodiscard

◆ at_value() [1/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 key_type & mstd::bimap< Key, T, Map >::at_value ( const mapped_type & value)
inlinenodiscard

◆ at_value() [2/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const key_type & mstd::bimap< Key, T, Map >::at_value ( const mapped_type & value) const
inlinenodiscard

◆ at_value() [3/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 key_type & mstd::bimap< Key, T, Map >::at_value ( mapped_type && value)
inlinenodiscard

◆ at_value() [4/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const key_type & mstd::bimap< Key, T, Map >::at_value ( mapped_type && value) const
inlinenodiscard

◆ begin() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::begin ( )
inlinenodiscard

◆ begin() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::begin ( ) const
inlinenodiscard

◆ cbegin()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::cbegin ( ) const
inlinenodiscard

◆ cend()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::cend ( ) const
inlinenodiscard

◆ clear()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::clear ( )
inline

◆ contains() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::contains ( const key_type & key) const
inlinenodiscard

◆ contains() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::contains ( key_type && key) const
inlinenodiscard

◆ contains_value() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::contains_value ( const mapped_type & value) const
inlinenodiscard

◆ contains_value() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::contains_value ( mapped_type && value) const
inlinenodiscard

◆ crbegin()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_reverse_iterator mstd::bimap< Key, T, Map >::crbegin ( ) const
inlinenodiscard

◆ crend()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_reverse_iterator mstd::bimap< Key, T, Map >::crend ( ) const
inlinenodiscard

◆ emplace() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::emplace ( const key_type & key,
const mapped_type & value )
inline

◆ emplace() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::emplace ( key_type && key,
mapped_type && value )
inline

◆ empty()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::empty ( ) const
inlinenodiscard

◆ end() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::end ( )
inlinenodiscard

◆ end() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::end ( ) const
inlinenodiscard

◆ erase() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::erase ( const key_type & key)
inline

◆ erase() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::erase ( key_type && key)
inline

◆ erase_value() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::erase_value ( const mapped_type & value)
inline

◆ erase_value() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::erase_value ( mapped_type && value)
inline

◆ find() [1/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::find ( const key_type & key)
inlinenodiscard

◆ find() [2/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::find ( const key_type & key) const
inlinenodiscard

◆ find() [3/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::find ( key_type && key)
inlinenodiscard

◆ find() [4/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::find ( key_type && key) const
inlinenodiscard

◆ find_value() [1/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::find_value ( const mapped_type & value)
inlinenodiscard

◆ find_value() [2/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::find_value ( const mapped_type & value) const
inlinenodiscard

◆ find_value() [3/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 iterator mstd::bimap< Key, T, Map >::find_value ( mapped_type && value)
inlinenodiscard

◆ find_value() [4/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_iterator mstd::bimap< Key, T, Map >::find_value ( mapped_type && value) const
inlinenodiscard

◆ insert() [1/3]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::insert ( const value_type & value)
inline

◆ insert() [2/3]

template<class Key, class T, template< class, class, class... > class Map>
template<mstd::iterator_of< value_type > Iter>
_MSTD_CONSTEXPR20 void mstd::bimap< Key, T, Map >::insert ( Iter begin,
Iter end )
inline

◆ insert() [3/3]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::insert ( value_type && value)
inline

◆ operator!=()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::operator!= ( const bimap< Key, T, Map > & other) const
inline

◆ operator=() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bimap & mstd::bimap< Key, T, Map >::operator= ( bimap< Key, T, Map > && other)
defaultnoexcept

◆ operator=() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bimap & mstd::bimap< Key, T, Map >::operator= ( const bimap< Key, T, Map > & other)
default

◆ operator==()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 bool mstd::bimap< Key, T, Map >::operator== ( const bimap< Key, T, Map > & other) const
inline

◆ operator[]() [1/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::operator[] ( const key_type & key)
inlinenodiscard

◆ operator[]() [2/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const mapped_type & mstd::bimap< Key, T, Map >::operator[] ( const key_type & key) const
inlinenodiscard

◆ operator[]() [3/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 mapped_type & mstd::bimap< Key, T, Map >::operator[] ( key_type && key)
inlinenodiscard

◆ operator[]() [4/4]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const mapped_type & mstd::bimap< Key, T, Map >::operator[] ( key_type && key) const
inlinenodiscard

◆ rbegin() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 reverse_iterator mstd::bimap< Key, T, Map >::rbegin ( )
inlinenodiscard

◆ rbegin() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_reverse_iterator mstd::bimap< Key, T, Map >::rbegin ( ) const
inlinenodiscard

◆ rend() [1/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 reverse_iterator mstd::bimap< Key, T, Map >::rend ( )
inlinenodiscard

◆ rend() [2/2]

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 const_reverse_iterator mstd::bimap< Key, T, Map >::rend ( ) const
inlinenodiscard

◆ size()

template<class Key, class T, template< class, class, class... > class Map>
_MSTD_CONSTEXPR20 size_t mstd::bimap< Key, T, Map >::size ( ) const
inlinenodiscard

Member Data Documentation

◆ _data

template<class Key, class T, template< class, class, class... > class Map>
_data_type mstd::bimap< Key, T, Map >::_data
private

◆ _invertedMap

template<class Key, class T, template< class, class, class... > class Map>
_inverted_map_type mstd::bimap< Key, T, Map >::_invertedMap
private

◆ _map

template<class Key, class T, template< class, class, class... > class Map>
_map_type mstd::bimap< Key, T, Map >::_map
private