diff options
Diffstat (limited to 'Source/kwsys/hash_map.hxx.in')
| -rw-r--r-- | Source/kwsys/hash_map.hxx.in | 246 |
1 files changed, 147 insertions, 99 deletions
diff --git a/Source/kwsys/hash_map.hxx.in b/Source/kwsys/hash_map.hxx.in index 60c7086..3f9174f 100644 --- a/Source/kwsys/hash_map.hxx.in +++ b/Source/kwsys/hash_map.hxx.in @@ -1,14 +1,5 @@ -/*============================================================================ - KWSys - Kitware System Library - Copyright 2000-2009 Kitware, Inc., Insight Software Consortium - - Distributed under the OSI-approved BSD License (the "License"); - see accompanying file Copyright.txt for details. - - This software is distributed WITHOUT ANY WARRANTY; without even the - implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. - See the License for more information. -============================================================================*/ +/* Distributed under the OSI-approved BSD 3-Clause License. See accompanying + file Copyright.txt or https://cmake.org/licensing#kwsys for details. */ /* * Copyright (c) 1996 * Silicon Graphics Computer Systems, Inc. @@ -38,36 +29,37 @@ #define @KWSYS_NAMESPACE@_hash_map_hxx #include <@KWSYS_NAMESPACE@/hashtable.hxx> + #include <@KWSYS_NAMESPACE@/hash_fun.hxx> + #include <functional> // equal_to #if defined(_MSC_VER) -# pragma warning (push) -# pragma warning (disable:4284) -# pragma warning (disable:4786) +#pragma warning(push) +#pragma warning(disable : 4284) +#pragma warning(disable : 4786) #endif #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -# pragma set woff 1174 -# pragma set woff 1375 +#pragma set woff 1174 +#pragma set woff 1375 #endif -namespace @KWSYS_NAMESPACE@ -{ +namespace @KWSYS_NAMESPACE@ { // select1st is an extension: it is not part of the standard. template <class T1, class T2> -struct hash_select1st: - public std::unary_function<std::pair<T1, T2>, T1> +struct hash_select1st : public std::unary_function<std::pair<T1, T2>, T1> { const T1& operator()(const std::pair<T1, T2>& __x) const - { return __x.first; } + { + return __x.first; + } }; // Forward declaration of equality operator; needed for friend declaration. -template <class _Key, class _Tp, - class _HashFcn = hash<_Key>, +template <class _Key, class _Tp, class _HashFcn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<char> > class hash_map; @@ -76,13 +68,13 @@ template <class _Key, class _Tp, class _HashFn, class _EqKey, class _Alloc> bool operator==(const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&, const hash_map<_Key, _Tp, _HashFn, _EqKey, _Alloc>&); -template <class _Key, class _Tp, class _HashFcn, class _EqualKey, - class _Alloc> +template <class _Key, class _Tp, class _HashFcn, class _EqualKey, class _Alloc> class hash_map { private: - typedef hashtable<std::pair<const _Key,_Tp>,_Key,_HashFcn, - hash_select1st<const _Key,_Tp>,_EqualKey,_Alloc> _Ht; + typedef hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, + hash_select1st<const _Key, _Tp>, _EqualKey, _Alloc> + _Ht; _Ht _M_ht; public: @@ -110,34 +102,51 @@ public: allocator_type get_allocator() const { return _M_ht.get_allocator(); } public: - hash_map() : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + hash_map() + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { + } explicit hash_map(size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { + } hash_map(size_type __n, const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + : _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) {} + : _M_ht(__n, __hf, __eql, __a) + { + } template <class _InputIterator> hash_map(_InputIterator __f, _InputIterator __l) : _M_ht(100, hasher(), key_equal(), allocator_type()) - { _M_ht.insert_unique(__f, __l); } + { + _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); } + { + _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); } + { + _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); } + { + _M_ht.insert_unique(__f, __l); + } public: size_type size() const { return _M_ht.size(); } @@ -145,8 +154,7 @@ public: bool empty() const { return _M_ht.empty(); } void swap(hash_map& __hs) { _M_ht.swap(__hs._M_ht); } - friend bool operator==<>(const hash_map&, - const hash_map&); + friend bool operator==<>(const hash_map&, const hash_map&); iterator begin() { return _M_ht.begin(); } iterator end() { return _M_ht.end(); } @@ -154,31 +162,44 @@ public: const_iterator end() const { return _M_ht.end(); } public: - std::pair<iterator,bool> insert(const value_type& __obj) - { return _M_ht.insert_unique(__obj); } + std::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); } - std::pair<iterator,bool> insert_noresize(const value_type& __obj) - { return _M_ht.insert_unique_noresize(__obj); } + { + _M_ht.insert_unique(__f, __l); + } + std::pair<iterator, bool> insert_noresize(const value_type& __obj) + { + return _M_ht.insert_unique_noresize(__obj); + } iterator find(const key_type& __key) { return _M_ht.find(__key); } const_iterator find(const key_type& __key) const - { return _M_ht.find(__key); } + { + return _M_ht.find(__key); + } - _Tp& operator[](const key_type& __key) { + _Tp& operator[](const key_type& __key) + { return _M_ht.find_or_insert(value_type(__key, _Tp())).second; } size_type count(const key_type& __key) const { return _M_ht.count(__key); } std::pair<iterator, iterator> equal_range(const key_type& __key) - { return _M_ht.equal_range(__key); } - std::pair<const_iterator, const_iterator> - equal_range(const key_type& __key) const - { return _M_ht.equal_range(__key); } + { + return _M_ht.equal_range(__key); + } + std::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); } + 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(); } @@ -187,53 +208,51 @@ public: 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); } + { + return _M_ht.elems_in_bucket(__n); + } }; template <class _Key, class _Tp, class _HashFcn, class _EqlKey, class _Alloc> -bool -operator==(const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, - const hash_map<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm2) +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) { +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) +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>, +template <class _Key, class _Tp, class _HashFcn = hash<_Key>, class _EqualKey = std::equal_to<_Key>, class _Alloc = std::allocator<char> > class hash_multimap; template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc> -bool -operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1, - const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2); +bool operator==(const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm1, + const hash_multimap<_Key, _Tp, _HF, _EqKey, _Alloc>& __hm2); -template <class _Key, class _Tp, class _HashFcn, class _EqualKey, - class _Alloc> +template <class _Key, class _Tp, class _HashFcn, class _EqualKey, class _Alloc> class hash_multimap { private: typedef hashtable<std::pair<const _Key, _Tp>, _Key, _HashFcn, hash_select1st<const _Key, _Tp>, _EqualKey, _Alloc> - _Ht; + _Ht; _Ht _M_ht; public: @@ -261,34 +280,51 @@ public: allocator_type get_allocator() const { return _M_ht.get_allocator(); } public: - hash_multimap() : _M_ht(100, hasher(), key_equal(), allocator_type()) {} + hash_multimap() + : _M_ht(100, hasher(), key_equal(), allocator_type()) + { + } explicit hash_multimap(size_type __n) - : _M_ht(__n, hasher(), key_equal(), allocator_type()) {} + : _M_ht(__n, hasher(), key_equal(), allocator_type()) + { + } hash_multimap(size_type __n, const hasher& __hf) - : _M_ht(__n, __hf, key_equal(), allocator_type()) {} + : _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) {} + : _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); } + { + _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); } + { + _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); } + { + _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); } + { + _M_ht.insert_equal(__f, __l); + } public: size_type size() const { return _M_ht.size(); } @@ -296,8 +332,7 @@ public: bool empty() const { return _M_ht.empty(); } void swap(hash_multimap& __hs) { _M_ht.swap(__hs._M_ht); } - friend bool operator==<>(const hash_multimap&, - const hash_multimap&); + friend bool operator==<>(const hash_multimap&, const hash_multimap&); iterator begin() { return _M_ht.begin(); } iterator end() { return _M_ht.end(); } @@ -306,26 +341,38 @@ public: public: iterator insert(const value_type& __obj) - { return _M_ht.insert_equal(__obj); } + { + return _M_ht.insert_equal(__obj); + } template <class _InputIterator> void insert(_InputIterator __f, _InputIterator __l) - { _M_ht.insert_equal(__f,__l); } + { + _M_ht.insert_equal(__f, __l); + } iterator insert_noresize(const value_type& __obj) - { return _M_ht.insert_equal_noresize(__obj); } + { + return _M_ht.insert_equal_noresize(__obj); + } iterator find(const key_type& __key) { return _M_ht.find(__key); } const_iterator find(const key_type& __key) const - { return _M_ht.find(__key); } + { + return _M_ht.find(__key); + } size_type count(const key_type& __key) const { return _M_ht.count(__key); } std::pair<iterator, iterator> equal_range(const key_type& __key) - { return _M_ht.equal_range(__key); } - std::pair<const_iterator, const_iterator> - equal_range(const key_type& __key) const - { return _M_ht.equal_range(__key); } + { + return _M_ht.equal_range(__key); + } + std::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); } + 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(); } @@ -335,28 +382,29 @@ public: 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); } + { + return _M_ht.elems_in_bucket(__n); + } }; template <class _Key, class _Tp, class _HF, class _EqKey, class _Alloc> -bool -operator==(const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm1, - const hash_multimap<_Key,_Tp,_HF,_EqKey,_Alloc>& __hm2) +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) { +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) +inline void swap(hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm1, + hash_multimap<_Key, _Tp, _HashFcn, _EqlKey, _Alloc>& __hm2) { __hm1.swap(__hm2); } @@ -364,12 +412,12 @@ swap(hash_multimap<_Key,_Tp,_HashFcn,_EqlKey,_Alloc>& __hm1, } // namespace @KWSYS_NAMESPACE@ #if defined(__sgi) && !defined(__GNUC__) && (_MIPS_SIM != _MIPS_SIM_ABI32) -# pragma reset woff 1174 -# pragma reset woff 1375 +#pragma reset woff 1174 +#pragma reset woff 1375 #endif #if defined(_MSC_VER) -# pragma warning (pop) +#pragma warning(pop) #endif #endif |