chunkedseq
container library for large in-memory data sets
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Modules Pages
Public Types | Public Member Functions | List of all members
pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity > Class Template Reference

[swap] More...

#include <map.hpp>

Public Types

using key_type = Key
 
using mapped_type = Item
 
using value_type = std::pair< key_type, mapped_type >
 
using key_compare = Compare
 
using allocator_type = Alloc
 
using reference = value_type &
 
using const_reference = const value_type &
 
using pointer = value_type *
 
using const_pointer = const value_type *
 
using difference_type = ptrdiff_t
 
using size_type = size_t
 
using key_swap_type = Key_swap
 
using iterator = typename container_type::iterator
 

Public Member Functions

 map ()
 
 map (const map &other)
 
size_type size () const
 
bool empty () const
 
iterator find (const key_type &k) const
 
mapped_type & operator[] (const key_type &k) const
 
void erase (iterator it)
 
size_type erase (const key_type &k)
 
std::ostream & stream (std::ostream &out) const
 
iterator begin () const
 
iterator end () const
 
void check () const
 

Detailed Description

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
class pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >

[map]

Examples:
map_1.cpp.

Definition at line 171 of file map.hpp.

Member Typedef Documentation

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::allocator_type = Alloc

Definition at line 178 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::const_pointer = const value_type*

Definition at line 182 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::const_reference = const value_type&

Definition at line 180 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::difference_type = ptrdiff_t

Definition at line 183 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::iterator = typename container_type::iterator

Definition at line 195 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::key_compare = Compare

Definition at line 177 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::key_swap_type = Key_swap

Definition at line 185 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::key_type = Key

Definition at line 174 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::mapped_type = Item

Definition at line 175 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::pointer = value_type*

Definition at line 181 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::reference = value_type&

Definition at line 179 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::size_type = size_t

Definition at line 184 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
using pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::value_type = std::pair<key_type, mapped_type>

Definition at line 176 of file map.hpp.

Constructor & Destructor Documentation

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::map ( )
inline

Definition at line 213 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::map ( const map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity > &  other)
inline

Definition at line 217 of file map.hpp.

Member Function Documentation

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
iterator pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::begin ( ) const
inline

Definition at line 279 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
void pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::check ( ) const
inline

Definition at line 287 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
bool pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::empty ( ) const
inline

Definition at line 226 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
iterator pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::end ( ) const
inline

Definition at line 283 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
void pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::erase ( iterator  it)
inline

Definition at line 252 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
size_type pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::erase ( const key_type &  k)
inline

Definition at line 262 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
iterator pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::find ( const key_type &  k) const
inline

Definition at line 230 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
mapped_type& pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::operator[] ( const key_type &  k) const
inline

Definition at line 235 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
size_type pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::size ( ) const
inline

Definition at line 222 of file map.hpp.

template<class Key, class Item, class Compare = std::less<Key>, class Key_swap = std_swap<Key>, class Alloc = std::allocator<std::pair<const Key, Item> >, int chunk_capacity = 8>
std::ostream& pasl::data::map::map< Key, Item, Compare, Key_swap, Alloc, chunk_capacity >::stream ( std::ostream &  out) const
inline

Definition at line 268 of file map.hpp.

The documentation for this class was generated from the following file:
Generated on Mon Mar 9 2015 22:07:09 for chunkedseq by   doxygen 1.8.8