Boost  v1.57.0
doxygen for www.boost.org
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
boost::interprocess::unordered_map_index< MapConfig > Singleton Reference

Index type based in unordered_map. More...

#include <interprocess_fwd.hpp>

Inheritance diagram for boost::interprocess::unordered_map_index< MapConfig >:
Collaboration diagram for boost::interprocess::unordered_map_index< MapConfig >:

Public Types

typedef K key_type
 
typedef std::pair< const K, Tvalue_type
 
typedef T mapped_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::l_iterator local_iterator
 
typedef table::c_iterator const_iterator
 
typedef table::iterator iterator
 

Public Member Functions

 unordered_map_index (segment_manager_base *segment_mngr)
 Constructor. More...
 
void reserve (typename segment_manager_base::size_type n)
 This reserves memory to optimize the insertion of n elements in the index. More...
 
void shrink_to_fit ()
 This tries to free previously allocate unused memory. More...
 
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
 
local_iterator begin (size_type n)
 
const_local_iterator begin (size_type n) const
 
iterator end () BOOST_NOEXCEPT
 
const_iterator end () const BOOST_NOEXCEPT
 
local_iterator end (size_type)
 
const_local_iterator end (size_type) const
 
const_iterator cbegin () const BOOST_NOEXCEPT
 
const_local_iterator cbegin (size_type n) const
 
const_iterator cend () const BOOST_NOEXCEPT
 
const_local_iterator cend (size_type) const
 
template<class... Args>
std::pair< iterator, bool > emplace (BOOST_FWD_REF(Args)...args)
 
template<class... Args>
iterator emplace_hint (const_iterator, BOOST_FWD_REF(Args)...args)
 
std::pair< iterator, bool > insert (value_type const &x)
 
std::pair< iterator, bool > insert (BOOST_RV_REF(value_type) x)
 
iterator insert (const_iterator hint, value_type const &x)
 
iterator insert (const_iterator hint, BOOST_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_map &)
 
hasher hash_function () const
 
key_equal key_eq () const
 
mapped_typeoperator[] (const key_type &)
 
mapped_typeat (const key_type &)
 
mapped_type const & at (const key_type &) const
 
iterator find (const key_type &)
 
const_iterator find (const key_type &) const
 
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
iterator find (CompatibleKey const &, CompatibleHash const &, CompatiblePredicate 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< iterator, iteratorequal_range (const key_type &)
 
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
 
float max_load_factor () const BOOST_NOEXCEPT
 
void max_load_factor (float) BOOST_NOEXCEPT
 
float load_factor () const BOOST_NOEXCEPT
 
void rehash (size_type)
 
void reserve (size_type)
 

Detailed Description

template<class MapConfig>
singleton boost::interprocess::unordered_map_index< MapConfig >

Index type based in unordered_map.

Just derives from unordered_map and defines the interface needed by managed memory segments

Member Typedef Documentation

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

Constructor & Destructor Documentation

template<class MapConfig >
boost::interprocess::unordered_map_index< MapConfig >::unordered_map_index ( segment_manager_base *  segment_mngr)
inline

Constructor.

Takes a pointer to the segment manager. Can throw

Member Function Documentation

template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::mapped_type & boost::unordered::unordered_map< K, T, H, P, A >::at ( const key_type k)
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::mapped_type const & boost::unordered::unordered_map< K, T, H, P, A >::at ( const key_type k) const
inherited
template<class K, class T, class H, class P, class A>
iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( void  )
inlineinherited
template<class K, class T, class H, class P, class A>
const_iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( void  ) const
inlineinherited
template<class K, class T, class H, class P, class A>
local_iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( size_type  n)
inlineinherited
template<class K, class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::begin ( size_type  n) const
inlineinherited
template<class K, class T, class H, class P, class A>
size_type boost::unordered::unordered_map< K, T, H, P, A >::bucket ( const key_type k) const
inlineinherited
template<class K, class T, class H, class P, class A>
size_type boost::unordered::unordered_map< K, T, H, P, A >::bucket_count ( ) const
inlineinherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::size_type boost::unordered::unordered_map< K, T, H, P, A >::bucket_size ( size_type  n) const
inherited
template<class K, class T, class H, class P, class A>
const_iterator boost::unordered::unordered_map< K, T, H, P, A >::cbegin ( ) const
inlineinherited
template<class K, class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::cbegin ( size_type  n) const
inlineinherited
template<class K, class T, class H, class P, class A>
const_iterator boost::unordered::unordered_map< K, T, H, P, A >::cend ( ) const
inlineinherited
template<class K, class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::cend ( size_type  ) const
inlineinherited
template<class K , class T , class H , class P , class A >
void boost::unordered::unordered_map< K, T, H, P, A >::clear ( void  )
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::size_type boost::unordered::unordered_map< K, T, H, P, A >::count ( const key_type k) const
inherited
template<class K, class T, class H, class P, class A>
template<class... Args>
std::pair<iterator, bool> boost::unordered::unordered_map< K, T, H, P, A >::emplace ( BOOST_FWD_REF(Args)...  args)
inlineinherited
template<class K, class T, class H, class P, class A>
template<class... Args>
iterator boost::unordered::unordered_map< K, T, H, P, A >::emplace_hint ( const_iterator  ,
BOOST_FWD_REF(Args)...  args 
)
inlineinherited
template<class K, class T, class H, class P, class A>
bool boost::unordered::unordered_map< K, T, H, P, A >::empty ( void  ) const
inlineinherited
template<class K, class T, class H, class P, class A>
const_iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( void  ) const
inlineinherited
template<class K, class T, class H, class P, class A>
local_iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( size_type  )
inlineinherited
template<class K, class T, class H, class P, class A>
const_local_iterator boost::unordered::unordered_map< K, T, H, P, A >::end ( size_type  ) const
inlineinherited
template<class K , class T , class H , class P , class A >
std::pair< typename unordered_map< K, T, H, P, A >::iterator, typename unordered_map< K, T, H, P, A >::iterator > boost::unordered::unordered_map< K, T, H, P, A >::equal_range ( const key_type k)
inherited
template<class K , class T , class H , class P , class A >
std::pair< typename unordered_map< K, T, H, P, A >::const_iterator, typename unordered_map< K, T, H, P, A >::const_iterator > boost::unordered::unordered_map< K, T, H, P, A >::equal_range ( const key_type k) const
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::size_type boost::unordered::unordered_map< K, T, H, P, A >::erase ( const key_type k)
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::erase ( const_iterator  first,
const_iterator  last 
)
inherited
template<class K, class T, class H, class P, class A>
void boost::unordered::unordered_map< K, T, H, P, A >::erase_return_void ( const_iterator  it)
inlineinherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::find ( const key_type k)
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::const_iterator boost::unordered::unordered_map< K, T, H, P, A >::find ( const key_type k) const
inherited
template<class K , class T , class H , class P , class A >
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
unordered_map< K, T, H, P, A >::iterator boost::unordered::unordered_map< K, T, H, P, A >::find ( CompatibleKey const &  k,
CompatibleHash const &  hash,
CompatiblePredicate const &  eq 
)
inherited
template<class K , class T , class H , class P , class A >
template<class CompatibleKey , class CompatibleHash , class CompatiblePredicate >
unordered_map< K, T, H, P, A >::const_iterator boost::unordered::unordered_map< K, T, H, P, A >::find ( CompatibleKey const &  k,
CompatibleHash const &  hash,
CompatiblePredicate const &  eq 
) const
inherited
template<class K, class T, class H, class P, class A>
allocator_type boost::unordered::unordered_map< K, T, H, P, A >::get_allocator ( void  ) const
inlineinherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::hasher boost::unordered::unordered_map< K, T, H, P, A >::hash_function ( ) const
inherited
template<class K, class T, class H, class P, class A>
std::pair<iterator, bool> boost::unordered::unordered_map< K, T, H, P, A >::insert ( value_type const &  x)
inlineinherited
template<class K, class T, class H, class P, class A>
std::pair<iterator, bool> boost::unordered::unordered_map< K, T, H, P, A >::insert ( BOOST_RV_REF(value_type x)
inlineinherited
template<class K, class T, class H, class P, class A>
iterator boost::unordered::unordered_map< K, T, H, P, A >::insert ( const_iterator  hint,
value_type const &  x 
)
inlineinherited
template<class K, class T, class H, class P, class A>
iterator boost::unordered::unordered_map< K, T, H, P, A >::insert ( const_iterator  hint,
BOOST_RV_REF(value_type x 
)
inlineinherited
template<class K , class T , class H , class P , class A >
template<class InputIt >
void boost::unordered::unordered_map< K, T, H, P, A >::insert ( InputIt  first,
InputIt  last 
)
inherited
template<class K , class T , class H , class P , class A >
void boost::unordered::unordered_map< K, T, H, P, A >::insert ( std::initializer_list< value_type list)
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::key_equal boost::unordered::unordered_map< K, T, H, P, A >::key_eq ( ) const
inherited
template<class K , class T , class H , class P , class A >
float boost::unordered::unordered_map< K, T, H, P, A >::load_factor ( ) const
inherited
template<class K, class T, class H, class P, class A>
size_type boost::unordered::unordered_map< K, T, H, P, A >::max_bucket_count ( ) const
inlineinherited
template<class K, class T, class H, class P, class A>
float boost::unordered::unordered_map< K, T, H, P, A >::max_load_factor ( ) const
inlineinherited
template<class K , class T , class H , class P , class A >
void boost::unordered::unordered_map< K, T, H, P, A >::max_load_factor ( float  m)
inherited
template<class K , class T , class H , class P , class A >
std::size_t boost::unordered::unordered_map< K, T, H, P, A >::max_size ( void  ) const
inherited
template<class K , class T , class H , class P , class A >
unordered_map< K, T, H, P, A >::mapped_type & boost::unordered::unordered_map< K, T, H, P, A >::operator[] ( const key_type k)
inherited
template<class K, class T, class H, class P, class A>
void boost::unordered::unordered_map< K, T, H, P, A >::quick_erase ( const_iterator  it)
inlineinherited
template<class K , class T , class H , class P , class A >
void boost::unordered::unordered_map< K, T, H, P, A >::rehash ( size_type  n)
inherited
template<class MapConfig >
void boost::interprocess::unordered_map_index< MapConfig >::reserve ( typename segment_manager_base::size_type  n)
inline

This reserves memory to optimize the insertion of n elements in the index.

References boost::unordered::unordered_map< K, T, H, P, A >::rehash().

template<class K , class T , class H , class P , class A >
void boost::unordered::unordered_map< K, T, H, P, A >::reserve ( size_type  n)
inherited
template<class MapConfig >
void boost::interprocess::unordered_map_index< MapConfig >::shrink_to_fit ( )
inline
template<class K, class T, class H, class P, class A>
size_type boost::unordered::unordered_map< K, T, H, P, A >::size ( void  ) const
inlineinherited
template<class K , class T , class H , class P , class A >
void boost::unordered::unordered_map< K, T, H, P, A >::swap ( unordered_map< K, T, H, P, A > &  other)
inherited

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


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