TwiceAsNice  2019-02-18
Public Types | Public Member Functions | Private Attributes | List of all members
Nice::Map< Key, T, Compare, Allocator > Class Template Reference

#include <Map.h>

Collaboration diagram for Nice::Map< Key, T, Compare, Allocator >:
Collaboration graph

Public Types

typedef std::map< Key, T, Compare, Allocator >::iterator iterator
 
typedef std::map< Key, T, Compare, Allocator >::const_iterator const_iterator
 
typedef std::map< Key, T, Compare, Allocator >::reverse_iterator reverse_iterator
 
typedef std::map< Key, T, Compare, Allocator >::const_reverse_iterator const_reverse_iterator
 
typedef std::map< Key, T, Compare, Allocator >::allocator_type allocator_type
 
typedef std::map< Key, T, Compare, Allocator >::size_type size_type
 
typedef std::map< Key, T, Compare, Allocator >::key_compare key_compare
 
typedef std::map< Key, T, Compare, Allocator >::value_compare value_compare
 
typedef std::map< Key, T, Compare, Allocator >::value_type value_type
 
typedef std::map< Key, T, Compare, Allocator >::iterator iterator
 
typedef std::map< Key, T, Compare, Allocator >::const_iterator const_iterator
 
typedef std::map< Key, T, Compare, Allocator >::reverse_iterator reverse_iterator
 
typedef std::map< Key, T, Compare, Allocator >::const_reverse_iterator const_reverse_iterator
 
typedef std::map< Key, T, Compare, Allocator >::allocator_type allocator_type
 
typedef std::map< Key, T, Compare, Allocator >::size_type size_type
 
typedef std::map< Key, T, Compare, Allocator >::key_compare key_compare
 
typedef std::map< Key, T, Compare, Allocator >::value_compare value_compare
 
typedef std::map< Key, T, Compare, Allocator >::value_type value_type
 

Public Member Functions

 Map (const Compare &comp=Compare(), const Allocator &alloc=Allocator())
 
template<class InputIterator >
 Map (InputIterator first, InputIterator last, const Compare &comp=Compare(), const Allocator &alloc=Allocator())
 
 Map (const Nice::Map< Key, T, Compare, Allocator > &x)
 
Nice::Map< Key, T, Compare, Allocator > & operator= (const Nice::Map< Key, T, Compare, Allocator > &x)
 
 ~Map (void)
 
iterator begin (void)
 
const_iterator begin (void) const
 
iterator end (void)
 
const_iterator end (void) const
 
reverse_iterator rbegin (void)
 
const_reverse_iterator rbegin (void) const
 
reverse_iterator rend (void)
 
const_reverse_iterator rend (void) const
 
size_type size (void) const
 
size_type max_size (void) const
 
bool empty (void) const
 
T operator[] (const Key &x)
 
void set (const Key &x, const T &v)
 
std::pair< iterator, bool > insert (const value_type &x)
 
iterator insert (iterator position, const value_type &x)
 
template<class InputIterator >
void insert (InputIterator first, InputIterator last)
 
void erase (iterator pos)
 
size_type erase (const Key &x)
 
void erase (iterator begin, iterator end)
 
void swap (Nice::Map< Key, T, Compare, Allocator > &x)
 
void swap (std::map< Key, T, Compare, Allocator > &x)
 
void clear (void)
 
key_compare key_comp (void) const
 
value_compare value_comp (void) const
 
const_iterator find (const Key &x) const
 
iterator find (const Key &x)
 
bool find (const Key &x, T &v) const
 
size_type count (const Key &x) const
 
const_iterator lower_bound (const Key &x) const
 
iterator lower_bound (const Key &x)
 
const_iterator upper_bound (const Key &x) const
 
iterator upper_bound (const Key &x)
 
std::pair< const_iterator, const_iterator > equal_range (const Key &x) const
 
std::pair< iterator, iterator > equal_range (const Key &x)
 
allocator_type get_allocator (void) const
 
 operator std::map< Key, T, Compare, Allocator > ()
 
template<class Visitor >
void visitor (Visitor &_v)
 
template<class Visitor , typename V1 , typename V2 , typename V3 , typename V4 , typename V5 >
void visitor (Visitor &_v, const V1 &_v1, const V2 &_v2, const V3 &_v3, const V4 &_v4, const V5 &_v5)
 
 Map (const Compare &comp=Compare(), const Allocator &alloc=Allocator())
 
template<class InputIterator >
 Map (InputIterator first, InputIterator last, const Compare &comp=Compare(), const Allocator &alloc=Allocator())
 
 Map (const Nice::Map< Key, T, Compare, Allocator > &x)
 
