From 02abc8c9a4793cb89b69334d700f203efe32f2fd Mon Sep 17 00:00:00 2001 From: Daniel James Date: Thu, 26 May 2016 23:12:36 +0100 Subject: [PATCH] Truncate ids in tests even more. Whatever version of xsltproc I'm not using generates even longer id numbers, which means that the base id needs to be further truncated to make space for them. --- test/more/run-tests.py | 2 +- test/more/tests/libs/array.gold | 24 +++--- test/more/tests/libs/hash-ref.gold | 108 ++++++++++++------------ test/more/tests/libs/unordered-ref.gold | 48 +++++------ 4 files changed, 91 insertions(+), 91 deletions(-) diff --git a/test/more/run-tests.py b/test/more/run-tests.py index 393e8cc..c91f84c 100755 --- a/test/more/run-tests.py +++ b/test/more/run-tests.py @@ -95,7 +95,7 @@ def normalize_boostbook_ids(doc): if(match): # Truncate id name, as it sometimes has different lengths... match2 = re.match("(.*?)([^.]*?)(_?id)", match.group(1)) - base = match2.group(1) + match2.group(2)[:14] + match2.group(3) + base = match2.group(1) + match2.group(2)[:7] + match2.group(3) count = id_bases[base] + 1 id_bases[base] = count ids[id] = base + str(count) + match.group(3) diff --git a/test/more/tests/libs/array.gold b/test/more/tests/libs/array.gold index af19350..f76ffae 100644 --- a/test/more/tests/libs/array.gold +++ b/test/more/tests/libs/array.gold @@ -87,13 +87,13 @@ template<typename T, std::size_t N> bool operator!=(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator<(const array<T, N>&, const array<T, N>&); + bool operator<(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator>(const array<T, N>&, const array<T, N>&); + bool operator>(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator<=(const array<T, N>&, const array<T, N>&); + bool operator<=(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator>=(const array<T, N>&, const array<T, N>&); + bool operator>=(const array<T, N>&, const array<T, N>&); } Class template array3boost::arraySTL compliant container wrapper for arrays of constant size// In header: <boost/array.hpp> @@ -163,13 +163,13 @@ template<typename T, std::size_t N> bool operator!=(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator<(const array<T, N>&, const array<T, N>&); + bool operator<(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator>(const array<T, N>&, const array<T, N>&); + bool operator>(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator<=(const array<T, N>&, const array<T, N>&); + bool operator<=(const array<T, N>&, const array<T, N>&); template<typename T, std::size_t N> - bool operator>=(const array<T, N>&, const array<T, N>&);Description<anchor id="boost.arrayconstruct-copy-destruct"/><computeroutput>array</computeroutput> + <phrase role="keyword">bool</phrase> <link linkend="boost.array.operato_id4"><phrase role="keyword">operator</phrase><phrase role="special">>=</phrase></link><phrase role="special">(</phrase><phrase role="keyword">const</phrase> <link linkend="boost.array">array</link><phrase role="special"><</phrase><phrase role="identifier">T</phrase><phrase role="special">,</phrase> <phrase role="identifier">N</phrase><phrase role="special">></phrase><phrase role="special">&</phrase><phrase role="special">,</phrase> <phrase role="keyword">const</phrase> <link linkend="boost.array">array</link><phrase role="special"><</phrase><phrase role="identifier">T</phrase><phrase role="special">,</phrase> <phrase role="identifier">N</phrase><phrase role="special">></phrase><phrase role="special">&</phrase><phrase role="special">)</phrase><phrase role="special">;</phrase></synopsis></refsynopsisdiv><refsect1><title>Description<anchor id="boost.arrayconstruct-copy-destruct"/><computeroutput>array</computeroutput> public construct/copy/destructtemplate<typename U> array& operator=(const array<U, N>& other);bool operator!=(const array<T, N>& x, const array<T, N>& y);Returns:!(x == y)template<typename T, std::size_t N> - bool operator<(const array<T, N>& x, const array<T, N>& y);bool operator<(const array<T, N>& x, const array<T, N>& y);Returns:std::lexicographical_compare(x.begin(), x.end(), y.begin(), y.end())template<typename T, std::size_t N> - bool operator>(const array<T, N>& x, const array<T, N>& y);bool operator>(const array<T, N>& x, const array<T, N>& y);Returns:y < xtemplate<typename T, std::size_t N> - bool operator<=(const array<T, N>& x, const array<T, N>& y);bool operator<=(const array<T, N>& x, const array<T, N>& y);Returns:!(y < x)template<typename T, std::size_t N> - bool operator>=(const array<T, N>& x, const array<T, N>& y);bool operator>=(const array<T, N>& x, const array<T, N>& y);Returns:!(x < y) diff --git a/test/more/tests/libs/hash-ref.gold b/test/more/tests/libs/hash-ref.gold index 6404700..e2a1815 100644 --- a/test/more/tests/libs/hash-ref.gold +++ b/test/more/tests/libs/hash-ref.gold @@ -13,24 +13,24 @@ namespace boost { template<typename T> struct hash; - template<> struct hash<bool>; - template<> struct hash<char>; - template<> struct hash<signed char>; - template<> struct hash<unsigned char>; - template<> struct hash<wchar_t>; - template<> struct hash<short>; - template<> struct hash<unsigned short>; - template<> struct hash<int>; - template<> struct hash<unsigned int>; - template<> struct hash<long>; - template<> struct hash<unsigned long>; - template<> struct hash<long long>; - template<> struct hash<unsigned long long>; - template<> struct hash<float>; - template<> struct hash<double>; - template<> struct hash<long double>; - template<> struct hash<std::string>; - template<> struct hash<std::wstring>; + template<> struct hash<bool>; + template<> struct hash<char>; + template<> struct hash<signed char>; + template<> struct hash<unsigned char>; + template<> struct hash<wchar_t>; + template<> struct hash<short>; + template<> struct hash<unsigned short>; + template<> struct hash<int>; + template<> struct hash<unsigned int>; + template<> struct hash<long>; + template<> struct hash<unsigned long>; + template<> struct hash<long long>; + template<> struct hash<unsigned long long>; + template<> struct hash<float>; + template<> struct hash<double>; + template<> struct hash<long double>; + template<> struct hash<std::string>; + template<> struct hash<std::wstring>; template<typename T> struct hash<T*>; // Support functions (Boost extension). @@ -259,129 +259,129 @@ Throws: Only throws if hash_value(T) throws. - Struct hash<bool>3boost::hash<bool>// In header: <boost/functional/hash.hpp> + Struct hash<bool>3boost::hash<bool>// In header: <boost/functional/hash.hpp> -struct hash<bool> { +struct hash<bool> { std::size_t operator()(bool) const; };Descriptionstd::size_t operator()(bool val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<char>3boost::hash<char>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<char>3boost::hash<char>// In header: <boost/functional/hash.hpp> -struct hash<char> { +struct hash<char> { std::size_t operator()(char) const; };Descriptionstd::size_t operator()(char val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<signed char>3boost::hash<signed char>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<signed char>3boost::hash<signed char>// In header: <boost/functional/hash.hpp> -struct hash<signed char> { +struct hash<signed char> { std::size_t operator()(signed char) const; };Descriptionstd::size_t operator()(signed char val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned char>3boost::hash<unsigned char>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned char>3boost::hash<unsigned char>// In header: <boost/functional/hash.hpp> -struct hash<unsigned char> { +struct hash<unsigned char> { std::size_t operator()(unsigned char) const; };Descriptionstd::size_t operator()(unsigned char val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<wchar_t>3boost::hash<wchar_t>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<wchar_t>3boost::hash<wchar_t>// In header: <boost/functional/hash.hpp> -struct hash<wchar_t> { +struct hash<wchar_t> { std::size_t operator()(wchar_t) const; };Descriptionstd::size_t operator()(wchar_t val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<short>3boost::hash<short>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<short>3boost::hash<short>// In header: <boost/functional/hash.hpp> -struct hash<short> { +struct hash<short> { std::size_t operator()(short) const; };Descriptionstd::size_t operator()(short val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned short>3boost::hash<unsigned short>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned short>3boost::hash<unsigned short>// In header: <boost/functional/hash.hpp> -struct hash<unsigned short> { +struct hash<unsigned short> { std::size_t operator()(unsigned short) const; };Descriptionstd::size_t operator()(unsigned short val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<int>3boost::hash<int>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<int>3boost::hash<int>// In header: <boost/functional/hash.hpp> -struct hash<int> { +struct hash<int> { std::size_t operator()(int) const; };Descriptionstd::size_t operator()(int val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned int>3boost::hash<unsigned int>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned int>3boost::hash<unsigned int>// In header: <boost/functional/hash.hpp> -struct hash<unsigned int> { +struct hash<unsigned int> { std::size_t operator()(unsigned int) const; };Descriptionstd::size_t operator()(unsigned int val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<long>3boost::hash<long>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<long>3boost::hash<long>// In header: <boost/functional/hash.hpp> -struct hash<long> { +struct hash<long> { std::size_t operator()(long) const; };Descriptionstd::size_t operator()(long val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned long>3boost::hash<unsigned long>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned long>3boost::hash<unsigned long>// In header: <boost/functional/hash.hpp> -struct hash<unsigned long> { +struct hash<unsigned long> { std::size_t operator()(unsigned long) const; };Descriptionstd::size_t operator()(unsigned long val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<long long>3boost::hash<long long>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<long long>3boost::hash<long long>// In header: <boost/functional/hash.hpp> -struct hash<long long> { +struct hash<long long> { std::size_t operator()(long long) const; };Descriptionstd::size_t operator()(long long val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned long long>3boost::hash<unsigned long long>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<unsigned long long>3boost::hash<unsigned long long>// In header: <boost/functional/hash.hpp> -struct hash<unsigned long long> { +struct hash<unsigned long long> { std::size_t operator()(unsigned long long) const; };Descriptionstd::size_t operator()(unsigned long long val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<float>3boost::hash<float>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<float>3boost::hash<float>// In header: <boost/functional/hash.hpp> -struct hash<float> { +struct hash<float> { std::size_t operator()(float) const; };Descriptionstd::size_t operator()(float val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<double>3boost::hash<double>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<double>3boost::hash<double>// In header: <boost/functional/hash.hpp> -struct hash<double> { +struct hash<double> { std::size_t operator()(double) const; };Descriptionstd::size_t operator()(double val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<long double>3boost::hash<long double>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<long double>3boost::hash<long double>// In header: <boost/functional/hash.hpp> -struct hash<long double> { +struct hash<long double> { std::size_t operator()(long double) const; };Descriptionstd::size_t operator()(long double val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<std::string>3boost::hash<std::string>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<std::string>3boost::hash<std::string>// In header: <boost/functional/hash.hpp> -struct hash<std::string> { +struct hash<std::string> { std::size_t operator()(std::string const&) const; };Descriptionstd::size_t operator()(std::string const& val) const;Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<std::wstring>3boost::hash<std::wstring>// In header: <boost/functional/hash.hpp> + ?>Returns:Unspecified in TR1, except that equal arguments yield the same result.hash_value(val) in Boost.Throws:Doesn't throwStruct hash<std::wstring>3boost::hash<std::wstring>// In header: <boost/functional/hash.hpp> -struct hash<std::wstring> { +struct hash<std::wstring> { std::size_t operator()(std::wstring const&) const; };Descriptionstd::size_t operator()(std::wstring const& val) const;typename Alloc = std::allocator<Value> > class unordered_set; template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&, + bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&, unordered_set<Value, Hash, Pred, Alloc> const&); template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&, + bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&, unordered_set<Value, Hash, Pred, Alloc> const&); template<typename Value, typename Hash, typename Pred, typename Alloc> void swap(unordered_set<Value, Hash, Pred, Alloc>&, @@ -19,10 +19,10 @@ typename Alloc = std::allocator<Value> > class unordered_multiset; template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const&, + bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const&, unordered_multiset<Value, Hash, Pred, Alloc> const&); template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const&, + bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const&, unordered_multiset<Value, Hash, Pred, Alloc> const&); template<typename Value, typename Hash, typename Pred, typename Alloc> void swap(unordered_multiset<Value, Hash, Pred, Alloc>&, @@ -141,10 +141,10 @@ // Equality Comparisons template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&, + bool operator==(unordered_set<Value, Hash, Pred, Alloc> const&, unordered_set<Value, Hash, Pred, Alloc> const&); template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&, + bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const&, unordered_set<Value, Hash, Pred, Alloc> const&); // swap @@ -366,12 +366,12 @@ ?>Effects:Changes the container's maximum load factor, using z as a hint.void rehash(size_type n);Changes the number of buckets so that there at least n buckets, and so that the load factor is less than the maximum load factor.Invalidates iterators, and changes the order of elements. Pointers and references to elements are not invalidated.Throws:The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.<anchor id="id68-bb"/><computeroutput>unordered_set</computeroutput> Equality Comparisonstemplate<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_set<Value, Hash, Pred, Alloc> const& x, + bool operator==(unordered_set<Value, Hash, Pred, Alloc> const& x, unordered_set<Value, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have equivalent equality predicates.template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const& x, + bool operator!=(unordered_set<Value, Hash, Pred, Alloc> const& x, unordered_set<Value, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have @@ -494,10 +494,10 @@ // Equality Comparisons template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const&, + bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const&, unordered_multiset<Value, Hash, Pred, Alloc> const&); template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const&, + bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const&, unordered_multiset<Value, Hash, Pred, Alloc> const&); // swap @@ -719,12 +719,12 @@ ?>Effects:Changes the container's maximum load factor, using z as a hint.void rehash(size_type n);Changes the number of buckets so that there at least n buckets, and so that the load factor is less than the maximum load factor.Invalidates iterators, and changes the order of elements. Pointers and references to elements are not invalidated.Throws:The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.<anchor id="id137-bb"/><computeroutput>unordered_multiset</computeroutput> Equality Comparisonstemplate<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const& x, + bool operator==(unordered_multiset<Value, Hash, Pred, Alloc> const& x, unordered_multiset<Value, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have equivalent equality predicates.template<typename Value, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const& x, + bool operator!=(unordered_multiset<Value, Hash, Pred, Alloc> const& x, unordered_multiset<Value, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have @@ -742,11 +742,11 @@ class unordered_map; template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, unordered_map<Key, Mapped, Hash, Pred, Alloc> const&); template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, unordered_map<Key, Mapped, Hash, Pred, Alloc> const&); template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> @@ -758,11 +758,11 @@ class unordered_multimap; template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&); template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&); template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> @@ -887,11 +887,11 @@ // Equality Comparisons template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, unordered_map<Key, Mapped, Hash, Pred, Alloc> const&); template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const&, unordered_map<Key, Mapped, Hash, Pred, Alloc> const&); // swap @@ -1124,13 +1124,13 @@ list-presentation="table" ?>Throws:The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.<anchor id="id210-bb"/><computeroutput>unordered_map</computeroutput> Equality Comparisonstemplate<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const& x, + bool operator==(unordered_map<Key, Mapped, Hash, Pred, Alloc> const& x, unordered_map<Key, Mapped, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have equivalent equality predicates.template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const& x, + bool operator!=(unordered_map<Key, Mapped, Hash, Pred, Alloc> const& x, unordered_map<Key, Mapped, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have @@ -1256,11 +1256,11 @@ // Equality Comparisons template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&); template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, + bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&, unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const&); // swap @@ -1487,13 +1487,13 @@ list-presentation="table" ?>Throws:The function has no effect if an exception is thrown, unless it is thrown by the container's hash function or comparison function.<anchor id="id279-bb"/><computeroutput>unordered_multimap</computeroutput> Equality Comparisonstemplate<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& x, + bool operator==(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& x, unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have equivalent equality predicates.template<typename Key, typename Mapped, typename Hash, typename Pred, typename Alloc> - bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& x, + bool operator!=(unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& x, unordered_multimap<Key, Mapped, Hash, Pred, Alloc> const& y);Notes:This is a boost extension.Behavior is undefined if the two containers don't have