diff options
Diffstat (limited to 'tests/libcxx/include/unordered_set')
| -rw-r--r-- | tests/libcxx/include/unordered_set | 1046 |
1 files changed, 0 insertions, 1046 deletions
diff --git a/tests/libcxx/include/unordered_set b/tests/libcxx/include/unordered_set deleted file mode 100644 index e50e0b6f..00000000 --- a/tests/libcxx/include/unordered_set +++ /dev/null @@ -1,1046 +0,0 @@ -// -*- C++ -*- -//===-------------------------- unordered_set -----------------------------===// -// -// The LLVM Compiler Infrastructure -// -// This file is dual licensed under the MIT and the University of Illinois Open -// Source Licenses. See LICENSE.TXT for details. -// -//===----------------------------------------------------------------------===// - -#ifndef _LIBCPP_UNORDERED_SET -#define _LIBCPP_UNORDERED_SET - -/* - - unordered_set synopsis - -#include <initializer_list> - -namespace std -{ - -template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, - class Alloc = allocator<Value>> -class unordered_set -{ -public: - // types - typedef Value key_type; - typedef key_type value_type; - typedef Hash hasher; - typedef Pred key_equal; - typedef Alloc 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; - - explicit unordered_set(size_type n = 0, const hasher& hf = hasher(), - const key_equal& eql = key_equal(), - const allocator_type& a = allocator_type()); - template <class InputIterator> - unordered_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 unordered_set(const allocator_type&); - unordered_set(const unordered_set&); - unordered_set(const unordered_set&, const Allocator&); - unordered_set(unordered_set&&); - unordered_set(unordered_set&&, const Allocator&); - unordered_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()); - ~unordered_set(); - unordered_set& operator=(const unordered_set&); - unordered_set& operator=(unordered_set&&); - unordered_set& operator=(initializer_list<value_type>); - - allocator_type get_allocator() const; - - bool empty() const; - size_type size() const; - size_type max_size() const; - - iterator begin(); - iterator end(); - const_iterator begin() const; - const_iterator end() const; - const_iterator cbegin() const; - const_iterator cend() const; - - template <class... Args> - pair<iterator, bool> emplace(Args&&... args); - template <class... Args> - iterator emplace_hint(const_iterator position, 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(); - - void swap(unordered_set&); - - 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; - size_type max_bucket_count() const; - - 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; - float max_load_factor() const; - void max_load_factor(float z); - void rehash(size_type n); - void reserve(size_type n); -}; - -template <class Value, class Hash, class Pred, class Alloc> - void swap(unordered_set<Value, Hash, Pred, Alloc>& x, - unordered_set<Value, Hash, Pred, Alloc>& y); - -template <class Value, class Hash, class Pred, class Alloc> - bool - operator==(const unordered_set<Value, Hash, Pred, Alloc>& x, - const unordered_set<Value, Hash, Pred, Alloc>& y); - -template <class Value, class Hash, class Pred, class Alloc> - bool - operator!=(const unordered_set<Value, Hash, Pred, Alloc>& x, - const unordered_set<Value, Hash, Pred, Alloc>& y); - -template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, - class Alloc = allocator<Value>> -class unordered_multiset -{ -public: - // types - typedef Value key_type; - typedef key_type value_type; - typedef Hash hasher; - typedef Pred key_equal; - typedef Alloc 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; - - explicit unordered_multiset(size_type n = 0, const hasher& hf = hasher(), - const key_equal& eql = key_equal(), - const allocator_type& a = allocator_type()); - template <class InputIterator> - unordered_multiset(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 unordered_multiset(const allocator_type&); - unordered_multiset(const unordered_multiset&); - unordered_multiset(const unordered_multiset&, const Allocator&); - unordered_multiset(unordered_multiset&&); - unordered_multiset(unordered_multiset&&, const Allocator&); - unordered_multiset(initializer_list<value_type>, size_type n = /see below/, - const hasher& hf = hasher(), const key_equal& eql = key_equal(), - const allocator_type& a = allocator_type()); - ~unordered_multiset(); - unordered_multiset& operator=(const unordered_multiset&); - unordered_multiset& operator=(unordered_multiset&&); - unordered_multiset& operator=(initializer_list<value_type>); - - allocator_type get_allocator() const; - - bool empty() const; - size_type size() const; - size_type max_size() const; - - iterator begin(); - iterator end(); - const_iterator begin() const; - const_iterator end() const; - const_iterator cbegin() const; - const_iterator cend() const; - - template <class... Args> - iterator emplace(Args&&... args); - template <class... Args> - iterator emplace_hint(const_iterator position, Args&&... args); - iterator insert(const value_type& obj); - iterator 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(); - - void swap(unordered_multiset&); - - 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; - size_type max_bucket_count() const; - - 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; - float max_load_factor() const; - void max_load_factor(float z); - void rehash(size_type n); - void reserve(size_type n); -}; - -template <class Value, class Hash, class Pred, class Alloc> - void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x, - unordered_multiset<Value, Hash, Pred, Alloc>& y); - -template <class Value, class Hash, class Pred, class Alloc> - bool - operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x, - const unordered_multiset<Value, Hash, Pred, Alloc>& y); - -template <class Value, class Hash, class Pred, class Alloc> - bool - operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x, - const unordered_multiset<Value, Hash, Pred, Alloc>& y); -} // std - -*/ - -#include <__config> -#include <__hash_table> -#include <functional> - -#pragma GCC system_header - -_LIBCPP_BEGIN_NAMESPACE_STD - -template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, - class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE unordered_set -{ -public: - // types - typedef _Value key_type; - typedef key_type value_type; - typedef _Hash hasher; - typedef _Pred key_equal; - typedef _Alloc allocator_type; - typedef value_type& reference; - typedef const value_type& const_reference; - -private: - typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table; - - __table __table_; - -public: - typedef typename __table::pointer pointer; - typedef typename __table::const_pointer const_pointer; - typedef typename __table::size_type size_type; - typedef typename __table::difference_type difference_type; - - typedef typename __table::const_iterator iterator; - typedef typename __table::const_iterator const_iterator; - typedef typename __table::const_local_iterator local_iterator; - typedef typename __table::const_local_iterator const_local_iterator; - - _LIBCPP_INLINE_VISIBILITY - unordered_set() {} // = default; - explicit unordered_set(size_type __n, const hasher& __hf = hasher(), - const key_equal& __eql = key_equal()); - unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, - const allocator_type& __a); - template <class _InputIterator> - unordered_set(_InputIterator __first, _InputIterator __last); - template <class _InputIterator> - unordered_set(_InputIterator __first, _InputIterator __last, - size_type __n, const hasher& __hf = hasher(), - const key_equal& __eql = key_equal()); - template <class _InputIterator> - unordered_set(_InputIterator __first, _InputIterator __last, - size_type __n, const hasher& __hf, const key_equal& __eql, - const allocator_type& __a); - explicit unordered_set(const allocator_type& __a); - unordered_set(const unordered_set& __u); - unordered_set(const unordered_set& __u, const allocator_type& __a); -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - unordered_set(unordered_set&& __u); - unordered_set(unordered_set&& __u, const allocator_type& __a); -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - unordered_set(initializer_list<value_type> __il); - unordered_set(initializer_list<value_type> __il, size_type __n, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal()); - unordered_set(initializer_list<value_type> __il, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a); - // ~unordered_set() = default; - // unordered_set& operator=(const unordered_set& __u) = default; -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - unordered_set& operator=(unordered_set&& __u); -#endif - unordered_set& operator=(initializer_list<value_type> __il); - - _LIBCPP_INLINE_VISIBILITY - allocator_type get_allocator() const - {return allocator_type(__table_.__node_alloc());} - - _LIBCPP_INLINE_VISIBILITY - bool empty() const {return __table_.size() == 0;} - _LIBCPP_INLINE_VISIBILITY - size_type size() const {return __table_.size();} - _LIBCPP_INLINE_VISIBILITY - size_type max_size() const {return __table_.max_size();} - - _LIBCPP_INLINE_VISIBILITY - iterator begin() {return __table_.begin();} - _LIBCPP_INLINE_VISIBILITY - iterator end() {return __table_.end();} - _LIBCPP_INLINE_VISIBILITY - const_iterator begin() const {return __table_.begin();} - _LIBCPP_INLINE_VISIBILITY - const_iterator end() const {return __table_.end();} - _LIBCPP_INLINE_VISIBILITY - const_iterator cbegin() const {return __table_.begin();} - _LIBCPP_INLINE_VISIBILITY - const_iterator cend() const {return __table_.end();} - -#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) - template <class... _Args> - _LIBCPP_INLINE_VISIBILITY - pair<iterator, bool> emplace(_Args&&... __args) - {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...);} - template <class... _Args> - _LIBCPP_INLINE_VISIBILITY - iterator emplace_hint(const_iterator, _Args&&... __args) - {return __table_.__emplace_unique(_STD::forward<_Args>(__args)...).first;} -#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) - _LIBCPP_INLINE_VISIBILITY - pair<iterator, bool> insert(const value_type& __x) - {return __table_.__insert_unique(__x);} -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - _LIBCPP_INLINE_VISIBILITY - pair<iterator, bool> insert(value_type&& __x) - {return __table_.__insert_unique(_STD::move(__x));} -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - _LIBCPP_INLINE_VISIBILITY - iterator insert(const_iterator, const value_type& __x) - {return insert(__x).first;} -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - _LIBCPP_INLINE_VISIBILITY - iterator insert(const_iterator, value_type&& __x) - {return insert(_STD::move(__x)).first;} -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - template <class _InputIterator> - void insert(_InputIterator __first, _InputIterator __last); - _LIBCPP_INLINE_VISIBILITY - void insert(initializer_list<value_type> __il) - {insert(__il.begin(), __il.end());} - - _LIBCPP_INLINE_VISIBILITY - iterator erase(const_iterator __p) {return __table_.erase(__p);} - _LIBCPP_INLINE_VISIBILITY - size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} - _LIBCPP_INLINE_VISIBILITY - iterator erase(const_iterator __first, const_iterator __last) - {return __table_.erase(__first, __last);} - _LIBCPP_INLINE_VISIBILITY - void clear() {__table_.clear();} - - _LIBCPP_INLINE_VISIBILITY - void swap(unordered_set& __u) {__table_.swap(__u.__table_);} - - _LIBCPP_INLINE_VISIBILITY - hasher hash_function() const {return __table_.hash_function();} - _LIBCPP_INLINE_VISIBILITY - key_equal key_eq() const {return __table_.key_eq();} - - _LIBCPP_INLINE_VISIBILITY - iterator find(const key_type& __k) {return __table_.find(__k);} - _LIBCPP_INLINE_VISIBILITY - const_iterator find(const key_type& __k) const {return __table_.find(__k);} - _LIBCPP_INLINE_VISIBILITY - size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} - _LIBCPP_INLINE_VISIBILITY - pair<iterator, iterator> equal_range(const key_type& __k) - {return __table_.__equal_range_unique(__k);} - _LIBCPP_INLINE_VISIBILITY - pair<const_iterator, const_iterator> equal_range(const key_type& __k) const - {return __table_.__equal_range_unique(__k);} - - _LIBCPP_INLINE_VISIBILITY - size_type bucket_count() const {return __table_.bucket_count();} - _LIBCPP_INLINE_VISIBILITY - size_type max_bucket_count() const {return __table_.max_bucket_count();} - - _LIBCPP_INLINE_VISIBILITY - size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} - _LIBCPP_INLINE_VISIBILITY - size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} - - _LIBCPP_INLINE_VISIBILITY - local_iterator begin(size_type __n) {return __table_.begin(__n);} - _LIBCPP_INLINE_VISIBILITY - local_iterator end(size_type __n) {return __table_.end(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator end(size_type __n) const {return __table_.cend(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator cend(size_type __n) const {return __table_.cend(__n);} - - _LIBCPP_INLINE_VISIBILITY - float load_factor() const {return __table_.load_factor();} - _LIBCPP_INLINE_VISIBILITY - float max_load_factor() const {return __table_.max_load_factor();} - _LIBCPP_INLINE_VISIBILITY - void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} - _LIBCPP_INLINE_VISIBILITY - void rehash(size_type __n) {__table_.rehash(__n);} - _LIBCPP_INLINE_VISIBILITY - void reserve(size_type __n) {__table_.reserve(__n);} -}; - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, - const hasher& __hf, const key_equal& __eql) - : __table_(__hf, __eql) -{ - __table_.rehash(__n); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, - const hasher& __hf, const key_equal& __eql, const allocator_type& __a) - : __table_(__hf, __eql, __a) -{ - __table_.rehash(__n); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - _InputIterator __first, _InputIterator __last) -{ - insert(__first, __last); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - _InputIterator __first, _InputIterator __last, size_type __n, - const hasher& __hf, const key_equal& __eql) - : __table_(__hf, __eql) -{ - __table_.rehash(__n); - insert(__first, __last); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - _InputIterator __first, _InputIterator __last, size_type __n, - const hasher& __hf, const key_equal& __eql, const allocator_type& __a) - : __table_(__hf, __eql, __a) -{ - __table_.rehash(__n); - insert(__first, __last); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - const allocator_type& __a) - : __table_(__a) -{ -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - const unordered_set& __u) - : __table_(__u.__table_) -{ - __table_.rehash(__u.bucket_count()); - insert(__u.begin(), __u.end()); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - const unordered_set& __u, const allocator_type& __a) - : __table_(__u.__table_, __a) -{ - __table_.rehash(__u.bucket_count()); - insert(__u.begin(), __u.end()); -} - -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - unordered_set&& __u) - : __table_(_STD::move(__u.__table_)) -{ -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - unordered_set&& __u, const allocator_type& __a) - : __table_(_STD::move(__u.__table_), __a) -{ - if (__a != __u.get_allocator()) - { - iterator __i = __u.begin(); - while (__u.size() != 0) - __table_.__insert_unique(_STD::move(__u.__table_.remove(__i++)->__value_)); - } -} - -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - initializer_list<value_type> __il) -{ - insert(__il.begin(), __il.end()); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - initializer_list<value_type> __il, size_type __n, const hasher& __hf, - const key_equal& __eql) - : __table_(__hf, __eql) -{ - __table_.rehash(__n); - insert(__il.begin(), __il.end()); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( - initializer_list<value_type> __il, size_type __n, const hasher& __hf, - const key_equal& __eql, const allocator_type& __a) - : __table_(__hf, __eql, __a) -{ - __table_.rehash(__n); - insert(__il.begin(), __il.end()); -} - -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -unordered_set<_Value, _Hash, _Pred, _Alloc>& -unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u) -{ - __table_ = _STD::move(__u.__table_); - return *this; -} - -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -unordered_set<_Value, _Hash, _Pred, _Alloc>& -unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=( - initializer_list<value_type> __il) -{ - __table_.__assign_unique(__il.begin(), __il.end()); - return *this; -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -inline _LIBCPP_INLINE_VISIBILITY -void -unordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, - _InputIterator __last) -{ - for (; __first != __last; ++__first) - __table_.__insert_unique(*__first); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -void -swap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, - unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) -{ - __x.swap(__y); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -bool -operator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, - const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) -{ - if (__x.size() != __y.size()) - return false; - typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator - const_iterator; - for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); - __i != __ex; ++__i) - { - const_iterator __j = __y.find(*__i); - if (__j == __ey || !(*__i == *__j)) - return false; - } - return true; -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -bool -operator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, - const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) -{ - return !(__x == __y); -} - -template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, - class _Alloc = allocator<_Value> > -class _LIBCPP_VISIBLE unordered_multiset -{ -public: - // types - typedef _Value key_type; - typedef key_type value_type; - typedef _Hash hasher; - typedef _Pred key_equal; - typedef _Alloc allocator_type; - typedef value_type& reference; - typedef const value_type& const_reference; - -private: - typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table; - - __table __table_; - -public: - typedef typename __table::pointer pointer; - typedef typename __table::const_pointer const_pointer; - typedef typename __table::size_type size_type; - typedef typename __table::difference_type difference_type; - - typedef typename __table::const_iterator iterator; - typedef typename __table::const_iterator const_iterator; - typedef typename __table::const_local_iterator local_iterator; - typedef typename __table::const_local_iterator const_local_iterator; - - _LIBCPP_INLINE_VISIBILITY - unordered_multiset() {} // = default - explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(), - const key_equal& __eql = key_equal()); - unordered_multiset(size_type __n, const hasher& __hf, - const key_equal& __eql, const allocator_type& __a); - template <class _InputIterator> - unordered_multiset(_InputIterator __first, _InputIterator __last); - template <class _InputIterator> - unordered_multiset(_InputIterator __first, _InputIterator __last, - size_type __n, const hasher& __hf = hasher(), - const key_equal& __eql = key_equal()); - template <class _InputIterator> - unordered_multiset(_InputIterator __first, _InputIterator __last, - size_type __n , const hasher& __hf, - const key_equal& __eql, const allocator_type& __a); - explicit unordered_multiset(const allocator_type& __a); - unordered_multiset(const unordered_multiset& __u); - unordered_multiset(const unordered_multiset& __u, const allocator_type& __a); -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - unordered_multiset(unordered_multiset&& __u); - unordered_multiset(unordered_multiset&& __u, const allocator_type& __a); -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - unordered_multiset(initializer_list<value_type> __il); - unordered_multiset(initializer_list<value_type> __il, size_type __n, - const hasher& __hf = hasher(), - const key_equal& __eql = key_equal()); - unordered_multiset(initializer_list<value_type> __il, size_type __n, - const hasher& __hf, const key_equal& __eql, - const allocator_type& __a); - // ~unordered_multiset() = default; - // unordered_multiset& operator=(const unordered_multiset& __u) = default; -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - unordered_multiset& operator=(unordered_multiset&& __u); -#endif - unordered_multiset& operator=(initializer_list<value_type> __il); - - _LIBCPP_INLINE_VISIBILITY - allocator_type get_allocator() const - {return allocator_type(__table_.__node_alloc());} - - _LIBCPP_INLINE_VISIBILITY - bool empty() const {return __table_.size() == 0;} - _LIBCPP_INLINE_VISIBILITY - size_type size() const {return __table_.size();} - _LIBCPP_INLINE_VISIBILITY - size_type max_size() const {return __table_.max_size();} - - _LIBCPP_INLINE_VISIBILITY - iterator begin() {return __table_.begin();} - _LIBCPP_INLINE_VISIBILITY - iterator end() {return __table_.end();} - _LIBCPP_INLINE_VISIBILITY - const_iterator begin() const {return __table_.begin();} - _LIBCPP_INLINE_VISIBILITY - const_iterator end() const {return __table_.end();} - _LIBCPP_INLINE_VISIBILITY - const_iterator cbegin() const {return __table_.begin();} - _LIBCPP_INLINE_VISIBILITY - const_iterator cend() const {return __table_.end();} - -#if !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) - template <class... _Args> - _LIBCPP_INLINE_VISIBILITY - iterator emplace(_Args&&... __args) - {return __table_.__emplace_multi(_STD::forward<_Args>(__args)...);} - template <class... _Args> - _LIBCPP_INLINE_VISIBILITY - iterator emplace_hint(const_iterator __p, _Args&&... __args) - {return __table_.__emplace_hint_multi(__p, _STD::forward<_Args>(__args)...);} -#endif // !defined(_LIBCPP_HAS_NO_RVALUE_REFERENCES) && !defined(_LIBCPP_HAS_NO_VARIADICS) - _LIBCPP_INLINE_VISIBILITY - iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);} -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - _LIBCPP_INLINE_VISIBILITY - iterator insert(value_type&& __x) {return __table_.__insert_multi(_STD::move(__x));} -#endif - _LIBCPP_INLINE_VISIBILITY - iterator insert(const_iterator __p, const value_type& __x) - {return __table_.__insert_multi(__p, __x);} -#ifndef _LIBCPP_HAS_NO_RVALUE_REFERENCES - _LIBCPP_INLINE_VISIBILITY - iterator insert(const_iterator __p, value_type&& __x) - {return __table_.__insert_multi(__p, _STD::move(__x));} -#endif // _LIBCPP_HAS_NO_RVALUE_REFERENCES - template <class _InputIterator> - void insert(_InputIterator __first, _InputIterator __last); - _LIBCPP_INLINE_VISIBILITY - void insert(initializer_list<value_type> __il) - {insert(__il.begin(), __il.end());} - - _LIBCPP_INLINE_VISIBILITY - iterator erase(const_iterator __p) {return __table_.erase(__p);} - _LIBCPP_INLINE_VISIBILITY - size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);} - _LIBCPP_INLINE_VISIBILITY - iterator erase(const_iterator __first, const_iterator __last) - {return __table_.erase(__first, __last);} - _LIBCPP_INLINE_VISIBILITY - void clear() {__table_.clear();} - - _LIBCPP_INLINE_VISIBILITY - void swap(unordered_multiset& __u) {__table_.swap(__u.__table_);} - - _LIBCPP_INLINE_VISIBILITY - hasher hash_function() const {return __table_.hash_function();} - _LIBCPP_INLINE_VISIBILITY - key_equal key_eq() const {return __table_.key_eq();} - - _LIBCPP_INLINE_VISIBILITY - iterator find(const key_type& __k) {return __table_.find(__k);} - _LIBCPP_INLINE_VISIBILITY - const_iterator find(const key_type& __k) const {return __table_.find(__k);} - _LIBCPP_INLINE_VISIBILITY - size_type count(const key_type& __k) const {return __table_.__count_multi(__k);} - _LIBCPP_INLINE_VISIBILITY - pair<iterator, iterator> equal_range(const key_type& __k) - {return __table_.__equal_range_multi(__k);} - _LIBCPP_INLINE_VISIBILITY - pair<const_iterator, const_iterator> equal_range(const key_type& __k) const - {return __table_.__equal_range_multi(__k);} - - _LIBCPP_INLINE_VISIBILITY - size_type bucket_count() const {return __table_.bucket_count();} - _LIBCPP_INLINE_VISIBILITY - size_type max_bucket_count() const {return __table_.max_bucket_count();} - - _LIBCPP_INLINE_VISIBILITY - size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} - _LIBCPP_INLINE_VISIBILITY - size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} - - _LIBCPP_INLINE_VISIBILITY - local_iterator begin(size_type __n) {return __table_.begin(__n);} - _LIBCPP_INLINE_VISIBILITY - local_iterator end(size_type __n) {return __table_.end(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator end(size_type __n) const {return __table_.cend(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} - _LIBCPP_INLINE_VISIBILITY - const_local_iterator cend(size_type __n) const {return __table_.cend(__n);} - - _LIBCPP_INLINE_VISIBILITY - float load_factor() const {return __table_.load_factor();} - _LIBCPP_INLINE_VISIBILITY - float max_load_factor() const {return __table_.max_load_factor();} - _LIBCPP_INLINE_VISIBILITY - void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} - _LIBCPP_INLINE_VISIBILITY - void rehash(size_type __n) {__table_.rehash(__n);} - _LIBCPP_INLINE_VISIBILITY - void reserve(size_type __n) {__table_.reserve(__n);} -}; - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - size_type __n, const hasher& __hf, const key_equal& __eql) - : __table_(__hf, __eql) -{ - __table_.rehash(__n); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - size_type __n, const hasher& __hf, const key_equal& __eql, - const allocator_type& __a) - : __table_(__hf, __eql, __a) -{ - __table_.rehash(__n); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - _InputIterator __first, _InputIterator __last) -{ - insert(__first, __last); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - _InputIterator __first, _InputIterator __last, size_type __n, - const hasher& __hf, const key_equal& __eql) - : __table_(__hf, __eql) -{ - __table_.rehash(__n); - insert(__first, __last); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -template <class _InputIterator> -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - _InputIterator __first, _InputIterator __last, size_type __n, - const hasher& __hf, const key_equal& __eql, const allocator_type& __a) - : __table_(__hf, __eql, __a) -{ - __table_.rehash(__n); - insert(__first, __last); -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -inline _LIBCPP_INLINE_VISIBILITY -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - const allocator_type& __a) - : __table_(__a) -{ -} - -template <class _Value, class _Hash, class _Pred, class _Alloc> -unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( - const unordered_multiset& __u) - : __table_(__u.__table_) -{ - __table_.rehash(__u |