Nice::Map< Key, T, Compare, Allocator > & operator= (const Nice::Map< Key, T, Compare, Allocator > &x)
 
 ~Map (void)
 
iterator begin (void)
 
const_iterator begin (void) const
 
iterator end (void)
 
const_iterator end (void) const
 
reverse_iterator rbegin (void)
 
const_reverse_iterator rbegin (void) const
 
reverse_iterator rend (void)
 
const_reverse_iterator rend (void) const
 
size_type size (void) const
 
size_type max_size (void) const
 
bool empty (void) const
 
T operator[] (const Key &x)
 
void set (const Key &x, const T &v)
 
std::pair< iterator, bool > insert (const value_type &x)
 
iterator insert (iterator position, const value_type &x)
 
template<class InputIterator >
void insert (InputIterator first, InputIterator last)
 
void erase (iterator pos)
 
size_type erase (const Key &x)
 
void erase (iterator begin, iterator end)
 
void swap (Nice::Map< Key, T, Compare, Allocator > &x)
 
void swap (std::map< Key, T, Compare, Allocator > &x)
 
void clear (void)
 
key_compare key_comp (void) const
 
value_compare value_comp (void) const
 
const_iterator find (const Key &x) const
 
iterator find (const Key &x)
 
bool find (const Key &x, T &v) const
 
size_type count (const Key &x) const
 
const_iterator lower_bound (const Key &x) const
 
iterator lower_bound (const Key &x)
 
const_iterator upper_bound (const Key &x) const
 
iterator upper_bound (const Key &x)
 
std::pair< const_iterator, const_iterator > equal_range (const Key &x) const
 
std::pair< iterator, iterator > equal_range (const Key &x)
 
allocator_type get_allocator (void) const
 
 operator std::map< Key, T, Compare, Allocator > ()
 
template<class Visitor >
void visitor (Visitor &_v)
 
template<class Visitor , typename V1 , typename V2 , typename V3 , typename V4 , typename V5 >
void visitor (Visitor &_v, const V1 &_v1, const V2 &_v2, const V3 &_v3, const V4 &_v4, const V5 &_v5)
 

Private Attributes

std::map< Key, T, Compare, Allocator > m_storage
 
Nice::Mutex m_mutex
 

Member Typedef Documentation

