Skip to content

R
riscv-gcc-1
Commit 95cefe5f by Paolo Carlini Committed by Paolo Carlini
Options

hashtable_policy.h: Uglify all the names. 

2006-09-19  Paolo Carlini  <pcarlini@suse.de>

	* include/tr1/hashtable_policy.h: Uglify all the names.
	* include/tr1/hashtable: Likewise.
	* include/tr1/unordered_map: Likewise.
	* include/tr1/unordered_set: Likewise.
	* include/tr1/functional: Uglify struct hash names.
	* include/tr1/cmath: Uglify namespace detail to __detail.

From-SVN: r117052
parent b5387733
Showing with 206 additions and 183 deletions
libstdc++-v3/ChangeLog
2006-09-19 Paolo Carlini <pcarlini@suse.de>
* include/tr1/hashtable_policy.h: Uglify all the names.
* include/tr1/hashtable: Likewise.
* include/tr1/unordered_map: Likewise.
* include/tr1/unordered_set: Likewise.
* include/tr1/functional: Uglify struct hash names.
* include/tr1/cmath: Uglify namespace detail to __detail.
2006-09-18 Benjamin Kosnik <bkoz@redhat.com>
* testsuite/util/regression/res_mng: Remove.
......
libstdc++-v3/include/tr1/cmath
......@@ -368,21 +368,23 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
using std::atan;
// Workaround for c++/21682.
namespace detail
namespace __detail
{
template<typename _Tp, typename _Up>
inline typename __gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value
|| std::__is_floating<_Up>::__value,
typename std::tr1::__promote_2<_Tp, _Up>::__type>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename std::tr1::__promote_2<_Tp, _Up>::__type __type;
return std::atan2(__type(__y), __type(__x));
}
} // namespace detail
inline typename
__gnu_cxx::__enable_if<std::__is_floating<_Tp>::__value
|| std::__is_floating<_Up>::__value,
typename
std::tr1::__promote_2<_Tp, _Up>::__type>::__type
atan2(_Tp __y, _Up __x)
{
typedef typename std::tr1::__promote_2<_Tp, _Up>::__type __type;
return std::atan2(__type(__y), __type(__x));
}
} // namespace __detail
using std::atan2;
using detail::atan2;
using __detail::atan2;
inline float
atanh(float __x)
......
libstdc++-v3/include/tr1/unordered_map
......@@ -43,120 +43,124 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
// XXX When we get typedef templates these class definitions
// will be unnecessary.
template<class Key, class T,
class Hash = hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<std::pair<const Key, T> >,
bool cache_hash_code = false>
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
bool __cache_hash_code = false>
class unordered_map
: public hashtable<Key, std::pair<const Key, T>, Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, false, true>
: public _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, true>
{
typedef hashtable<Key, std::pair<const Key, T>, Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, false, true>
Base;
typedef _Hashtable<_Key, std::pair<const _Key, _Tp>, _Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, true>
_Base;
public:
typedef typename Base::size_type size_type;
typedef typename Base::hasher hasher;
typedef typename Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_map(size_type n = 10,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base(n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a)
unordered_map(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
template<typename InputIterator>
unordered_map(InputIterator f, InputIterator l,
size_type n = 10,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base (f, l, n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a)
template<typename _InputIterator>
unordered_map(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
};
template<class Key, class T,
class Hash = hash<Key>,
class Pred = std::equal_to<Key>,
class Alloc = std::allocator<std::pair<const Key, T> >,
bool cache_hash_code = false>
template<class _Key, class _Tp,
class _Hash = hash<_Key>,
class _Pred = std::equal_to<_Key>,
class _Alloc = std::allocator<std::pair<const _Key, _Tp> >,
bool __cache_hash_code = false>
class unordered_multimap
: public hashtable <Key, std::pair<const Key, T>,
Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, false, false>
: public _Hashtable<_Key, std::pair<const _Key, _Tp>,
_Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, false>
{
typedef hashtable <Key, std::pair<const Key, T>,
Alloc,
std::_Select1st<std::pair<const Key, T> >, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, false, false>
Base;
typedef _Hashtable<_Key, std::pair<const _Key, _Tp>,
_Alloc,
std::_Select1st<std::pair<const _Key, _Tp> >, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, false, false>
_Base;
public:
typedef typename Base::size_type size_type;
typedef typename Base::hasher hasher;
typedef typename Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_multimap(size_type n = 10,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base (n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a)
unordered_multimap(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
template<typename InputIterator>
unordered_multimap(InputIterator f, InputIterator l,
typename Base::size_type n = 0,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base (f, l, n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(),
eql, std::_Select1st<std::pair<const Key, T> >(), a)
template<typename _InputIterator>
unordered_multimap(_InputIterator __f, _InputIterator __l,
typename _Base::size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(),
__eql, std::_Select1st<std::pair<const _Key, _Tp> >(), __a)
{ }
};
template<class Key, class T, class Hash, class Pred, class Alloc,
bool cache_hash_code>
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(unordered_map<Key, T, Hash, Pred, Alloc, cache_hash_code>& x,
unordered_map<Key, T, Hash, Pred, Alloc, cache_hash_code>& y)
{ x.swap(y); }
template<class Key, class T, class Hash, class Pred, class Alloc,
bool cache_hash_code>
swap(unordered_map<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
unordered_map<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
template<class _Key, class _Tp, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(unordered_multimap<Key, T, Hash, Pred, Alloc, cache_hash_code>& x,
unordered_multimap<Key, T, Hash, Pred, Alloc, cache_hash_code>& y)
{ x.swap(y); }
swap(unordered_multimap<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
unordered_multimap<_Key, _Tp, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE
}
......
libstdc++-v3/include/tr1/unordered_set
......@@ -43,114 +43,122 @@ _GLIBCXX_BEGIN_NAMESPACE(tr1)
// XXX When we get typedef templates these class definitions
// will be unnecessary.
template<class Value,
class Hash = hash<Value>,
class Pred = std::equal_to<Value>,
class Alloc = std::allocator<Value>,
bool cache_hash_code = false>
template<class _Value,
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value>,
bool __cache_hash_code = false>
class unordered_set
: public hashtable<Value, Value, Alloc,
std::_Identity<Value>, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, true, true>
: public _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, true>
{
typedef hashtable<Value, Value, Alloc,
std::_Identity<Value>, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, true, true>
Base;
typedef _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, true>
_Base;
public:
typedef typename Base::size_type size_type;
typedef typename Base::hasher hasher;
typedef typename Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_set(size_type n = 10,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base(n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a)
unordered_set(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
template<typename InputIterator>
unordered_set(InputIterator f, InputIterator l,
size_type n = 10,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base(f, l, n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a)
template<typename _InputIterator>
unordered_set(_InputIterator __f, _InputIterator __l,
size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
};
template<class Value,
class Hash = hash<Value>,
class Pred = std::equal_to<Value>,
class Alloc = std::allocator<Value>,
bool cache_hash_code = false>
template<class _Value,
class _Hash = hash<_Value>,
class _Pred = std::equal_to<_Value>,
class _Alloc = std::allocator<_Value>,
bool __cache_hash_code = false>
class unordered_multiset
: public hashtable <Value, Value, Alloc,
std::_Identity<Value>, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, true, false>
: public _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, false>
{
typedef hashtable<Value, Value, Alloc,
std::_Identity<Value>, Pred,
Hash, detail::mod_range_hashing,
detail::default_ranged_hash,
detail::prime_rehash_policy,
cache_hash_code, true, false>
Base;
typedef _Hashtable<_Value, _Value, _Alloc,
std::_Identity<_Value>, _Pred,
_Hash, __detail::_Mod_range_hashing,
__detail::_Default_ranged_hash,
__detail::_Prime_rehash_policy,
__cache_hash_code, true, false>
_Base;
public:
typedef typename Base::size_type size_type;
typedef typename Base::hasher hasher;
typedef typename Base::key_equal key_equal;
typedef typename Base::allocator_type allocator_type;
typedef typename _Base::size_type size_type;
typedef typename _Base::hasher hasher;
typedef typename _Base::key_equal key_equal;
typedef typename _Base::allocator_type allocator_type;
explicit
unordered_multiset(size_type n = 10,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base(n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a)
unordered_multiset(size_type __n = 10,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
template<typename InputIterator>
unordered_multiset(InputIterator f, InputIterator l,
typename Base::size_type n = 0,
const hasher& hf = hasher(),
const key_equal& eql = key_equal(),
const allocator_type& a = allocator_type())
: Base(f, l, n, hf, detail::mod_range_hashing(),
detail::default_ranged_hash(), eql, std::_Identity<Value>(), a)
template<typename _InputIterator>
unordered_multiset(_InputIterator __f, _InputIterator __l,
typename _Base::size_type __n = 0,
const hasher& __hf = hasher(),
const key_equal& __eql = key_equal(),
const allocator_type& __a = allocator_type())
: _Base(__f, __l, __n, __hf, __detail::_Mod_range_hashing(),
__detail::_Default_ranged_hash(), __eql,
std::_Identity<_Value>(), __a)
{ }
};
template<class Value, class Hash, class Pred, class Alloc,
bool cache_hash_code>
template<class _Value, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap (unordered_set<Value, Hash, Pred, Alloc, cache_hash_code>& x,
unordered_set<Value, Hash, Pred, Alloc, cache_hash_code>& y)
{ x.swap(y); }
template<class Value, class Hash, class Pred, class Alloc,
bool cache_hash_code>
swap (unordered_set<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
unordered_set<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
template<class _Value, class _Hash, class _Pred, class _Alloc,
bool __cache_hash_code>
inline void
swap(unordered_multiset<Value, Hash, Pred, Alloc, cache_hash_code>& x,
unordered_multiset<Value, Hash, Pred, Alloc, cache_hash_code>& y)
{ x.swap(y); }
swap(unordered_multiset<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __x,
unordered_multiset<_Value, _Hash, _Pred,
_Alloc, __cache_hash_code>& __y)
{ __x.swap(__y); }
_GLIBCXX_END_NAMESPACE
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment