---

more::gen::degenerate_set Class Template Reference

A set which supports degenerate elements. More...

#include <more/gen/degenerate_set.h>

Inheritance diagram for more::gen::degenerate_set:

[legend]List of all members.

Public Types

• typedef Key key_type
• typedef Key value_type
• typedef Compare key_compare
• typedef Compare value_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_set ()
• degenerate_set (degenerate_set const &x)
• degenerate_set (key_compare const &kc)
• degenerate_set & operator= (degenerate_set const &rhs)
• bool operator== (degenerate_set const &rhs) const
• bool operator!= (degenerate_set const &rhs) const
• bool operator< (degenerate_set const &rhs) const
• bool operator<= (degenerate_set const &rhs) const
• bool operator> (degenerate_set const &rhs) const
• bool operator>= (degenerate_set 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_set &x)
• std::pair< iterator, size_type > insert (const value_type &x)

  Insert x into the set. More...
  
  

• std::pair< iterator, size_type > 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 Compare = std::less<Key>>
class more::gen::degenerate_set< Key, Compare >

A set which supports degenerate elements.

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

---

Member Typedef Documentation

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

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

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

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

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

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

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

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

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

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

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

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

template<typename Key, typename Compare = std::less<Key>> typedef Compare more::gen::degenerate_set::value_compare

template<typename Key, typename Compare = std::less<Key>> typedef Key more::gen::degenerate_set::value_type

---

Constructor & Destructor Documentation

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

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

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

---

Member Function Documentation

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

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

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

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

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

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

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

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

Sink the degeneracy of k, and remove if zero.

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

Erase a range of iterators.

template<typename Key, typename Compare = std::less<Key>> void more::gen::degenerate_set< Key, 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 Compare = std::less<Key>> iterator more::gen::degenerate_set< Key, Compare >::find (  key_type const &    k )  const [inline]

template<typename Key, typename Compare = std::less<Key>> std::pair<iterator, size_type> more::gen::degenerate_set< Key, 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 Compare = std::less<Key>> std::pair<iterator, size_type> more::gen::degenerate_set< Key, Compare >::insert (  iterator    hint, const value_type &    x )  [inline]

Insert with hint.

template<typename Key, typename Compare = std::less<Key>> std::pair<iterator, size_type> more::gen::degenerate_set< Key, 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 Compare = std::less<Key>> key_compare more::gen::degenerate_set< Key, Compare >::key_comp (    )  const [inline]

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

---

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

• more/gen/degenerate_set.h

---