◆ allocator_type [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::allocator_type Nice::Map< Key, T, Compare, Allocator >::allocator_type

◆ allocator_type [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::allocator_type Nice::Map< Key, T, Compare, Allocator >::allocator_type

◆ const_iterator [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::const_iterator Nice::Map< Key, T, Compare, Allocator >::const_iterator

◆ const_iterator [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::const_iterator Nice::Map< Key, T, Compare, Allocator >::const_iterator

◆ const_reverse_iterator [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::const_reverse_iterator Nice::Map< Key, T, Compare, Allocator >::const_reverse_iterator

◆ const_reverse_iterator [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::const_reverse_iterator Nice::Map< Key, T, Compare, Allocator >::const_reverse_iterator

◆ iterator [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::iterator Nice::Map< Key, T, Compare, Allocator >::iterator

◆ iterator [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::iterator Nice::Map< Key, T, Compare, Allocator >::iterator

◆ key_compare [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::key_compare Nice::Map< Key, T, Compare, Allocator >::key_compare

◆ key_compare [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::key_compare Nice::Map< Key, T, Compare, Allocator >::key_compare

◆ reverse_iterator [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::reverse_iterator Nice::Map< Key, T, Compare, Allocator >::reverse_iterator

◆ reverse_iterator [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::reverse_iterator Nice::Map< Key, T, Compare, Allocator >::reverse_iterator

◆ size_type [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::size_type Nice::Map< Key, T, Compare, Allocator >::size_type

◆ size_type [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::size_type Nice::Map< Key, T, Compare, Allocator >::size_type

◆ value_compare [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::value_compare Nice::Map< Key, T, Compare, Allocator >::value_compare

◆ value_compare [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::value_compare Nice::Map< Key, T, Compare, Allocator >::value_compare

◆ value_type [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::value_type Nice::Map< Key, T, Compare, Allocator >::value_type

◆ value_type [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
typedef std::map<Key, T, Compare, Allocator>::value_type Nice::Map< Key, T, Compare, Allocator >::value_type

Constructor & Destructor Documentation

◆ Map() [1/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::Map ( const Compare &  comp = Compare(),
const Allocator &  alloc = Allocator() 
)
inlineexplicit

◆ Map() [2/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class InputIterator >
Nice::Map< Key, T, Compare, Allocator >::Map ( InputIterator  first,
InputIterator  last,
const Compare &  comp = Compare(),
const Allocator &  alloc = Allocator() 
)
inline

◆ Map() [3/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::Map ( const Nice::Map< Key, T, Compare, Allocator > &  x)
inline

◆ ~Map() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::~Map ( void  )
inline

◆ Map() [4/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::Map ( const Compare &  comp = Compare(),
const Allocator &  alloc = Allocator() 
)
inlineexplicit

◆ Map() [5/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class InputIterator >
Nice::Map< Key, T, Compare, Allocator >::Map ( InputIterator  first,
InputIterator  last,
const Compare &  comp = Compare(),
const Allocator &  alloc = Allocator() 
)
inline

◆ Map() [6/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::Map ( const Nice::Map< Key, T, Compare, Allocator > &  x)
inline

◆ ~Map() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::~Map ( void  )
inline

Member Function Documentation

◆ begin() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::begin ( void  )
inline

◆ begin() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::begin ( void  )
inline

◆ begin() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::begin ( void  ) const
inline

◆ begin() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::begin ( void  ) const
inline

◆ clear() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::clear ( void  )
inline

◆ clear() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::clear ( void  )
inline

◆ count() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::count ( const Key &  x) const
inline

◆ count() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::count ( const Key &  x) const
inline

◆ empty() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
bool Nice::Map< Key, T, Compare, Allocator >::empty ( void  ) const
inline

◆ empty() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
bool Nice::Map< Key, T, Compare, Allocator >::empty ( void  ) const
inline

◆ end() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::end ( void  )
inline

◆ end() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::end ( void  )
inline

◆ end() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::end ( void  ) const
inline

◆ end() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::end ( void  ) const
inline

◆ equal_range() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::pair<const_iterator,const_iterator> Nice::Map< Key, T, Compare, Allocator >::equal_range ( const Key &  x) const
inline

◆ equal_range() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::pair<const_iterator,const_iterator> Nice::Map< Key, T, Compare, Allocator >::equal_range ( const Key &  x) const
inline

◆ equal_range() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::pair<iterator,iterator> Nice::Map< Key, T, Compare, Allocator >::equal_range ( const Key &  x)
inline

◆ equal_range() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::pair<iterator,iterator> Nice::Map< Key, T, Compare, Allocator >::equal_range ( const Key &  x)
inline

◆ erase() [1/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::erase ( iterator  pos)
inline

◆ erase() [2/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::erase ( iterator  pos)
inline

◆ erase() [3/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::erase ( const Key &  x)
inline

◆ erase() [4/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::erase ( const Key &  x)
inline

◆ erase() [5/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::erase ( iterator  begin,
iterator  end 
)
inline

◆ erase() [6/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::erase ( iterator  begin,
iterator  end 
)
inline

◆ find() [1/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::find ( const Key &  x) const
inline

◆ find() [2/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::find ( const Key &  x) const
inline

◆ find() [3/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::find ( const Key &  x)
inline

◆ find() [4/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::find ( const Key &  x)
inline

◆ find() [5/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
bool Nice::Map< Key, T, Compare, Allocator >::find ( const Key &  x,
T &  v 
) const
inline

◆ find() [6/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
bool Nice::Map< Key, T, Compare, Allocator >::find ( const Key &  x,
T &  v 
) const
inline

◆ get_allocator() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
allocator_type Nice::Map< Key, T, Compare, Allocator >::get_allocator ( void  ) const
inline

◆ get_allocator() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
allocator_type Nice::Map< Key, T, Compare, Allocator >::get_allocator ( void  ) const
inline

◆ insert() [1/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::pair<iterator, bool> Nice::Map< Key, T, Compare, Allocator >::insert ( const value_type &  x)
inline

◆ insert() [2/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::pair<iterator, bool> Nice::Map< Key, T, Compare, Allocator >::insert ( const value_type &  x)
inline

◆ insert() [3/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::insert ( iterator  position,
const value_type &  x 
)
inline

◆ insert() [4/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::insert ( iterator  position,
const value_type &  x 
)
inline

◆ insert() [5/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class InputIterator >
void Nice::Map< Key, T, Compare, Allocator >::insert ( InputIterator  first,
InputIterator  last 
)
inline

◆ insert() [6/6]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class InputIterator >
void Nice::Map< Key, T, Compare, Allocator >::insert ( InputIterator  first,
InputIterator  last 
)
inline

◆ key_comp() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
key_compare Nice::Map< Key, T, Compare, Allocator >::key_comp ( void  ) const
inline

◆ key_comp() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
key_compare Nice::Map< Key, T, Compare, Allocator >::key_comp ( void  ) const
inline

◆ lower_bound() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::lower_bound ( const Key &  x) const
inline

◆ lower_bound() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::lower_bound ( const Key &  x) const
inline

◆ lower_bound() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::lower_bound ( const Key &  x)
inline

◆ lower_bound() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::lower_bound ( const Key &  x)
inline

◆ max_size() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::max_size ( void  ) const
inline

◆ max_size() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::max_size ( void  ) const
inline

◆ operator std::map< Key, T, Compare, Allocator >() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::operator std::map< Key, T, Compare, Allocator > ( )
inline

◆ operator std::map< Key, T, Compare, Allocator >() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map< Key, T, Compare, Allocator >::operator std::map< Key, T, Compare, Allocator > ( )
inline

◆ operator=() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map<Key, T, Compare, Allocator>& Nice::Map< Key, T, Compare, Allocator >::operator= ( const Nice::Map< Key, T, Compare, Allocator > &  x)
inline

◆ operator=() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Map<Key, T, Compare, Allocator>& Nice::Map< Key, T, Compare, Allocator >::operator= ( const Nice::Map< Key, T, Compare, Allocator > &  x)
inline

◆ operator[]() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
T Nice::Map< Key, T, Compare, Allocator >::operator[] ( const Key &  x)
inline

◆ operator[]() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
T Nice::Map< Key, T, Compare, Allocator >::operator[] ( const Key &  x)
inline

◆ rbegin() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rbegin ( void  )
inline

◆ rbegin() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rbegin ( void  )
inline

◆ rbegin() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rbegin ( void  ) const
inline

◆ rbegin() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rbegin ( void  ) const
inline

◆ rend() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rend ( void  )
inline

◆ rend() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rend ( void  )
inline

◆ rend() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rend ( void  ) const
inline

◆ rend() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_reverse_iterator Nice::Map< Key, T, Compare, Allocator >::rend ( void  ) const
inline

◆ set() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::set ( const Key &  x,
const T &  v 
)
inline

◆ set() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::set ( const Key &  x,
const T &  v 
)
inline

◆ size() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::size ( void  ) const
inline

◆ size() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
size_type Nice::Map< Key, T, Compare, Allocator >::size ( void  ) const
inline

◆ swap() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::swap ( Nice::Map< Key, T, Compare, Allocator > &  x)
inline

◆ swap() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::swap ( Nice::Map< Key, T, Compare, Allocator > &  x)
inline

◆ swap() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::swap ( std::map< Key, T, Compare, Allocator > &  x)
inline

◆ swap() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
void Nice::Map< Key, T, Compare, Allocator >::swap ( std::map< Key, T, Compare, Allocator > &  x)
inline

◆ upper_bound() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::upper_bound ( const Key &  x) const
inline

◆ upper_bound() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
const_iterator Nice::Map< Key, T, Compare, Allocator >::upper_bound ( const Key &  x) const
inline

◆ upper_bound() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::upper_bound ( const Key &  x)
inline

◆ upper_bound() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
iterator Nice::Map< Key, T, Compare, Allocator >::upper_bound ( const Key &  x)
inline

◆ value_comp() [1/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
value_compare Nice::Map< Key, T, Compare, Allocator >::value_comp ( void  ) const
inline

◆ value_comp() [2/2]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
value_compare Nice::Map< Key, T, Compare, Allocator >::value_comp ( void  ) const
inline

◆ visitor() [1/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class Visitor >
void Nice::Map< Key, T, Compare, Allocator >::visitor ( Visitor &  _v)
inline

◆ visitor() [2/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class Visitor >
void Nice::Map< Key, T, Compare, Allocator >::visitor ( Visitor &  _v)
inline

◆ visitor() [3/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class Visitor , typename V1 , typename V2 , typename V3 , typename V4 , typename V5 >
void Nice::Map< Key, T, Compare, Allocator >::visitor ( Visitor &  _v,
const V1 &  _v1,
const V2 &  _v2,
const V3 &  _v3,
const V4 &  _v4,
const V5 &  _v5 
)
inline

◆ visitor() [4/4]

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
template<class Visitor , typename V1 , typename V2 , typename V3 , typename V4 , typename V5 >
void Nice::Map< Key, T, Compare, Allocator >::visitor ( Visitor &  _v,
const V1 &  _v1,
const V2 &  _v2,
const V3 &  _v3,
const V4 &  _v4,
const V5 &  _v5 
)
inline

Member Data Documentation

◆ m_mutex

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
Nice::Mutex Nice::Map< Key, T, Compare, Allocator >::m_mutex
private

◆ m_storage

template<class Key, class T, class Compare = std::less<Key>, class Allocator = std::allocator<std::pair<const Key,T> >>
std::map< Key, T, Compare, Allocator > Nice::Map< Key, T, Compare, Allocator >::m_storage
private
The documentation for this class was generated from the following file:
Generated on Mon Feb 18 2019 14:18:37 for TwiceAsNice by   doxygen 1.8.14