feedc0de/boost_unordered
1
0
Fork 0
forked from boostorg/unordered
Code Pull Requests Activity

made operator [==|!=] templated again to accommodate fwd declarations

Browse Source
This commit is contained in:
joaquintides
2023-05-12 12:33:27 +02:00
parent dacc1c8234
commit d615a08f76
5 changed files with 105 additions and 75 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
include/boost/unordered/concurrent_flat_map.hpp
View File

@ -148,6 +148,11 @@ namespace boost {
detail::foa::concurrent_table<type_policy, Hash, Pred, Allocator> table_; detail::foa::concurrent_table<type_policy, Hash, Pred, Allocator> table_;
template <class K, class V, class H, class KE, class A>
bool friend operator==(
concurrent_flat_map<K, V, H, KE, A> const& lhs,
concurrent_flat_map<K, V, H, KE, A> const& rhs);
public: public:
using key_type = Key; using key_type = Key;
using mapped_type = T; using mapped_type = T;
@ -766,22 +771,23 @@ namespace boost {
hasher hash_function() const { return table_.hash_function(); } hasher hash_function() const { return table_.hash_function(); }
key_equal key_eq() const { return table_.key_eq(); } key_equal key_eq() const { return table_.key_eq(); }
/// Equality
///
friend bool operator==(
concurrent_flat_map const& lhs, concurrent_flat_map const& rhs)
{
return lhs.table_ == rhs.table_;
}
friend bool operator!=(
concurrent_flat_map const& lhs, concurrent_flat_map const& rhs)
{
return !(lhs == rhs);
}
}; };
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
bool operator==(
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
{
return lhs.table_ == rhs.table_;
}
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
bool operator!=(
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
concurrent_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
{
return !(lhs == rhs);
}
} // namespace unordered } // namespace unordered
} // namespace boost } // namespace boost

36
include/boost/unordered/unordered_flat_map.hpp
View File

