---

more::gen::degenerate_map Class Template Reference

A map with degenerate values. More...

#include <more/gen/degenerate_map.h>

List of all members.

Public Types

• typedef Key key_type
• typedef Data mapped_type
• typedef std::pair< const key_type,
  mapped_type > value_type
• typedef Compare key_compare
• typedef std::size_t size_type
• typedef transforming_iterator<
  sub_iterator, selector > const_iterator
• typedef transforming_iterator<
  reverse_sub_iterator, selector > const_reverse_iterator
• typedef const_iterator iterator
• typedef const_reverse_iterator reverse_iterator
• typedef value_type & reference
• typedef const value_type & const_reference
• typedef value_type * pointer
• typedef container::difference_type difference_type
• typedef container::size_type size_type

Public Methods

• degenerate_map ()
• degenerate_map (degenerate_map const &x)
• degenerate_map (key_compare const &comp)
• degenerate_map & operator= (degenerate_map const &rhs)
• bool operator== (degenerate_map const &rhs) const
• bool operator!= (degenerate_map const &rhs) const
• bool operator< (degenerate_map const &rhs) const
• bool operator<= (degenerate_map const &rhs) const
• bool operator> (degenerate_map const &rhs) const
• bool operator>= (degenerate_map const &rhs) const
• iterator begin () const
• iterator end () const
• reverse_iterator rbegin () const
• reverse_iterator rend () const
• size_type size () const
• size_type max_size () const
• size_type empty () const
• key_compare key_comp () const
• value_compare value_comp () const
• void swap (degenerate_map &x)
• std::pair< iterator, size_type > insert (const value_type &x)

  Insert x into the set. More...
  
  

• std::pair< iterator, bool > insert (iterator hint, const value_type &x)

  Insert with hint. More...
  
  

• std::pair< iterator, size_type > insert (iterator it)

  Increase the degneracy of it. More...
  
  

• void erase (iterator it)

  Decrease the degeneracy of it, and remove if zero. More...
  
  

• void erase (iterator it, iterator it_end)

  Erase a range of iterators. More...
  
  

• size_type erase (key_type const &k)

  Sink the degeneracy of k, and remove if zero. More...
  
  

• iterator find (key_type const &k) const
• size_type count (key_type const &k) const
• size_type degeneracy (iterator it) const
• size_type degeneracy (key_type const &k) const
• iterator lower_bound (const key_type &k) const
• iterator upper_bound (const key_type &k) const
• std::pair< iterator, iterator > equal_range (key_type const &k) const

---

Detailed Description

template<typename Key, typename Data, typename Compare = std::less<Key>>
class more::gen::degenerate_map< Key, Data, Compare >

A map with degenerate values.

The degeneracy of an element is defined as the number of insertions minus the number of erases of the element or keys which is equal to its key according to the given comparison functional.

---

Member Typedef Documentation

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef transforming_iterator<sub_iterator, selector> more::gen::degenerate_map::const_iterator

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef const value_type& more::gen::degenerate_map::const_reference

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef transforming_iterator<reverse_sub_iterator, selector> more::gen::degenerate_map::const_reverse_iterator

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef container::difference_type more::gen::degenerate_map::difference_type

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef const_iterator more::gen::degenerate_map::iterator

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef Compare more::gen::degenerate_map::key_compare

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef Key more::gen::degenerate_map::key_type

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef Data more::gen::degenerate_map::mapped_type

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef value_type* more::gen::degenerate_map::pointer

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef value_type& more::gen::degenerate_map::reference

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef const_reverse_iterator more::gen::degenerate_map::reverse_iterator

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef container::size_type more::gen::degenerate_map::size_type

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef std::size_t more::gen::degenerate_map::size_type

template<typename Key, typename Data, typename Compare = std::less<Key>> typedef std::pair<const key_type, mapped_type> more::gen::degenerate_map::value_type

---

Constructor & Destructor Documentation

