384 lines
17 KiB
C++
384 lines
17 KiB
C++
|
/*
|
||
|
|
template <class Value, unsigned int Options = 0, class Hash = hash<Value>, class Pred = equal_to<Value>,
|
||
|
|
class Allocator = allocator<Value> >
|
||
|
|
class hash_set
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
// types
|
||
|
|
typedef Value key_type;
|
||
|
|
typedef key_type value_type;
|
||
|
|
typedef Hash hasher;
|
||
|
|
typedef Pred key_equal;
|
||
|
|
typedef Allocator allocator_type;
|
||
|
|
typedef value_type& reference;
|
||
|
|
typedef const value_type& const_reference;
|
||
|
|
typedef typename allocator_traits<allocator_type>::pointer pointer;
|
||
|
|
typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
|
||
|
|
typedef typename allocator_traits<allocator_type>::size_type size_type;
|
||
|
|
typedef typename allocator_traits<allocator_type>::difference_type difference_type;
|
||
|
|
|
||
|
|
typedef /unspecified/ iterator;
|
||
|
|
typedef /unspecified/ const_iterator;
|
||
|
|
typedef /unspecified/ local_iterator;
|
||
|
|
typedef /unspecified/ const_local_iterator;
|
||
|
|
|
||
|
|
hash_set()
|
||
|
|
noexcept(
|
||
|
|
is_nothrow_default_constructible<hasher>::value &&
|
||
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
||
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
||
|
|
explicit hash_set(size_type n, const hasher& hf = hasher(),
|
||
|
|
const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
template <class InputIterator>
|
||
|
|
hash_set(InputIterator f, InputIterator l,
|
||
|
|
size_type n = 0, const hasher& hf = hasher(),
|
||
|
|
const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
explicit hash_set(const allocator_type&);
|
||
|
|
hash_set(const hash_set&);
|
||
|
|
hash_set(const hash_set&, const Allocator&);
|
||
|
|
hash_set(hash_set&&)
|
||
|
|
noexcept(
|
||
|
|
is_nothrow_move_constructible<hasher>::value &&
|
||
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
||
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
||
|
|
hash_set(hash_set&&, const Allocator&);
|
||
|
|
hash_set(initializer_list<value_type>, size_type n = 0,
|
||
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
~hash_set();
|
||
|
|
hash_set& operator=(const hash_set&);
|
||
|
|
hash_set& operator=(hash_set&&)
|
||
|
|
noexcept(
|
||
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
||
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
||
|
|
is_nothrow_move_assignable<hasher>::value &&
|
||
|
|
is_nothrow_move_assignable<key_equal>::value);
|
||
|
|
hash_set& operator=(initializer_list<value_type>);
|
||
|
|
|
||
|
|
allocator_type get_allocator() const noexcept;
|
||
|
|
|
||
|
|
bool empty() const noexcept;
|
||
|
|
size_type size() const noexcept;
|
||
|
|
size_type max_size() const noexcept;
|
||
|
|
|
||
|
|
iterator begin() noexcept;
|
||
|
|
iterator end() noexcept;
|
||
|
|
const_iterator begin() const noexcept;
|
||
|
|
const_iterator end() const noexcept;
|
||
|
|
const_iterator cbegin() const noexcept;
|
||
|
|
const_iterator cend() const noexcept;
|
||
|
|
|
||
|
|
template <class... Args>
|
||
|
|
pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args);
|
||
|
|
template <class... Args>
|
||
|
|
iterator emplace_hint(const_iterator position, BOOST_FWD_REF(Args)... args);
|
||
|
|
pair<iterator, bool> insert(const value_type& obj);
|
||
|
|
pair<iterator, bool> insert(value_type&& obj);
|
||
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
||
|
|
iterator insert(const_iterator hint, value_type&& obj);
|
||
|
|
template <class InputIterator>
|
||
|
|
void insert(InputIterator first, InputIterator last);
|
||
|
|
void insert(initializer_list<value_type>);
|
||
|
|
|
||
|
|
iterator erase(const_iterator position);
|
||
|
|
size_type erase(const key_type& k);
|
||
|
|
iterator erase(const_iterator first, const_iterator last);
|
||
|
|
void clear() noexcept;
|
||
|
|
|
||
|
|
void swap(hash_set&)
|
||
|
|
noexcept(
|
||
|
|
(!allocator_type::propagate_on_container_swap::value ||
|
||
|
|
__is_nothrow_swappable<allocator_type>::value) &&
|
||
|
|
__is_nothrow_swappable<hasher>::value &&
|
||
|
|
__is_nothrow_swappable<key_equal>::value);
|
||
|
|
|
||
|
|
hasher hash_function() const;
|
||
|
|
key_equal key_eq() const;
|
||
|
|
|
||
|
|
iterator find(const key_type& k);
|
||
|
|
const_iterator find(const key_type& k) const;
|
||
|
|
size_type count(const key_type& k) const;
|
||
|
|
pair<iterator, iterator> equal_range(const key_type& k);
|
||
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
|
||
|
|
|
||
|
|
size_type bucket_count() const noexcept;
|
||
|
|
size_type max_bucket_count() const noexcept;
|
||
|
|
|
||
|
|
size_type bucket_size(size_type n) const;
|
||
|
|
size_type bucket(const key_type& k) const;
|
||
|
|
|
||
|
|
local_iterator begin(size_type n);
|
||
|
|
local_iterator end(size_type n);
|
||
|
|
const_local_iterator begin(size_type n) const;
|
||
|
|
const_local_iterator end(size_type n) const;
|
||
|
|
const_local_iterator cbegin(size_type n) const;
|
||
|
|
const_local_iterator cend(size_type n) const;
|
||
|
|
|
||
|
|
float load_factor() const noexcept;
|
||
|
|
float max_load_factor() const noexcept;
|
||
|
|
void max_load_factor(float z);
|
||
|
|
void rehash(size_type n);
|
||
|
|
void reserve(size_type n);
|
||
|
|
};
|
||
|
|
|
||
|
|
template <class Key, class T, unsigned int Options = 0, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||
|
|
class Allocator = allocator<pair<const Key, T> > >
|
||
|
|
class hash_map
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
// types
|
||
|
|
typedef Key key_type;
|
||
|
|
typedef T mapped_type;
|
||
|
|
typedef Hash hasher;
|
||
|
|
typedef Pred key_equal;
|
||
|
|
typedef Allocator allocator_type;
|
||
|
|
typedef pair<const key_type, mapped_type> value_type;
|
||
|
|
typedef value_type& reference;
|
||
|
|
typedef const value_type& const_reference;
|
||
|
|
typedef typename allocator_traits<allocator_type>::pointer pointer;
|
||
|
|
typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
|
||
|
|
typedef typename allocator_traits<allocator_type>::size_type size_type;
|
||
|
|
typedef typename allocator_traits<allocator_type>::difference_type difference_type;
|
||
|
|
|
||
|
|
typedef /unspecified/ iterator;
|
||
|
|
typedef /unspecified/ const_iterator;
|
||
|
|
typedef /unspecified/ local_iterator;
|
||
|
|
typedef /unspecified/ const_local_iterator;
|
||
|
|
|
||
|
|
hash_map()
|
||
|
|
noexcept(
|
||
|
|
is_nothrow_default_constructible<hasher>::value &&
|
||
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
||
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
||
|
|
explicit hash_map(size_type n, const hasher& hf = hasher(),
|
||
|
|
const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
template <class InputIterator>
|
||
|
|
hash_map(InputIterator f, InputIterator l,
|
||
|
|
size_type n = 0, const hasher& hf = hasher(),
|
||
|
|
const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
explicit hash_map(const allocator_type&);
|
||
|
|
hash_map(const hash_map&);
|
||
|
|
hash_map(const hash_map&, const Allocator&);
|
||
|
|
hash_map(hash_map&&)
|
||
|
|
noexcept(
|
||
|
|
is_nothrow_move_constructible<hasher>::value &&
|
||
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
||
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
||
|
|
hash_map(hash_map&&, const Allocator&);
|
||
|
|
hash_map(initializer_list<value_type>, size_type n = 0,
|
||
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
~hash_map();
|
||
|
|
hash_map& operator=(const hash_map&);
|
||
|
|
hash_map& operator=(hash_map&&)
|
||
|
|
noexcept(
|
||
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
||
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
||
|
|
is_nothrow_move_assignable<hasher>::value &&
|
||
|
|
is_nothrow_move_assignable<key_equal>::value);
|
||
|
|
hash_map& operator=(initializer_list<value_type>);
|
||
|
|
|
||
|
|
allocator_type get_allocator() const noexcept;
|
||
|
|
|
||
|
|
bool empty() const noexcept;
|
||
|
|
size_type size() const noexcept;
|
||
|
|
size_type max_size() const noexcept;
|
||
|
|
|
||
|
|
iterator begin() noexcept;
|
||
|
|
iterator end() noexcept;
|
||
|
|
const_iterator begin() const noexcept;
|
||
|
|
const_iterator end() const noexcept;
|
||
|
|
const_iterator cbegin() const noexcept;
|
||
|
|
const_iterator cend() const noexcept;
|
||
|
|
|
||
|
|
template <class... Args>
|
||
|
|
pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args);
|
||
|
|
template <class... Args>
|
||
|
|
iterator emplace_hint(const_iterator position, BOOST_FWD_REF(Args)... args);
|
||
|
|
pair<iterator, bool> insert(const value_type& obj);
|
||
|
|
template <class P>
|
||
|
|
pair<iterator, bool> insert(P&& obj);
|
||
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
||
|
|
template <class P>
|
||
|
|
iterator insert(const_iterator hint, P&& obj);
|
||
|
|
template <class InputIterator>
|
||
|
|
void insert(InputIterator first, InputIterator last);
|
||
|
|
void insert(initializer_list<value_type>);
|
||
|
|
|
||
|
|
iterator erase(const_iterator position);
|
||
|
|
size_type erase(const key_type& k);
|
||
|
|
iterator erase(const_iterator first, const_iterator last);
|
||
|
|
void clear() noexcept;
|
||
|
|
|
||
|
|
void swap(hash_map&)
|
||
|
|
noexcept(
|
||
|
|
(!allocator_type::propagate_on_container_swap::value ||
|
||
|
|
__is_nothrow_swappable<allocator_type>::value) &&
|
||
|
|
__is_nothrow_swappable<hasher>::value &&
|
||
|
|
__is_nothrow_swappable<key_equal>::value);
|
||
|
|
|
||
|
|
hasher hash_function() const;
|
||
|
|
key_equal key_eq() const;
|
||
|
|
|
||
|
|
iterator find(const key_type& k);
|
||
|
|
const_iterator find(const key_type& k) const;
|
||
|
|
size_type count(const key_type& k) const;
|
||
|
|
pair<iterator, iterator> equal_range(const key_type& k);
|
||
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
|
||
|
|
|
||
|
|
mapped_type& operator[](const key_type& k);
|
||
|
|
mapped_type& operator[](key_type&& k);
|
||
|
|
|
||
|
|
mapped_type& at(const key_type& k);
|
||
|
|
const mapped_type& at(const key_type& k) const;
|
||
|
|
|
||
|
|
size_type bucket_count() const noexcept;
|
||
|
|
size_type max_bucket_count() const noexcept;
|
||
|
|
|
||
|
|
size_type bucket_size(size_type n) const;
|
||
|
|
size_type bucket(const key_type& k) const;
|
||
|
|
|
||
|
|
local_iterator begin(size_type n);
|
||
|
|
local_iterator end(size_type n);
|
||
|
|
const_local_iterator begin(size_type n) const;
|
||
|
|
const_local_iterator end(size_type n) const;
|
||
|
|
const_local_iterator cbegin(size_type n) const;
|
||
|
|
const_local_iterator cend(size_type n) const;
|
||
|
|
|
||
|
|
float load_factor() const noexcept;
|
||
|
|
float max_load_factor() const noexcept;
|
||
|
|
void max_load_factor(float z);
|
||
|
|
void rehash(size_type n);
|
||
|
|
void reserve(size_type n);
|
||
|
|
};
|
||
|
|
|
||
|
|
*/
|
||
|
|
|
||
|
|
template <class Key, class Value, class KeyOfValue, unsigned int Options = 0, class Hash = hash<Key>, class Pred = equal_to<Key>,
|
||
|
|
class Allocator = allocator<Value> >
|
||
|
|
class hash_table
|
||
|
|
{
|
||
|
|
public:
|
||
|
|
// types
|
||
|
|
typedef Value key_type;
|
||
|
|
typedef key_type value_type;
|
||
|
|
typedef Hash hasher;
|
||
|
|
typedef Pred key_equal;
|
||
|
|
typedef Allocator allocator_type;
|
||
|
|
typedef value_type& reference;
|
||
|
|
typedef const value_type& const_reference;
|
||
|
|
typedef typename allocator_traits<allocator_type>::pointer pointer;
|
||
|
|
typedef typename allocator_traits<allocator_type>::const_pointer const_pointer;
|
||
|
|
typedef typename allocator_traits<allocator_type>::size_type size_type;
|
||
|
|
typedef typename allocator_traits<allocator_type>::difference_type difference_type;
|
||
|
|
|
||
|
|
typedef /unspecified/ iterator;
|
||
|
|
typedef /unspecified/ const_iterator;
|
||
|
|
typedef /unspecified/ local_iterator;
|
||
|
|
typedef /unspecified/ const_local_iterator;
|
||
|
|
|
||
|
|
hash_set()
|
||
|
|
noexcept(
|
||
|
|
is_nothrow_default_constructible<hasher>::value &&
|
||
|
|
is_nothrow_default_constructible<key_equal>::value &&
|
||
|
|
is_nothrow_default_constructible<allocator_type>::value);
|
||
|
|
explicit hash_set(size_type n, const hasher& hf = hasher(),
|
||
|
|
const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
template <class InputIterator>
|
||
|
|
hash_set(InputIterator f, InputIterator l,
|
||
|
|
size_type n = 0, const hasher& hf = hasher(),
|
||
|
|
const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
explicit hash_set(const allocator_type&);
|
||
|
|
hash_set(const hash_set&);
|
||
|
|
hash_set(const hash_set&, const Allocator&);
|
||
|
|
hash_set(hash_set&&)
|
||
|
|
noexcept(
|
||
|
|
is_nothrow_move_constructible<hasher>::value &&
|
||
|
|
is_nothrow_move_constructible<key_equal>::value &&
|
||
|
|
is_nothrow_move_constructible<allocator_type>::value);
|
||
|
|
hash_set(hash_set&&, const Allocator&);
|
||
|
|
hash_set(initializer_list<value_type>, size_type n = 0,
|
||
|
|
const hasher& hf = hasher(), const key_equal& eql = key_equal(),
|
||
|
|
const allocator_type& a = allocator_type());
|
||
|
|
~hash_set();
|
||
|
|
hash_set& operator=(const hash_set&);
|
||
|
|
hash_set& operator=(hash_set&&)
|
||
|
|
noexcept(
|
||
|
|
allocator_type::propagate_on_container_move_assignment::value &&
|
||
|
|
is_nothrow_move_assignable<allocator_type>::value &&
|
||
|
|
is_nothrow_move_assignable<hasher>::value &&
|
||
|
|
is_nothrow_move_assignable<key_equal>::value);
|
||
|
|
hash_set& operator=(initializer_list<value_type>);
|
||
|
|
|
||
|
|
allocator_type get_allocator() const noexcept;
|
||
|
|
|
||
|
|
bool empty() const noexcept;
|
||
|
|
size_type size() const noexcept;
|
||
|
|
size_type max_size() const noexcept;
|
||
|
|
|
||
|
|
iterator begin() noexcept;
|
||
|
|
iterator end() noexcept;
|
||
|
|
const_iterator begin() const noexcept;
|
||
|
|
const_iterator end() const noexcept;
|
||
|
|
const_iterator cbegin() const noexcept;
|
||
|
|
const_iterator cend() const noexcept;
|
||
|
|
|
||
|
|
template <class... Args>
|
||
|
|
pair<iterator, bool> emplace(BOOST_FWD_REF(Args)... args);
|
||
|
|
template <class... Args>
|
||
|
|
iterator emplace_hint(const_iterator position, BOOST_FWD_REF(Args)... args);
|
||
|
|
pair<iterator, bool> insert(const value_type& obj);
|
||
|
|
pair<iterator, bool> insert(value_type&& obj);
|
||
|
|
iterator insert(const_iterator hint, const value_type& obj);
|
||
|
|
iterator insert(const_iterator hint, value_type&& obj);
|
||
|
|
template <class InputIterator>
|
||
|
|
void insert(InputIterator first, InputIterator last);
|
||
|
|
void insert(initializer_list<value_type>);
|
||
|
|
|
||
|
|
iterator erase(const_iterator position);
|
||
|
|
size_type erase(const key_type& k);
|
||
|
|
iterator erase(const_iterator first, const_iterator last);
|
||
|
|
void clear() noexcept;
|
||
|
|
|
||
|
|
void swap(hash_set&)
|
||
|
|
noexcept(
|
||
|
|
(!allocator_type::propagate_on_container_swap::value ||
|
||
|
|
__is_nothrow_swappable<allocator_type>::value) &&
|
||
|
|
__is_nothrow_swappable<hasher>::value &&
|
||
|
|
__is_nothrow_swappable<key_equal>::value);
|
||
|
|
|
||
|
|
hasher hash_function() const;
|
||
|
|
key_equal key_eq() const;
|
||
|
|
|
||
|
|
iterator find(const key_type& k);
|
||
|
|
const_iterator find(const key_type& k) const;
|
||
|
|
size_type count(const key_type& k) const;
|
||
|
|
pair<iterator, iterator> equal_range(const key_type& k);
|
||
|
|
pair<const_iterator, const_iterator> equal_range(const key_type& k) const;
|
||
|
|
|
||
|
|
size_type bucket_count() const noexcept;
|
||
|
|
size_type max_bucket_count() const noexcept;
|
||
|
|
|
||
|
|
size_type bucket_size(size_type n) const;
|
||
|
|
size_type bucket(const key_type& k) const;
|
||
|
|
|
||
|
|
local_iterator begin(size_type n);
|
||
|
|
local_iterator end(size_type n);
|
||
|
|
const_local_iterator begin(size_type n) const;
|
||
|
|
const_local_iterator end(size_type n) const;
|
||
|
|
const_local_iterator cbegin(size_type n) const;
|
||
|
|
const_local_iterator cend(size_type n) const;
|
||
|
|
|
||
|
|
float load_factor() const noexcept;
|
||
|
|
float max_load_factor() const noexcept;
|
||
|
|
void max_load_factor(float z);
|
||
|
|
void rehash(size_type n);
|
||
|
|
void reserve(size_type n);
|
||
|
|
};
|