mirror of
git://gcc.gnu.org/git/gcc.git
synced 2025-03-29 08:20:27 +08:00
hash_map: Trivial formatting fixes.
2004-06-14 Paolo Carlini <pcarlini@suse.de> * include/ext/hash_map: Trivial formatting fixes. * include/ext/hash_set: Likewise. * include/ext/memory: Likewise. * include/ext/numeric: Likewise. From-SVN: r83131
This commit is contained in:
Paolo Carlini
Paolo Carlini
parent
f51d8522f7
commit
d962e073a0
@ -1,3 +1,10 @@
|
||||
2004-06-14 Paolo Carlini <pcarlini@suse.de>
|
||||
|
||||
* include/ext/hash_map: Trivial formatting fixes.
|
||||
* include/ext/hash_set: Likewise.
|
||||
* include/ext/memory: Likewise.
|
||||
* include/ext/numeric: Likewise.
|
||||
|
||||
2004-06-14 Benjamin Kosnik <bkoz@redhat.com>
|
||||
|
||||
* Makefile.in: Regenerate with automake 1.8.5.
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Hashing map implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
@ -74,314 +74,456 @@ namespace __gnu_cxx
|
||||
|
||||
// Forward declaration of equality operator; needed for friend
|
||||
// declaration.
|
||||
template<class _Key, class _Tp, class _HashFcn = hash<_Key>,
|
||||
class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> >
|
||||
template<class _Key, class _Tp, class _HashFcn = hash<_Key>,
|
||||
class _EqualKey = equal_to<_Key>, class _Alloc = allocator<_Tp> >
|
||||
class hash_map;
|
||||
|
||||
template<class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
|
||||
inline bool operator==(const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&,
|
||||
const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&);
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
|
||||
class _Alloc>
|
||||
class hash_map
|
||||
{
|
||||
private:
|
||||
typedef hashtable<pair<const _Key,_Tp>,_Key,_HashFcn,
|
||||
_Select1st<pair<const _Key,_Tp> >,_EqualKey,_Alloc> _Ht;
|
||||
_Ht _M_ht;
|
||||
inline bool
|
||||
operator==(const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&,
|
||||
const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&);
|
||||
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
|
||||
class _Alloc>
|
||||
class hash_map
|
||||
{
|
||||
private:
|
||||
typedef hashtable<pair<const _Key, _Tp>,_Key, _HashFcn,
|
||||
_Select1st<pair<const _Key, _Tp> >,
|
||||
_EqualKey, _Alloc> _Ht;
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Ht::pointer pointer;
|
||||
typedef typename _Ht::const_pointer const_pointer;
|
||||
typedef typename _Ht::reference reference;
|
||||
typedef typename _Ht::const_reference const_reference;
|
||||
_Ht _M_ht;
|
||||
|
||||
typedef typename _Ht::iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Ht::pointer pointer;
|
||||
typedef typename _Ht::const_pointer const_pointer;
|
||||
typedef typename _Ht::reference reference;
|
||||
typedef typename _Ht::const_reference const_reference;
|
||||
|
||||
typedef typename _Ht::iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
|
||||
hasher
|
||||
hash_funct() const
|
||||
{ return _M_ht.hash_funct(); }
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
key_equal
|
||||
key_eq() const
|
||||
{ return _M_ht.key_eq(); }
|
||||
|
||||
hasher hash_funct() const { return _M_ht.hash_funct(); }
|
||||
key_equal key_eq() const { return _M_ht.key_eq(); }
|
||||
allocator_type get_allocator() const { return _M_ht.get_allocator(); }
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return _M_ht.get_allocator(); }
|
||||
|
||||
public:
|
||||
hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
explicit hash_map(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
hash_map(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
public:
|
||||
hash_map()
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
explicit
|
||||
hash_map(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
hash_map(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
|
||||
public:
|
||||
size_type size() const { return _M_ht.size(); }
|
||||
size_type max_size() const { return _M_ht.max_size(); }
|
||||
bool empty() const { return _M_ht.empty(); }
|
||||
void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); }
|
||||
hash_map(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
|
||||
template <class _K1, class _T1, class _HF, class _EqK, class _Al>
|
||||
friend bool operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&,
|
||||
const hash_map<_K1, _T1, _HF, _EqK, _Al>&);
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
iterator begin() { return _M_ht.begin(); }
|
||||
iterator end() { return _M_ht.end(); }
|
||||
const_iterator begin() const { return _M_ht.begin(); }
|
||||
const_iterator end() const { return _M_ht.end(); }
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
public:
|
||||
pair<iterator,bool> insert(const value_type& __obj)
|
||||
{ return _M_ht.insert_unique(__obj); }
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_unique(__f,__l); }
|
||||
pair<iterator,bool> insert_noresize(const value_type& __obj)
|
||||
{ return _M_ht.insert_unique_noresize(__obj); }
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
iterator find(const key_type& __key) { return _M_ht.find(__key); }
|
||||
const_iterator find(const key_type& __key) const
|
||||
{ return _M_ht.find(__key); }
|
||||
template <class _InputIterator>
|
||||
hash_map(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
_Tp& operator[](const key_type& __key) {
|
||||
return _M_ht.find_or_insert(value_type(__key, _Tp())).second;
|
||||
}
|
||||
public:
|
||||
size_type
|
||||
size() const
|
||||
{ return _M_ht.size(); }
|
||||
|
||||
size_type
|
||||
max_size() const
|
||||
{ return _M_ht.max_size(); }
|
||||
|
||||
bool
|
||||
empty() const
|
||||
{ return _M_ht.empty(); }
|
||||
|
||||
void
|
||||
swap(hash_map& __hs)
|
||||
{ _M_ht.swap(__hs._M_ht); }
|
||||
|
||||
size_type count(const key_type& __key) const { return _M_ht.count(__key); }
|
||||
template <class _K1, class _T1, class _HF, class _EqK, class _Al>
|
||||
friend bool
|
||||
operator== (const hash_map<_K1, _T1, _HF, _EqK, _Al>&,
|
||||
const hash_map<_K1, _T1, _HF, _EqK, _Al>&);
|
||||
|
||||
pair<iterator, iterator> equal_range(const key_type& __key)
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
pair<const_iterator, const_iterator>
|
||||
equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
iterator
|
||||
begin()
|
||||
{ return _M_ht.begin(); }
|
||||
|
||||
size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
|
||||
void erase(iterator __it) { _M_ht.erase(__it); }
|
||||
void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
|
||||
void clear() { _M_ht.clear(); }
|
||||
iterator
|
||||
end()
|
||||
{ return _M_ht.end(); }
|
||||
|
||||
void resize(size_type __hint) { _M_ht.resize(__hint); }
|
||||
size_type bucket_count() const { return _M_ht.bucket_count(); }
|
||||
size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
|
||||
size_type elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
const_iterator
|
||||
begin() const
|
||||
{ return _M_ht.begin(); }
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
|
||||
const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
|
||||
{
|
||||
return __hm1._M_ht == __hm2._M_ht;
|
||||
}
|
||||
const_iterator
|
||||
end() const
|
||||
{ return _M_ht.end(); }
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
|
||||
const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) {
|
||||
return !(__hm1 == __hm2);
|
||||
}
|
||||
public:
|
||||
pair<iterator, bool>
|
||||
insert(const value_type& __obj)
|
||||
{ return _M_ht.insert_unique(__obj); }
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
|
||||
hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
|
||||
{
|
||||
__hm1.swap(__hm2);
|
||||
}
|
||||
template <class _InputIterator>
|
||||
void
|
||||
insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
// Forward declaration of equality operator; needed for friend declaration.
|
||||
pair<iterator, bool>
|
||||
insert_noresize(const value_type& __obj)
|
||||
{ return _M_ht.insert_unique_noresize(__obj); }
|
||||
|
||||
template <class _Key, class _Tp,
|
||||
class _HashFcn = hash<_Key>,
|
||||
class _EqualKey = equal_to<_Key>,
|
||||
class _Alloc = allocator<_Tp> >
|
||||
class hash_multimap;
|
||||
iterator
|
||||
find(const key_type& __key)
|
||||
{ return _M_ht.find(__key); }
|
||||
|
||||
template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
|
||||
const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2);
|
||||
const_iterator
|
||||
find(const key_type& __key) const
|
||||
{ return _M_ht.find(__key); }
|
||||
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class hash_multimap
|
||||
{
|
||||
// concept requirements
|
||||
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires3(_HashFcn, size_t, _Key, _UnaryFunctionConcept)
|
||||
__glibcxx_class_requires3(_EqualKey, _Key, _Key, _BinaryPredicateConcept)
|
||||
_Tp&
|
||||
operator[](const key_type& __key)
|
||||
{ return _M_ht.find_or_insert(value_type(__key, _Tp())).second; }
|
||||
|
||||
private:
|
||||
typedef hashtable<pair<const _Key, _Tp>, _Key, _HashFcn,
|
||||
_Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc>
|
||||
size_type
|
||||
count(const key_type& __key) const
|
||||
{ return _M_ht.count(__key); }
|
||||
|
||||
pair<iterator, iterator>
|
||||
equal_range(const key_type& __key)
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
pair<const_iterator, const_iterator>
|
||||
equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
size_type
|
||||
erase(const key_type& __key)
|
||||
{return _M_ht.erase(__key); }
|
||||
|
||||
void
|
||||
erase(iterator __it)
|
||||
{ _M_ht.erase(__it); }
|
||||
|
||||
void
|
||||
erase(iterator __f, iterator __l)
|
||||
{ _M_ht.erase(__f, __l); }
|
||||
|
||||
void
|
||||
clear()
|
||||
{ _M_ht.clear(); }
|
||||
|
||||
void
|
||||
resize(size_type __hint)
|
||||
{ _M_ht.resize(__hint); }
|
||||
|
||||
size_type
|
||||
bucket_count() const
|
||||
{ return _M_ht.bucket_count(); }
|
||||
|
||||
size_type
|
||||
max_bucket_count() const
|
||||
{ return _M_ht.max_bucket_count(); }
|
||||
|
||||
size_type
|
||||
elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm1,
|
||||
const hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm2)
|
||||
{ return __hm1._M_ht == __hm2._M_ht; }
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm1,
|
||||
const hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm2)
|
||||
{ return !(__hm1 == __hm2); }
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm1,
|
||||
hash_map<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm2)
|
||||
{ __hm1.swap(__hm2); }
|
||||
|
||||
// Forward declaration of equality operator; needed for friend declaration.
|
||||
|
||||
template <class _Key, class _Tp,
|
||||
class _HashFcn = hash<_Key>,
|
||||
class _EqualKey = equal_to<_Key>,
|
||||
class _Alloc = allocator<_Tp> >
|
||||
class hash_multimap;
|
||||
|
||||
template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1,
|
||||
const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2);
|
||||
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqualKey,
|
||||
class _Alloc>
|
||||
class hash_multimap
|
||||
{
|
||||
// concept requirements
|
||||
__glibcxx_class_requires(_Key, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires(_Tp, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires3(_HashFcn, size_t, _Key, _UnaryFunctionConcept)
|
||||
__glibcxx_class_requires3(_EqualKey, _Key, _Key, _BinaryPredicateConcept)
|
||||
|
||||
private:
|
||||
typedef hashtable<pair<const _Key, _Tp>, _Key, _HashFcn,
|
||||
_Select1st<pair<const _Key, _Tp> >, _EqualKey, _Alloc>
|
||||
_Ht;
|
||||
_Ht _M_ht;
|
||||
|
||||
_Ht _M_ht;
|
||||
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Ht::pointer pointer;
|
||||
typedef typename _Ht::const_pointer const_pointer;
|
||||
typedef typename _Ht::reference reference;
|
||||
typedef typename _Ht::const_reference const_reference;
|
||||
|
||||
typedef typename _Ht::iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
|
||||
hasher
|
||||
hash_funct() const
|
||||
{ return _M_ht.hash_funct(); }
|
||||
|
||||
key_equal
|
||||
key_eq() const
|
||||
{ return _M_ht.key_eq(); }
|
||||
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return _M_ht.get_allocator(); }
|
||||
|
||||
public:
|
||||
hash_multimap()
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
explicit
|
||||
hash_multimap(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
hash_multimap(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
|
||||
hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
public:
|
||||
size_type
|
||||
size() const
|
||||
{ return _M_ht.size(); }
|
||||
|
||||
size_type
|
||||
max_size() const
|
||||
{ return _M_ht.max_size(); }
|
||||
|
||||
bool
|
||||
empty() const
|
||||
{ return _M_ht.empty(); }
|
||||
|
||||
void
|
||||
swap(hash_multimap& __hs)
|
||||
{ _M_ht.swap(__hs._M_ht); }
|
||||
|
||||
template <class _K1, class _T1, class _HF, class _EqK, class _Al>
|
||||
friend bool
|
||||
operator==(const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&,
|
||||
const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&);
|
||||
|
||||
iterator
|
||||
begin()
|
||||
{ return _M_ht.begin(); }
|
||||
|
||||
iterator
|
||||
end()
|
||||
{ return _M_ht.end(); }
|
||||
|
||||
const_iterator
|
||||
begin() const
|
||||
{ return _M_ht.begin(); }
|
||||
|
||||
const_iterator
|
||||
end() const
|
||||
{ return _M_ht.end(); }
|
||||
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef _Tp data_type;
|
||||
typedef _Tp mapped_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
iterator
|
||||
insert(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal(__obj); }
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Ht::pointer pointer;
|
||||
typedef typename _Ht::const_pointer const_pointer;
|
||||
typedef typename _Ht::reference reference;
|
||||
typedef typename _Ht::const_reference const_reference;
|
||||
template <class _InputIterator>
|
||||
void
|
||||
insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_equal(__f,__l); }
|
||||
|
||||
typedef typename _Ht::iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
iterator
|
||||
insert_noresize(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal_noresize(__obj); }
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
iterator
|
||||
find(const key_type& __key)
|
||||
{ return _M_ht.find(__key); }
|
||||
|
||||
hasher hash_funct() const { return _M_ht.hash_funct(); }
|
||||
key_equal key_eq() const { return _M_ht.key_eq(); }
|
||||
allocator_type get_allocator() const { return _M_ht.get_allocator(); }
|
||||
const_iterator
|
||||
find(const key_type& __key) const
|
||||
{ return _M_ht.find(__key); }
|
||||
|
||||
public:
|
||||
hash_multimap() : _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
explicit hash_multimap(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
hash_multimap(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
hash_multimap(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
size_type
|
||||
count(const key_type& __key) const
|
||||
{ return _M_ht.count(__key); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_multimap(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
pair<iterator, iterator>
|
||||
equal_range(const key_type& __key)
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
public:
|
||||
size_type size() const { return _M_ht.size(); }
|
||||
size_type max_size() const { return _M_ht.max_size(); }
|
||||
bool empty() const { return _M_ht.empty(); }
|
||||
void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); }
|
||||
pair<const_iterator, const_iterator>
|
||||
equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
template <class _K1, class _T1, class _HF, class _EqK, class _Al>
|
||||
friend bool operator== (const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&,
|
||||
const hash_multimap<_K1, _T1, _HF, _EqK, _Al>&);
|
||||
size_type
|
||||
erase(const key_type& __key)
|
||||
{ return _M_ht.erase(__key); }
|
||||
|
||||
iterator begin() { return _M_ht.begin(); }
|
||||
iterator end() { return _M_ht.end(); }
|
||||
const_iterator begin() const { return _M_ht.begin(); }
|
||||
const_iterator end() const { return _M_ht.end(); }
|
||||
void
|
||||
erase(iterator __it)
|
||||
{ _M_ht.erase(__it); }
|
||||
|
||||
public:
|
||||
iterator insert(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal(__obj); }
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_equal(__f,__l); }
|
||||
iterator insert_noresize(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal_noresize(__obj); }
|
||||
void
|
||||
erase(iterator __f, iterator __l)
|
||||
{ _M_ht.erase(__f, __l); }
|
||||
|
||||
iterator find(const key_type& __key) { return _M_ht.find(__key); }
|
||||
const_iterator find(const key_type& __key) const
|
||||
{ return _M_ht.find(__key); }
|
||||
void
|
||||
clear()
|
||||
{ _M_ht.clear(); }
|
||||
|
||||
size_type count(const key_type& __key) const { return _M_ht.count(__key); }
|
||||
public:
|
||||
void
|
||||
resize(size_type __hint)
|
||||
{ _M_ht.resize(__hint); }
|
||||
|
||||
pair<iterator, iterator> equal_range(const key_type& __key)
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
pair<const_iterator, const_iterator>
|
||||
equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
size_type
|
||||
bucket_count() const
|
||||
{ return _M_ht.bucket_count(); }
|
||||
|
||||
size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
|
||||
void erase(iterator __it) { _M_ht.erase(__it); }
|
||||
void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
|
||||
void clear() { _M_ht.clear(); }
|
||||
|
||||
public:
|
||||
void resize(size_type __hint) { _M_ht.resize(__hint); }
|
||||
size_type bucket_count() const { return _M_ht.bucket_count(); }
|
||||
size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
|
||||
size_type elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
size_type
|
||||
max_bucket_count() const
|
||||
{ return _M_ht.max_bucket_count(); }
|
||||
|
||||
size_type
|
||||
elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
|
||||
template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
|
||||
const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2)
|
||||
{
|
||||
return __hm1._M_ht == __hm2._M_ht;
|
||||
}
|
||||
template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1,
|
||||
const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2)
|
||||
{ return __hm1._M_ht == __hm2._M_ht; }
|
||||
|
||||
template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1,
|
||||
const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2) {
|
||||
return !(__hm1 == __hm2);
|
||||
}
|
||||
template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1,
|
||||
const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2)
|
||||
{ return !(__hm1 == __hm2); }
|
||||
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1,
|
||||
hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2)
|
||||
{
|
||||
__hm1.swap(__hm2);
|
||||
}
|
||||
template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm1,
|
||||
hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm2)
|
||||
{ __hm1.swap(__hm2); }
|
||||
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
@ -390,58 +532,90 @@ namespace std
|
||||
// Specialization of insert_iterator so that it will work for hash_map
|
||||
// and hash_multimap.
|
||||
|
||||
template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
|
||||
_Container* container;
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_map<_Key, _Tp, _HashFn,
|
||||
_EqKey, _Alloc> >
|
||||
{
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>
|
||||
_Container;
|
||||
_Container* container;
|
||||
|
||||
insert_iterator(_Container& __x) : container(&__x) {}
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value) {
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
insert_iterator<_Container>& operator*() { return *this; }
|
||||
insert_iterator<_Container>& operator++() { return *this; }
|
||||
insert_iterator<_Container>& operator++(int) { return *this; }
|
||||
};
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
|
||||
insert_iterator(_Container& __x)
|
||||
: container(&__x) {}
|
||||
|
||||
template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> > {
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc> _Container;
|
||||
_Container* container;
|
||||
typename _Container::iterator iter;
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator(_Container& __x) : container(&__x) {}
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value) {
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
insert_iterator<_Container>& operator*() { return *this; }
|
||||
insert_iterator<_Container>& operator++() { return *this; }
|
||||
insert_iterator<_Container>& operator++(int) { return *this; }
|
||||
};
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value)
|
||||
{
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator*()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++() { return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++(int)
|
||||
{ return *this; }
|
||||
};
|
||||
|
||||
template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_multimap<_Key, _Tp, _HashFn,
|
||||
_EqKey, _Alloc> >
|
||||
{
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_multimap<_Key, _Tp, _HashFn, _EqKey, _Alloc>
|
||||
_Container;
|
||||
_Container* container;
|
||||
typename _Container::iterator iter;
|
||||
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
|
||||
insert_iterator(_Container& __x)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value)
|
||||
{
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator*()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++(int)
|
||||
{ return *this; }
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Hashing set implementation -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2001, 2002 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2001, 2002, 2004 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
@ -76,364 +76,512 @@ namespace __gnu_cxx
|
||||
// declaration.
|
||||
template <class _Value, class _HashFcn = hash<_Value>,
|
||||
class _EqualKey = equal_to<_Value>,
|
||||
class _Alloc = allocator<_Value> >
|
||||
class hash_set;
|
||||
class _Alloc = allocator<_Value> >
|
||||
class hash_set;
|
||||
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2);
|
||||
operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2);
|
||||
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class hash_set
|
||||
{
|
||||
// concept requirements
|
||||
__glibcxx_class_requires(_Value, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept)
|
||||
__glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept)
|
||||
|
||||
private:
|
||||
typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
|
||||
_EqualKey, _Alloc> _Ht;
|
||||
_Ht _M_ht;
|
||||
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Alloc::pointer pointer;
|
||||
typedef typename _Alloc::const_pointer const_pointer;
|
||||
typedef typename _Alloc::reference reference;
|
||||
typedef typename _Alloc::const_reference const_reference;
|
||||
|
||||
typedef typename _Ht::const_iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
|
||||
hasher hash_funct() const { return _M_ht.hash_funct(); }
|
||||
key_equal key_eq() const { return _M_ht.key_eq(); }
|
||||
allocator_type get_allocator() const { return _M_ht.get_allocator(); }
|
||||
|
||||
public:
|
||||
hash_set()
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
explicit hash_set(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
hash_set(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
public:
|
||||
size_type size() const { return _M_ht.size(); }
|
||||
size_type max_size() const { return _M_ht.max_size(); }
|
||||
bool empty() const { return _M_ht.empty(); }
|
||||
void swap(hash_set& __hs) { _M_ht.swap(__hs._M_ht); }
|
||||
|
||||
template <class _Val, class _HF, class _EqK, class _Al>
|
||||
friend bool operator== (const hash_set<_Val, _HF, _EqK, _Al>&,
|
||||
const hash_set<_Val, _HF, _EqK, _Al>&);
|
||||
|
||||
iterator begin() const { return _M_ht.begin(); }
|
||||
iterator end() const { return _M_ht.end(); }
|
||||
|
||||
public:
|
||||
pair<iterator, bool> insert(const value_type& __obj)
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class hash_set
|
||||
{
|
||||
pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
|
||||
return pair<iterator,bool>(__p.first, __p.second);
|
||||
}
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_unique(__f,__l); }
|
||||
pair<iterator, bool> insert_noresize(const value_type& __obj)
|
||||
{
|
||||
pair<typename _Ht::iterator, bool> __p =
|
||||
_M_ht.insert_unique_noresize(__obj);
|
||||
return pair<iterator, bool>(__p.first, __p.second);
|
||||
}
|
||||
// concept requirements
|
||||
__glibcxx_class_requires(_Value, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept)
|
||||
__glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept)
|
||||
|
||||
iterator find(const key_type& __key) const { return _M_ht.find(__key); }
|
||||
private:
|
||||
typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
|
||||
_EqualKey, _Alloc> _Ht;
|
||||
_Ht _M_ht;
|
||||
|
||||
size_type count(const key_type& __key) const { return _M_ht.count(__key); }
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Alloc::pointer pointer;
|
||||
typedef typename _Alloc::const_pointer const_pointer;
|
||||
typedef typename _Alloc::reference reference;
|
||||
typedef typename _Alloc::const_reference const_reference;
|
||||
|
||||
typedef typename _Ht::const_iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
|
||||
hasher
|
||||
hash_funct() const
|
||||
{ return _M_ht.hash_funct(); }
|
||||
|
||||
pair<iterator, iterator> equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
key_equal
|
||||
key_eq() const
|
||||
{ return _M_ht.key_eq(); }
|
||||
|
||||
size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
|
||||
void erase(iterator __it) { _M_ht.erase(__it); }
|
||||
void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
|
||||
void clear() { _M_ht.clear(); }
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return _M_ht.get_allocator(); }
|
||||
|
||||
public:
|
||||
hash_set()
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
explicit
|
||||
hash_set(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
hash_set(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
|
||||
hash_set(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_set(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
public:
|
||||
size_type
|
||||
size() const
|
||||
{ return _M_ht.size(); }
|
||||
|
||||
size_type
|
||||
max_size() const
|
||||
{ return _M_ht.max_size(); }
|
||||
|
||||
bool
|
||||
empty() const
|
||||
{ return _M_ht.empty(); }
|
||||
|
||||
void
|
||||
swap(hash_set& __hs)
|
||||
{ _M_ht.swap(__hs._M_ht); }
|
||||
|
||||
template <class _Val, class _HF, class _EqK, class _Al>
|
||||
friend bool
|
||||
operator==(const hash_set<_Val, _HF, _EqK, _Al>&,
|
||||
const hash_set<_Val, _HF, _EqK, _Al>&);
|
||||
|
||||
iterator
|
||||
begin() const
|
||||
{ return _M_ht.begin(); }
|
||||
|
||||
iterator
|
||||
end() const
|
||||
{ return _M_ht.end(); }
|
||||
|
||||
public:
|
||||
pair<iterator, bool>
|
||||
insert(const value_type& __obj)
|
||||
{
|
||||
pair<typename _Ht::iterator, bool> __p = _M_ht.insert_unique(__obj);
|
||||
return pair<iterator,bool>(__p.first, __p.second);
|
||||
}
|
||||
|
||||
template <class _InputIterator>
|
||||
void
|
||||
insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_unique(__f, __l); }
|
||||
|
||||
pair<iterator, bool>
|
||||
insert_noresize(const value_type& __obj)
|
||||
{
|
||||
pair<typename _Ht::iterator, bool> __p
|
||||
= _M_ht.insert_unique_noresize(__obj);
|
||||
return pair<iterator, bool>(__p.first, __p.second);
|
||||
}
|
||||
|
||||
iterator
|
||||
find(const key_type& __key) const
|
||||
{ return _M_ht.find(__key); }
|
||||
|
||||
size_type
|
||||
count(const key_type& __key) const
|
||||
{ return _M_ht.count(__key); }
|
||||
|
||||
pair<iterator, iterator>
|
||||
equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
size_type
|
||||
erase(const key_type& __key)
|
||||
{return _M_ht.erase(__key); }
|
||||
|
||||
void
|
||||
erase(iterator __it)
|
||||
{ _M_ht.erase(__it); }
|
||||
|
||||
void
|
||||
erase(iterator __f, iterator __l)
|
||||
{ _M_ht.erase(__f, __l); }
|
||||
|
||||
void
|
||||
clear()
|
||||
{ _M_ht.clear(); }
|
||||
|
||||
public:
|
||||
void resize(size_type __hint) { _M_ht.resize(__hint); }
|
||||
size_type bucket_count() const { return _M_ht.bucket_count(); }
|
||||
size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
|
||||
size_type elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
void
|
||||
resize(size_type __hint)
|
||||
{ _M_ht.resize(__hint); }
|
||||
|
||||
size_type
|
||||
bucket_count() const
|
||||
{ return _M_ht.bucket_count(); }
|
||||
|
||||
size_type
|
||||
max_bucket_count() const
|
||||
{ return _M_ht.max_bucket_count(); }
|
||||
|
||||
size_type
|
||||
elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2)
|
||||
{
|
||||
return __hs1._M_ht == __hs2._M_ht;
|
||||
}
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2)
|
||||
{ return __hs1._M_ht == __hs2._M_ht; }
|
||||
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
const hash_set<_Value,_HashFcn,_EqualKey,_Alloc>& __hs2) {
|
||||
return !(__hs1 == __hs2);
|
||||
}
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
const hash_set<_Value, _HashFcn, _EqualKey, _Alloc>& __hs2)
|
||||
{ return !(__hs1 == __hs2); }
|
||||
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
hash_set<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
|
||||
{
|
||||
__hs1.swap(__hs2);
|
||||
}
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
hash_set<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
|
||||
{ __hs1.swap(__hs2); }
|
||||
|
||||
template <class _Value,
|
||||
class _HashFcn = hash<_Value>,
|
||||
class _EqualKey = equal_to<_Value>,
|
||||
class _Alloc = allocator<_Value> >
|
||||
class hash_multiset;
|
||||
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2);
|
||||
|
||||
|
||||
template <class _Value,
|
||||
class _HashFcn = hash<_Value>,
|
||||
class _EqualKey = equal_to<_Value>,
|
||||
class _Alloc = allocator<_Value> >
|
||||
class hash_multiset;
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class hash_multiset
|
||||
{
|
||||
// concept requirements
|
||||
__glibcxx_class_requires(_Value, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept)
|
||||
__glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept)
|
||||
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2);
|
||||
private:
|
||||
typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
|
||||
_EqualKey, _Alloc> _Ht;
|
||||
_Ht _M_ht;
|
||||
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Alloc::pointer pointer;
|
||||
typedef typename _Alloc::const_pointer const_pointer;
|
||||
typedef typename _Alloc::reference reference;
|
||||
typedef typename _Alloc::const_reference const_reference;
|
||||
|
||||
/**
|
||||
* This is an SGI extension.
|
||||
* @ingroup SGIextensions
|
||||
* @doctodo
|
||||
*/
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class hash_multiset
|
||||
{
|
||||
// concept requirements
|
||||
__glibcxx_class_requires(_Value, _SGIAssignableConcept)
|
||||
__glibcxx_class_requires3(_HashFcn, size_t, _Value, _UnaryFunctionConcept)
|
||||
__glibcxx_class_requires3(_EqualKey, _Value, _Value, _BinaryPredicateConcept)
|
||||
typedef typename _Ht::const_iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
|
||||
hasher
|
||||
hash_funct() const
|
||||
{ return _M_ht.hash_funct(); }
|
||||
|
||||
key_equal
|
||||
key_eq() const
|
||||
{ return _M_ht.key_eq(); }
|
||||
|
||||
allocator_type
|
||||
get_allocator() const
|
||||
{ return _M_ht.get_allocator(); }
|
||||
|
||||
private:
|
||||
typedef hashtable<_Value, _Value, _HashFcn, _Identity<_Value>,
|
||||
_EqualKey, _Alloc> _Ht;
|
||||
_Ht _M_ht;
|
||||
public:
|
||||
hash_multiset()
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
explicit
|
||||
hash_multiset(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
|
||||
hash_multiset(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
|
||||
hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
|
||||
public:
|
||||
size_type
|
||||
size() const
|
||||
{ return _M_ht.size(); }
|
||||
|
||||
size_type
|
||||
max_size() const
|
||||
{ return _M_ht.max_size(); }
|
||||
|
||||
bool
|
||||
empty() const
|
||||
{ return _M_ht.empty(); }
|
||||
|
||||
void
|
||||
swap(hash_multiset& hs)
|
||||
{ _M_ht.swap(hs._M_ht); }
|
||||
|
||||
template <class _Val, class _HF, class _EqK, class _Al>
|
||||
friend bool
|
||||
operator==(const hash_multiset<_Val, _HF, _EqK, _Al>&,
|
||||
const hash_multiset<_Val, _HF, _EqK, _Al>&);
|
||||
|
||||
iterator
|
||||
begin() const
|
||||
{ return _M_ht.begin(); }
|
||||
|
||||
iterator
|
||||
end() const
|
||||
{ return _M_ht.end(); }
|
||||
|
||||
public:
|
||||
typedef typename _Ht::key_type key_type;
|
||||
typedef typename _Ht::value_type value_type;
|
||||
typedef typename _Ht::hasher hasher;
|
||||
typedef typename _Ht::key_equal key_equal;
|
||||
iterator
|
||||
insert(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal(__obj); }
|
||||
|
||||
template <class _InputIterator>
|
||||
void
|
||||
insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_equal(__f,__l); }
|
||||
|
||||
iterator
|
||||
insert_noresize(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal_noresize(__obj); }
|
||||
|
||||
typedef typename _Ht::size_type size_type;
|
||||
typedef typename _Ht::difference_type difference_type;
|
||||
typedef typename _Alloc::pointer pointer;
|
||||
typedef typename _Alloc::const_pointer const_pointer;
|
||||
typedef typename _Alloc::reference reference;
|
||||
typedef typename _Alloc::const_reference const_reference;
|
||||
iterator
|
||||
find(const key_type& __key) const
|
||||
{ return _M_ht.find(__key); }
|
||||
|
||||
typedef typename _Ht::const_iterator iterator;
|
||||
typedef typename _Ht::const_iterator const_iterator;
|
||||
size_type
|
||||
count(const key_type& __key) const
|
||||
{ return _M_ht.count(__key); }
|
||||
|
||||
typedef typename _Ht::allocator_type allocator_type;
|
||||
pair<iterator, iterator>
|
||||
equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
hasher hash_funct() const { return _M_ht.hash_funct(); }
|
||||
key_equal key_eq() const { return _M_ht.key_eq(); }
|
||||
allocator_type get_allocator() const { return _M_ht.get_allocator(); }
|
||||
size_type
|
||||
erase(const key_type& __key)
|
||||
{ return _M_ht.erase(__key); }
|
||||
|
||||
void
|
||||
erase(iterator __it)
|
||||
{ _M_ht.erase(__it); }
|
||||
|
||||
void
|
||||
erase(iterator __f, iterator __l)
|
||||
{ _M_ht.erase(__f, __l); }
|
||||
|
||||
void
|
||||
clear()
|
||||
{ _M_ht.clear(); }
|
||||
|
||||
public:
|
||||
hash_multiset()
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type()) {}
|
||||
explicit hash_multiset(size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type()) {}
|
||||
hash_multiset(size_type __n, const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type()) {}
|
||||
hash_multiset(size_type __n, const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a) {}
|
||||
public:
|
||||
void
|
||||
resize(size_type __hint)
|
||||
{ _M_ht.resize(__hint); }
|
||||
|
||||
size_type
|
||||
bucket_count() const
|
||||
{ return _M_ht.bucket_count(); }
|
||||
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l)
|
||||
: _M_ht(100, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n)
|
||||
: _M_ht(__n, hasher(), key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf)
|
||||
: _M_ht(__n, __hf, key_equal(), allocator_type())
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
template <class _InputIterator>
|
||||
hash_multiset(_InputIterator __f, _InputIterator __l, size_type __n,
|
||||
const hasher& __hf, const key_equal& __eql,
|
||||
const allocator_type& __a = allocator_type())
|
||||
: _M_ht(__n, __hf, __eql, __a)
|
||||
{ _M_ht.insert_equal(__f, __l); }
|
||||
size_type
|
||||
max_bucket_count() const
|
||||
{ return _M_ht.max_bucket_count(); }
|
||||
|
||||
public:
|
||||
size_type size() const { return _M_ht.size(); }
|
||||
size_type max_size() const { return _M_ht.max_size(); }
|
||||
bool empty() const { return _M_ht.empty(); }
|
||||
void swap(hash_multiset& hs) { _M_ht.swap(hs._M_ht); }
|
||||
size_type
|
||||
elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
|
||||
template <class _Val, class _HF, class _EqK, class _Al>
|
||||
friend bool operator== (const hash_multiset<_Val, _HF, _EqK, _Al>&,
|
||||
const hash_multiset<_Val, _HF, _EqK, _Al>&);
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
|
||||
{ return __hs1._M_ht == __hs2._M_ht; }
|
||||
|
||||
iterator begin() const { return _M_ht.begin(); }
|
||||
iterator end() const { return _M_ht.end(); }
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
const hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
|
||||
{ return !(__hs1 == __hs2); }
|
||||
|
||||
public:
|
||||
iterator insert(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal(__obj); }
|
||||
template <class _InputIterator>
|
||||
void insert(_InputIterator __f, _InputIterator __l)
|
||||
{ _M_ht.insert_equal(__f,__l); }
|
||||
iterator insert_noresize(const value_type& __obj)
|
||||
{ return _M_ht.insert_equal_noresize(__obj); }
|
||||
|
||||
iterator find(const key_type& __key) const { return _M_ht.find(__key); }
|
||||
|
||||
size_type count(const key_type& __key) const { return _M_ht.count(__key); }
|
||||
|
||||
pair<iterator, iterator> equal_range(const key_type& __key) const
|
||||
{ return _M_ht.equal_range(__key); }
|
||||
|
||||
size_type erase(const key_type& __key) {return _M_ht.erase(__key); }
|
||||
void erase(iterator __it) { _M_ht.erase(__it); }
|
||||
void erase(iterator __f, iterator __l) { _M_ht.erase(__f, __l); }
|
||||
void clear() { _M_ht.clear(); }
|
||||
|
||||
public:
|
||||
void resize(size_type __hint) { _M_ht.resize(__hint); }
|
||||
size_type bucket_count() const { return _M_ht.bucket_count(); }
|
||||
size_type max_bucket_count() const { return _M_ht.max_bucket_count(); }
|
||||
size_type elems_in_bucket(size_type __n) const
|
||||
{ return _M_ht.elems_in_bucket(__n); }
|
||||
};
|
||||
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator==(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2)
|
||||
{
|
||||
return __hs1._M_ht == __hs2._M_ht;
|
||||
}
|
||||
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline bool
|
||||
operator!=(const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
const hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
|
||||
return !(__hs1 == __hs2);
|
||||
}
|
||||
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs1,
|
||||
hash_multiset<_Val,_HashFcn,_EqualKey,_Alloc>& __hs2) {
|
||||
__hs1.swap(__hs2);
|
||||
}
|
||||
template <class _Val, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
inline void
|
||||
swap(hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs1,
|
||||
hash_multiset<_Val, _HashFcn, _EqualKey, _Alloc>& __hs2)
|
||||
{ __hs1.swap(__hs2); }
|
||||
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
namespace std
|
||||
{
|
||||
// Specialization of insert_iterator so that it will work for hash_set
|
||||
// and hash_multiset.
|
||||
// Specialization of insert_iterator so that it will work for hash_set
|
||||
// and hash_multiset.
|
||||
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> > {
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
|
||||
_Container* container;
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_set<_Value, _HashFcn,
|
||||
_EqualKey, _Alloc> >
|
||||
{
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_set<_Value, _HashFcn, _EqualKey, _Alloc>
|
||||
_Container;
|
||||
_Container* container;
|
||||
|
||||
insert_iterator(_Container& __x) : container(&__x) {}
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value) {
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
insert_iterator<_Container>& operator*() { return *this; }
|
||||
insert_iterator<_Container>& operator++() { return *this; }
|
||||
insert_iterator<_Container>& operator++(int) { return *this; }
|
||||
};
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> > {
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc> _Container;
|
||||
_Container* container;
|
||||
typename _Container::iterator iter;
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
insert_iterator(_Container& __x)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator(_Container& __x) : container(&__x) {}
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value) {
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
insert_iterator<_Container>& operator*() { return *this; }
|
||||
insert_iterator<_Container>& operator++() { return *this; }
|
||||
insert_iterator<_Container>& operator++(int) { return *this; }
|
||||
};
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value)
|
||||
{
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator*()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++(int)
|
||||
{ return *this; }
|
||||
};
|
||||
|
||||
template <class _Value, class _HashFcn, class _EqualKey, class _Alloc>
|
||||
class insert_iterator<__gnu_cxx::hash_multiset<_Value, _HashFcn,
|
||||
_EqualKey, _Alloc> >
|
||||
{
|
||||
protected:
|
||||
typedef __gnu_cxx::hash_multiset<_Value, _HashFcn, _EqualKey, _Alloc>
|
||||
_Container;
|
||||
_Container* container;
|
||||
typename _Container::iterator iter;
|
||||
|
||||
public:
|
||||
typedef _Container container_type;
|
||||
typedef output_iterator_tag iterator_category;
|
||||
typedef void value_type;
|
||||
typedef void difference_type;
|
||||
typedef void pointer;
|
||||
typedef void reference;
|
||||
|
||||
insert_iterator(_Container& __x)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator(_Container& __x, typename _Container::iterator)
|
||||
: container(&__x) {}
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator=(const typename _Container::value_type& __value)
|
||||
{
|
||||
container->insert(__value);
|
||||
return *this;
|
||||
}
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator*()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++()
|
||||
{ return *this; }
|
||||
|
||||
insert_iterator<_Container>&
|
||||
operator++(int) { return *this; }
|
||||
};
|
||||
} // namespace std
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Memory extensions -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2002, 2004 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
@ -82,7 +82,7 @@ namespace __gnu_cxx
|
||||
_ForwardIter __cur = __result;
|
||||
try
|
||||
{
|
||||
for ( ; __count > 0 ; --__count, ++__first, ++__cur)
|
||||
for (; __count > 0 ; --__count, ++__first, ++__cur)
|
||||
std::_Construct(&*__cur, *__first);
|
||||
return pair<_InputIter, _ForwardIter>(__first, __cur);
|
||||
}
|
||||
@ -100,19 +100,16 @@ namespace __gnu_cxx
|
||||
std::random_access_iterator_tag)
|
||||
{
|
||||
_RandomAccessIter __last = __first + __count;
|
||||
return pair<_RandomAccessIter, _ForwardIter>(
|
||||
__last,
|
||||
std::uninitialized_copy(__first, __last, __result));
|
||||
return (pair<_RandomAccessIter, _ForwardIter>
|
||||
(__last, std::uninitialized_copy(__first, __last, __result)));
|
||||
}
|
||||
|
||||
template<typename _InputIter, typename _Size, typename _ForwardIter>
|
||||
inline pair<_InputIter, _ForwardIter>
|
||||
__uninitialized_copy_n(_InputIter __first, _Size __count,
|
||||
_ForwardIter __result)
|
||||
{
|
||||
return __uninitialized_copy_n(__first, __count, __result,
|
||||
__iterator_category(__first));
|
||||
}
|
||||
{ return __uninitialized_copy_n(__first, __count, __result,
|
||||
__iterator_category(__first)); }
|
||||
|
||||
/**
|
||||
* @brief Copies the range [first,last) into result.
|
||||
@ -128,11 +125,8 @@ namespace __gnu_cxx
|
||||
inline pair<_InputIter, _ForwardIter>
|
||||
uninitialized_copy_n(_InputIter __first, _Size __count,
|
||||
_ForwardIter __result)
|
||||
{
|
||||
return __uninitialized_copy_n(__first, __count, __result,
|
||||
__iterator_category(__first));
|
||||
}
|
||||
|
||||
{ return __uninitialized_copy_n(__first, __count, __result,
|
||||
__iterator_category(__first)); }
|
||||
|
||||
/**
|
||||
* This class provides similar behavior and semantics of the standard
|
||||
@ -155,16 +149,16 @@ namespace __gnu_cxx
|
||||
* @ingroup SGIextensions
|
||||
*/
|
||||
template <class _ForwardIterator, class _Tp
|
||||
= typename std::iterator_traits<_ForwardIterator>::value_type >
|
||||
struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
|
||||
{
|
||||
/// Requests storage large enough to hold a copy of [first,last).
|
||||
temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
|
||||
: _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) { }
|
||||
|
||||
/// Destroys objects and frees storage.
|
||||
~temporary_buffer() { }
|
||||
};
|
||||
= typename std::iterator_traits<_ForwardIterator>::value_type >
|
||||
struct temporary_buffer : public _Temporary_buffer<_ForwardIterator, _Tp>
|
||||
{
|
||||
/// Requests storage large enough to hold a copy of [first,last).
|
||||
temporary_buffer(_ForwardIterator __first, _ForwardIterator __last)
|
||||
: _Temporary_buffer<_ForwardIterator, _Tp>(__first, __last) { }
|
||||
|
||||
/// Destroys objects and frees storage.
|
||||
~temporary_buffer() { }
|
||||
};
|
||||
} // namespace __gnu_cxx
|
||||
|
||||
#endif
|
||||
|
||||
@ -1,6 +1,6 @@
|
||||
// Numeric extensions -*- C++ -*-
|
||||
|
||||
// Copyright (C) 2002 Free Software Foundation, Inc.
|
||||
// Copyright (C) 2002, 2004 Free Software Foundation, Inc.
|
||||
//
|
||||
// This file is part of the GNU ISO C++ Library. This library is free
|
||||
// software; you can redistribute it and/or modify it under the
|
||||
@ -79,22 +79,25 @@ namespace __gnu_cxx
|
||||
{
|
||||
if (__n == 0)
|
||||
return identity_element(__monoid_op);
|
||||
else {
|
||||
while ((__n & 1) == 0) {
|
||||
__n >>= 1;
|
||||
__x = __monoid_op(__x, __x);
|
||||
}
|
||||
else
|
||||
{
|
||||
while ((__n & 1) == 0)
|
||||
{
|
||||
__n >>= 1;
|
||||
__x = __monoid_op(__x, __x);
|
||||
}
|
||||
|
||||
_Tp __result = __x;
|
||||
__n >>= 1;
|
||||
while (__n != 0) {
|
||||
__x = __monoid_op(__x, __x);
|
||||
if ((__n & 1) != 0)
|
||||
__result = __monoid_op(__result, __x);
|
||||
_Tp __result = __x;
|
||||
__n >>= 1;
|
||||
while (__n != 0)
|
||||
{
|
||||
__x = __monoid_op(__x, __x);
|
||||
if ((__n & 1) != 0)
|
||||
__result = __monoid_op(__result, __x);
|
||||
__n >>= 1;
|
||||
}
|
||||
return __result;
|
||||
}
|
||||
return __result;
|
||||
}
|
||||
}
|
||||
|
||||
template<typename _Tp, typename _Integer>
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user