@ -100,6 +100,11 @@ namespace boost {
table_type table_; table_type table_;
template <class K, class V, class H, class KE, class A>
bool friend operator==(
unordered_flat_map<K, V, H, KE, A> const& lhs,
unordered_flat_map<K, V, H, KE, A> const& rhs);
template <class K, class V, class H, class KE, class A, class Pred> template <class K, class V, class H, class KE, class A, class Pred>
typename unordered_flat_map<K, V, H, KE, A>::size_type friend erase_if( typename unordered_flat_map<K, V, H, KE, A>::size_type friend erase_if(
unordered_flat_map<K, V, H, KE, A>& set, Pred pred); unordered_flat_map<K, V, H, KE, A>& set, Pred pred);
@ -695,23 +700,24 @@ namespace boost {
hasher hash_function() const { return table_.hash_function(); } hasher hash_function() const { return table_.hash_function(); }
key_equal key_eq() const { return table_.key_eq(); } key_equal key_eq() const { return table_.key_eq(); }
/// Equality
///
friend bool operator==(
unordered_flat_map const& lhs, unordered_flat_map const& rhs)
{
return lhs.table_ == rhs.table_;
}
friend bool operator!=(
unordered_flat_map const& lhs, unordered_flat_map const& rhs)
{
return !(lhs == rhs);
}
}; };
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
bool operator==(
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
{
return lhs.table_ == rhs.table_;
}
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
bool operator!=(
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
{
return !(lhs == rhs);
}
template <class Key, class T, class Hash, class KeyEqual, class Allocator> template <class Key, class T, class Hash, class KeyEqual, class Allocator>
void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs, void swap(unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs) unordered_flat_map<Key, T, Hash, KeyEqual, Allocator>& rhs)

36
include/boost/unordered/unordered_flat_set.hpp
View File

@ -69,6 +69,11 @@ namespace boost {
table_type table_; table_type table_;
template <class K, class H, class KE, class A>
bool friend operator==(
unordered_flat_set<K, H, KE, A> const& lhs,
unordered_flat_set<K, H, KE, A> const& rhs);
template <class K, class H, class KE, class A, class Pred> template <class K, class H, class KE, class A, class Pred>
typename unordered_flat_set<K, H, KE, A>::size_type friend erase_if( typename unordered_flat_set<K, H, KE, A>::size_type friend erase_if(
unordered_flat_set<K, H, KE, A>& set, Pred pred); unordered_flat_set<K, H, KE, A>& set, Pred pred);
@ -492,23 +497,24 @@ namespace boost {
hasher hash_function() const { return table_.hash_function(); } hasher hash_function() const { return table_.hash_function(); }
key_equal key_eq() const { return table_.key_eq(); } key_equal key_eq() const { return table_.key_eq(); }
/// Equality
///
friend bool operator==(
unordered_flat_set const& lhs, unordered_flat_set const& rhs)
{
return lhs.table_ == rhs.table_;
}
friend bool operator!=(
unordered_flat_set const& lhs, unordered_flat_set const& rhs)
{
return !(lhs == rhs);
}
}; };
template <class Key, class Hash, class KeyEqual, class Allocator>
bool operator==(
unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& lhs,
unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& rhs)
{
return lhs.table_ == rhs.table_;
}
template <class Key, class Hash, class KeyEqual, class Allocator>
bool operator!=(
unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& lhs,
unordered_flat_set<Key, Hash, KeyEqual, Allocator> const& rhs)
{
return !(lhs == rhs);
}
template <class Key, class Hash, class KeyEqual, class Allocator> template <class Key, class Hash, class KeyEqual, class Allocator>
void swap(unordered_flat_set<Key, Hash, KeyEqual, Allocator>& lhs, void swap(unordered_flat_set<Key, Hash, KeyEqual, Allocator>& lhs,
unordered_flat_set<Key, Hash, KeyEqual, Allocator>& rhs) unordered_flat_set<Key, Hash, KeyEqual, Allocator>& rhs)

36
include/boost/unordered/unordered_node_map.hpp
View File

@ -187,6 +187,11 @@ namespace boost {
table_type table_; table_type table_;
template <class K, class V, class H, class KE, class A>
bool friend operator==(
unordered_node_map<K, V, H, KE, A> const& lhs,
unordered_node_map<K, V, H, KE, A> const& rhs);
template <class K, class V, class H, class KE, class A, class Pred> template <class K, class V, class H, class KE, class A, class Pred>
typename unordered_node_map<K, V, H, KE, A>::size_type friend erase_if( typename unordered_node_map<K, V, H, KE, A>::size_type friend erase_if(
unordered_node_map<K, V, H, KE, A>& set, Pred pred); unordered_node_map<K, V, H, KE, A>& set, Pred pred);
@ -847,23 +852,24 @@ namespace boost {
hasher hash_function() const { return table_.hash_function(); } hasher hash_function() const { return table_.hash_function(); }
key_equal key_eq() const { return table_.key_eq(); } key_equal key_eq() const { return table_.key_eq(); }
/// Equality
///
friend bool operator==(
unordered_node_map const& lhs, unordered_node_map const& rhs)
{
return lhs.table_ == rhs.table_;
}
friend bool operator!=(
unordered_node_map const& lhs, unordered_node_map const& rhs)
{
return !(lhs == rhs);
}
}; };
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
bool operator==(
unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
{
return lhs.table_ == rhs.table_;
}
template <class Key, class T, class Hash, class KeyEqual, class Allocator>
bool operator!=(
unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& lhs,
unordered_node_map<Key, T, Hash, KeyEqual, Allocator> const& rhs)
{
return !(lhs == rhs);
}
template <class Key, class T, class Hash, class KeyEqual, class Allocator> template <class Key, class T, class Hash, class KeyEqual, class Allocator>
void swap(unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& lhs, void swap(unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& lhs,
unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& rhs) unordered_node_map<Key, T, Hash, KeyEqual, Allocator>& rhs)

36
include/boost/unordered/unordered_node_set.hpp
View File

@ -143,6 +143,11 @@ namespace boost {
table_type table_; table_type table_;
template <class K, class H, class KE, class A>
bool friend operator==(
unordered_node_set<K, H, KE, A> const& lhs,
unordered_node_set<K, H, KE, A> const& rhs);
template <class K, class H, class KE, class A, class Pred> template <class K, class H, class KE, class A, class Pred>
typename unordered_node_set<K, H, KE, A>::size_type friend erase_if( typename unordered_node_set<K, H, KE, A>::size_type friend erase_if(
unordered_node_set<K, H, KE, A>& set, Pred pred); unordered_node_set<K, H, KE, A>& set, Pred pred);
@ -631,23 +636,24 @@ namespace boost {
hasher hash_function() const { return table_.hash_function(); } hasher hash_function() const { return table_.hash_function(); }
key_equal key_eq() const { return table_.key_eq(); } key_equal key_eq() const { return table_.key_eq(); }
/// Equality
///
friend bool operator==(
unordered_node_set const& lhs, unordered_node_set const& rhs)
{
return lhs.table_ == rhs.table_;
}
friend bool operator!=(
unordered_node_set const& lhs, unordered_node_set const& rhs)
{
return !(lhs == rhs);
}
}; };
template <class Key, class Hash, class KeyEqual, class Allocator>
bool operator==(
unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
{
return lhs.table_ == rhs.table_;
}
template <class Key, class Hash, class KeyEqual, class Allocator>
bool operator!=(
unordered_node_set<Key, Hash, KeyEqual, Allocator> const& lhs,
unordered_node_set<Key, Hash, KeyEqual, Allocator> const& rhs)
{
return !(lhs == rhs);
}
template <class Key, class Hash, class KeyEqual, class Allocator> template <class Key, class Hash, class KeyEqual, class Allocator>
void swap(unordered_node_set<Key, Hash, KeyEqual, Allocator>& lhs, void swap(unordered_node_set<Key, Hash, KeyEqual, Allocator>& lhs,
unordered_node_set<Key, Hash, KeyEqual, Allocator>& rhs) unordered_node_set<Key, Hash, KeyEqual, Allocator>& rhs)