template<typename Key, typename Data, typename Compare = std::less<Key>> more::gen::degenerate_map< Key, Data, Compare >::degenerate_map (    )  [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> more::gen::degenerate_map< Key, Data, Compare >::degenerate_map (  degenerate_map< Key, Data, Compare > const &    x )  [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> more::gen::degenerate_map< Key, Data, Compare >::degenerate_map (  key_compare const &    comp )  [inline]

---

Member Function Documentation

template<typename Key, typename Data, typename Compare = std::less<Key>> iterator more::gen::degenerate_map< Key, Data, Compare >::begin (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::count (  key_type const &    k )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::degeneracy (  key_type const &    k )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::degeneracy (  iterator    it )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::empty (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> iterator more::gen::degenerate_map< Key, Data, Compare >::end (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> std::pair<iterator, iterator> more::gen::degenerate_map< Key, Data, Compare >::equal_range (  key_type const &    k )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::erase (  key_type const &    k )  [inline]

Sink the degeneracy of k, and remove if zero.

template<typename Key, typename Data, typename Compare = std::less<Key>> void more::gen::degenerate_map< Key, Data, Compare >::erase (  iterator    it, iterator    it_end )  [inline]

Erase a range of iterators.

template<typename Key, typename Data, typename Compare = std::less<Key>> void more::gen::degenerate_map< Key, Data, Compare >::erase (  iterator    it )  [inline]

Decrease the degeneracy of it, and remove if zero. Precondition: it must be a valid iterator in this container.

template<typename Key, typename Data, typename Compare = std::less<Key>> iterator more::gen::degenerate_map< Key, Data, Compare >::find (  key_type const &    k )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> std::pair<iterator, size_type> more::gen::degenerate_map< Key, Data, Compare >::insert (  iterator    it )  [inline]

Increase the degneracy of it. Precondition: it must be a valid iterator pointing into this container.

template<typename Key, typename Data, typename Compare = std::less<Key>> std::pair<iterator, bool> more::gen::degenerate_map< Key, Data, Compare >::insert (  iterator    hint, const value_type &    x )  [inline]

Insert with hint.

template<typename Key, typename Data, typename Compare = std::less<Key>> std::pair<iterator, size_type> more::gen::degenerate_map< Key, Data, Compare >::insert (  const value_type &    x )  [inline]

Insert x into the set. Returns: A pair of the iterator to the value, and the degeneracy of the value before the insertion.

template<typename Key, typename Data, typename Compare = std::less<Key>> key_compare more::gen::degenerate_map< Key, Data, Compare >::key_comp (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> iterator more::gen::degenerate_map< Key, Data, Compare >::lower_bound (  const key_type &    k )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::max_size (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> bool more::gen::degenerate_map< Key, Data, Compare >::operator!= (  degenerate_map< Key, Data, Compare > const &    rhs )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> bool more::gen::degenerate_map< Key, Data, Compare >::operator< (  degenerate_map< Key, Data, Compare > const &    rhs )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> bool more::gen::degenerate_map< Key, Data, Compare >::operator<= (  degenerate_map< Key, Data, Compare > const &    rhs )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> degenerate_map& more::gen::degenerate_map< Key, Data, Compare >::operator= (  degenerate_map< Key, Data, Compare > const &    rhs )  [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> bool more::gen::degenerate_map< Key, Data, Compare >::operator== (  degenerate_map< Key, Data, Compare > const &    rhs )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> bool more::gen::degenerate_map< Key, Data, Compare >::operator> (  degenerate_map< Key, Data, Compare > const &    rhs )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> bool more::gen::degenerate_map< Key, Data, Compare >::operator>= (  degenerate_map< Key, Data, Compare > const &    rhs )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> reverse_iterator more::gen::degenerate_map< Key, Data, Compare >::rbegin (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> reverse_iterator more::gen::degenerate_map< Key, Data, Compare >::rend (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> size_type more::gen::degenerate_map< Key, Data, Compare >::size (    )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> void more::gen::degenerate_map< Key, Data, Compare >::swap (  degenerate_map< Key, Data, Compare > &    x )  [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> iterator more::gen::degenerate_map< Key, Data, Compare >::upper_bound (  const key_type &    k )  const [inline]

template<typename Key, typename Data, typename Compare = std::less<Key>> value_compare more::gen::degenerate_map< Key, Data, Compare >::value_comp (    )  const [inline]

---

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

• more/gen/degenerate_map.h

---