Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::unordered::unordered_multiset< T, H, P, A > Singleton Reference

#include <unordered_set_fwd.hpp>

Public Types

typedef T key_type
 
typedef T value_type
 
typedef H hasher
 
typedef P key_equal
 
typedef A allocator_type
 
typedef allocator_traits::pointer pointer
 
typedef
allocator_traits::const_pointer 
const_pointer
 
typedef value_typereference
 
typedef value_type const & const_reference
 
typedef std::size_t size_type
 
typedef std::ptrdiff_t difference_type
 
typedef table::cl_iterator const_local_iterator
 
typedef table::cl_iterator local_iterator
 
typedef table::c_iterator const_iterator
 
typedef table::c_iterator iterator
 

Public Member Functions

 unordered_multiset (size_type=boost::unordered::detail::default_bucket_count, const hasher &=hasher(), const key_equal &=key_equal(), const allocator_type &=allocator_type())
 
 unordered_multiset (allocator_type const &)
 
template<class InputIt >
 unordered_multiset (InputIt, InputIt)
 
template<class InputIt >
 unordered_multiset (InputIt, InputIt, size_type, const hasher &=hasher(), const key_equal &=key_equal())
 
template<class InputIt >
 unordered_multiset (InputIt, InputIt, size_type, const hasher &, const key_equal &, const allocator_type &)
 
 unordered_multiset (unordered_multiset const &)
 
 unordered_multiset (unordered_multiset const &, allocator_type const &)
 
 unordered_multiset (unordered_multiset &&other) BOOST_NOEXCEPT_IF(table
 
 unordered_multiset (unordered_multiset &&, allocator_type const &)
 
 unordered_multiset (std::initializer_list< value_type >, size_type=boost::unordered::detail::default_bucket_count, const hasher &=hasher(), const key_equal &l=key_equal(), const allocator_type &=allocator_type())
 
 ~unordered_multiset () BOOST_NOEXCEPT
 
unordered_multisetoperator= (unordered_multiset const &x)
 
unordered_multisetoperator= (unordered_multiset &&x)
 
unordered_multisetoperator= (std::initializer_list< value_type >)
 
allocator_type get_allocator () const BOOST_NOEXCEPT
 
bool empty () const BOOST_NOEXCEPT
 
size_type size () const BOOST_NOEXCEPT
 
size_type max_size () const BOOST_NOEXCEPT
 
iterator begin () BOOST_NOEXCEPT
 
const_iterator begin () const BOOST_NOEXCEPT
 
iterator end () BOOST_NOEXCEPT
 
const_iterator end () const BOOST_NOEXCEPT
 
const_iterator cbegin () const BOOST_NOEXCEPT
 
const_iterator cend () const BOOST_NOEXCEPT
 
template<class... Args>
iterator emplace (BOOST_FWD_REF(Args)...args)
 
template<class... Args>
iterator emplace_hint (const_iterator, BOOST_FWD_REF(Args)...args)
 
iterator insert (value_type const &x)
 
iterator insert (BOOST_UNORDERED_RV_REF(value_type) x)
 
iterator insert (const_iterator hint, value_type const &x)
 
iterator insert (const_iterator hint, BOOST_UNORDERED_RV_REF(value_type) x)
 
template<class InputIt >
void insert (InputIt, InputIt)
 
void insert (std::initializer_list< value_type >)
 
iterator erase (const_iterator)
 
size_type erase (const key_type &)
 
iterator erase (const_iterator, const_iterator)
 
void quick_erase (const_iterator it)
 
void erase_return_void (const_iterator it)
 
void clear ()
 
void swap (unordered_multiset &)
 
hasher hash_function () const
 
key_equal key_eq () const
 
const_iterator find (const key_type &) const
 
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
const_iterator find (CompatibleKey const &, CompatibleHash const &, CompatiblePredicate const &) const
 
size_type count (const key_type &) const
 
std::pair< const_iterator,
const_iterator
equal_range (const key_type &) const
 
size_type bucket_count () const BOOST_NOEXCEPT
 
size_type max_bucket_count () const BOOST_NOEXCEPT
 
size_type bucket_size (size_type) const
 
size_type bucket (const key_type &k) const
 
local_iterator begin (size_type n)
 
const_local_iterator begin (size_type n) const
 
local_iterator end (size_type)
 
const_local_iterator end (size_type) const
 
const_local_iterator cbegin (size_type n) const
 
const_local_iterator cend (size_type) const
 
float max_load_factor () const BOOST_NOEXCEPT
 
float load_factor () const BOOST_NOEXCEPT
 
void max_load_factor (float) BOOST_NOEXCEPT
 
void rehash (size_type)
 
void reserve (size_type)
 

Friends

bool operator== (unordered_multiset const &, unordered_multiset const &)
 
bool operator!= (unordered_multiset const &, unordered_multiset const &)
 

Member Typedef Documentation

template<class T, class H, class P, class A>
typedef A boost::unordered::unordered_multiset< T, H, P, A >::allocator_type
template<class T, class H, class P, class A>
typedef table::c_iterator boost::unordered::unordered_multiset< T, H, P, A >::const_iterator
template<class T, class H, class P, class A>
typedef table::cl_iterator boost::unordered::unordered_multiset< T, H, P, A >::const_local_iterator
template<class T, class H, class P, class A>
typedef allocator_traits::const_pointer boost::unordered::unordered_multiset< T, H, P, A >::const_pointer
template<class T, class H, class P, class A>
typedef value_type const& boost::unordered::unordered_multiset< T, H, P, A >::const_reference
template<class T, class H, class P, class A>
typedef std::ptrdiff_t boost::unordered::unordered_multiset< T, H, P, A >::difference_type
template<class T, class H, class P, class A>
typedef H boost::unordered::unordered_multiset< T, H, P, A >::hasher
template<class T, class H, class P, class A>
typedef table::c_iterator boost::unordered::unordered_multiset< T, H, P, A >::iterator
template<class T, class H, class P, class A>
typedef P boost::unordered::unordered_multiset< T, H, P, A >::key_equal
template<class T, class H, class P, class A>
typedef T boost::unordered::unordered_multiset< T, H, P, A >::key_type
template<class T, class H, class P, class A>
typedef table::cl_iterator boost::unordered::unordered_multiset< T, H, P, A >::local_iterator
template<class T, class H, class P, class A>
typedef allocator_traits::pointer boost::unordered::unordered_multiset< T, H, P, A >::pointer
template<class T, class H, class P, class A>
typedef value_type& boost::unordered::unordered_multiset< T, H, P, A >::reference
template<class T, class H, class P, class A>
typedef std::size_t boost::unordered::unordered_multiset< T, H, P, A >::size_type
template<class T, class H, class P, class A>
typedef T boost::unordered::unordered_multiset< T, H, P, A >::value_type

Constructor & Destructor Documentation

template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( size_type  n = boost::unordered::detail::default_bucket_count,
const hasher hf = hasher(),
const key_equal eql = key_equal(),
const allocator_type a = allocator_type() 
)
explicit
template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( allocator_type const &  a)
explicit
template<class T , class H , class P , class A >
template<class InputIt >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( InputIt  f,
InputIt  l 
)
template<class T , class H , class P , class A >
template<class InputIt >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( InputIt  f,
InputIt  l,
size_type  n,
const hasher hf = hasher(),
const key_equal eql = key_equal() 
)
template<class T , class H , class P , class A >
template<class InputIt >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( InputIt  f,
InputIt  l,
size_type  n,
const hasher hf,
const key_equal eql,
const allocator_type a 
)
template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( unordered_multiset< T, H, P, A > const &  other)
template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( unordered_multiset< T, H, P, A > const &  other,
allocator_type const &  a 
)
template<class T, class H, class P, class A>
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( unordered_multiset< T, H, P, A > &&  other)
inline
template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( unordered_multiset< T, H, P, A > &&  other,
allocator_type const &  a 
)
template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::unordered_multiset ( std::initializer_list< value_type list,
size_type  n = boost::unordered::detail::default_bucket_count,
const hasher hf = hasher(),
const key_equal l = key_equal(),
const allocator_type a = allocator_type() 
)
template<class T , class H , class P , class A >
boost::unordered::unordered_multiset< T, H, P, A >::~unordered_multiset ( )

Member Function Documentation

template<class T, class H, class P, class A>
iterator boost::unordered::unordered_multiset< T, H, P, A >::begin ( void  )
inline
template<class T, class H, class P, class A>
const_iterator boost::unordered::unordered_multiset< T, H, P, A >::begin ( void  ) const
inline
template<class T, class H, class P, class A>
local_iterator boost::unordered::unordered_multiset< T, H, P, A >::begin ( size_type  n)
inline

References boost::n.

template<class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_multiset< T, H, P, A >::begin ( size_type  n) const
inline

References boost::n.

template<class T, class H, class P, class A>
size_type boost::unordered::unordered_multiset< T, H, P, A >::bucket ( const key_type k) const
inline
template<class T, class H, class P, class A>
size_type boost::unordered::unordered_multiset< T, H, P, A >::bucket_count ( ) const
inline
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::size_type boost::unordered::unordered_multiset< T, H, P, A >::bucket_size ( size_type  n) const
template<class T, class H, class P, class A>
const_iterator boost::unordered::unordered_multiset< T, H, P, A >::cbegin ( ) const
inline
template<class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_multiset< T, H, P, A >::cbegin ( size_type  n) const
inline

References boost::n.

template<class T, class H, class P, class A>
const_iterator boost::unordered::unordered_multiset< T, H, P, A >::cend ( ) const
inline
template<class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_multiset< T, H, P, A >::cend ( size_type  ) const
inline
template<class T , class H , class P , class A >
void boost::unordered::unordered_multiset< T, H, P, A >::clear ( void  )
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::size_type boost::unordered::unordered_multiset< T, H, P, A >::count ( const key_type k) const
template<class T, class H, class P, class A>
template<class... Args>
iterator boost::unordered::unordered_multiset< T, H, P, A >::emplace ( BOOST_FWD_REF(Args)...  args)
inline
template<class T, class H, class P, class A>
template<class... Args>
iterator boost::unordered::unordered_multiset< T, H, P, A >::emplace_hint ( const_iterator  ,
BOOST_FWD_REF(Args)...  args 
)
inline
template<class T, class H, class P, class A>
bool boost::unordered::unordered_multiset< T, H, P, A >::empty ( void  ) const
inline
template<class T, class H, class P, class A>
iterator boost::unordered::unordered_multiset< T, H, P, A >::end ( void  )
inline
template<class T, class H, class P, class A>
const_iterator boost::unordered::unordered_multiset< T, H, P, A >::end ( void  ) const
inline
template<class T, class H, class P, class A>
local_iterator boost::unordered::unordered_multiset< T, H, P, A >::end ( size_type  )
inline
template<class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_multiset< T, H, P, A >::end ( size_type  ) const
inline
template<class T , class H , class P , class A >
std::pair< typename unordered_multiset< T, H, P, A >::const_iterator, typename unordered_multiset< T, H, P, A >::const_iterator > boost::unordered::unordered_multiset< T, H, P, A >::equal_range ( const key_type k) const
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::size_type boost::unordered::unordered_multiset< T, H, P, A >::erase ( const key_type k)
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::iterator boost::unordered::unordered_multiset< T, H, P, A >::erase ( const_iterator  first,
const_iterator  last 
)
template<class T, class H, class P, class A>
void boost::unordered::unordered_multiset< T, H, P, A >::erase_return_void ( const_iterator  it)
inline
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::const_iterator boost::unordered::unordered_multiset< T, H, P, A >::find ( const key_type k) const
template<class T , class H , class P , class A >
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
unordered_multiset< T, H, P, A >::const_iterator boost::unordered::unordered_multiset< T, H, P, A >::find ( CompatibleKey const &  k,
CompatibleHash const &  hash,
CompatiblePredicate const &  eq 
) const
template<class T, class H, class P, class A>
allocator_type boost::unordered::unordered_multiset< T, H, P, A >::get_allocator ( void  ) const
inline
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::hasher boost::unordered::unordered_multiset< T, H, P, A >::hash_function ( ) const
template<class T, class H, class P, class A>
iterator boost::unordered::unordered_multiset< T, H, P, A >::insert ( value_type const &  x)
inline
template<class T, class H, class P, class A>
iterator boost::unordered::unordered_multiset< T, H, P, A >::insert ( BOOST_UNORDERED_RV_REF(value_type x)
inline
template<class T, class H, class P, class A>
iterator boost::unordered::unordered_multiset< T, H, P, A >::insert ( const_iterator  hint,
value_type const &  x 
)
inline
template<class T, class H, class P, class A>
iterator boost::unordered::unordered_multiset< T, H, P, A >::insert ( const_iterator  hint,
BOOST_UNORDERED_RV_REF(value_type x 
)
inline
template<class T , class H , class P , class A >
template<class InputIt >
void boost::unordered::unordered_multiset< T, H, P, A >::insert ( InputIt  first,
InputIt  last 
)
template<class T , class H , class P , class A >
void boost::unordered::unordered_multiset< T, H, P, A >::insert ( std::initializer_list< value_type list)
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A >::key_equal boost::unordered::unordered_multiset< T, H, P, A >::key_eq ( ) const
template<class T , class H , class P , class A >
float boost::unordered::unordered_multiset< T, H, P, A >::load_factor ( ) const
template<class T, class H, class P, class A>
size_type boost::unordered::unordered_multiset< T, H, P, A >::max_bucket_count ( ) const
inline
template<class T, class H, class P, class A>
float boost::unordered::unordered_multiset< T, H, P, A >::max_load_factor ( ) const
inline
template<class T , class H , class P , class A >
void boost::unordered::unordered_multiset< T, H, P, A >::max_load_factor ( float  m)
template<class T , class H , class P , class A >
std::size_t boost::unordered::unordered_multiset< T, H, P, A >::max_size ( void  ) const
template<class T, class H, class P, class A>
unordered_multiset& boost::unordered::unordered_multiset< T, H, P, A >::operator= ( unordered_multiset< T, H, P, A > const &  x)
inline
template<class T, class H, class P, class A>
unordered_multiset& boost::unordered::unordered_multiset< T, H, P, A >::operator= ( unordered_multiset< T, H, P, A > &&  x)
inline
template<class T , class H , class P , class A >
unordered_multiset< T, H, P, A > & boost::unordered::unordered_multiset< T, H, P, A >::operator= ( std::initializer_list< value_type list)
template<class T, class H, class P, class A>
void boost::unordered::unordered_multiset< T, H, P, A >::quick_erase ( const_iterator  it)
inline
template<class T , class H , class P , class A >
void boost::unordered::unordered_multiset< T, H, P, A >::rehash ( size_type  n)
template<class T , class H , class P , class A >
void boost::unordered::unordered_multiset< T, H, P, A >::reserve ( size_type  n)
template<class T, class H, class P, class A>
size_type boost::unordered::unordered_multiset< T, H, P, A >::size ( void  ) const
inline
template<class T , class H , class P , class A >
void boost::unordered::unordered_multiset< T, H, P, A >::swap ( unordered_multiset< T, H, P, A > &  other)

Referenced by boost::unordered::swap().

Friends And Related Function Documentation

template<class T, class H, class P, class A>
bool operator!= ( unordered_multiset< T, H, P, A > const &  ,
unordered_multiset< T, H, P, A > const &   
)
friend
template<class T, class H, class P, class A>
bool operator== ( unordered_multiset< T, H, P, A > const &  ,
unordered_multiset< T, H, P, A > const &   
)
friend

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