1 files changed, 33 insertions, 9 deletions

diff --git a/src/corelib/tools/qset.h b/src/corelib/tools/qset.h
index e4688711d6..aeba6cf68d 100644
--- a/src/corelib/tools/qset.h
+++ b/src/corelib/tools/qset.h
@@ -57,15 +57,9 @@ public:
             insert(*it);
     }
 #endif
-    inline QSet(const QSet<T> &other) : q_hash(other.q_hash) {}
-
-    inline QSet<T> &operator=(const QSet<T> &other)
-        { q_hash = other.q_hash; return *this; }
-#ifdef Q_COMPILER_RVALUE_REFS
-    inline QSet(QSet &&other) : q_hash(qMove(other.q_hash)) {}
-    inline QSet<T> &operator=(QSet<T> &&other)
-        { qSwap(q_hash, other.q_hash); return *this; }
-#endif
+    // compiler-generated copy/move ctor/assignment operators are fine!
+    // compiler-generated destructor is fine!
+
     inline void swap(QSet<T> &other) { q_hash.swap(other.q_hash); }
 
     inline bool operator==(const QSet<T> &other) const
@@ -137,6 +131,7 @@ public:
         typedef QHash<T, QHashDummyValue> Hash;
         typename Hash::const_iterator i;
         friend class iterator;
+        friend class QSet<T>;
 
     public:
         typedef std::bidirectional_iterator_tag iterator_category;
@@ -191,6 +186,7 @@ public:
     inline const_iterator constFind(const T &value) const { return find(value); }
     QSet<T> &unite(const QSet<T> &other);
     QSet<T> &intersect(const QSet<T> &other);
+    bool intersects(const QSet<T> &other) const;
     QSet<T> &subtract(const QSet<T> &other);
 
     // STL compatibility
@@ -284,6 +280,34 @@ Q_INLINE_TEMPLATE QSet<T> &QSet<T>::intersect(const QSet<T> &other)
 }
 
 template <class T>
+Q_INLINE_TEMPLATE bool QSet<T>::intersects(const QSet<T> &other) const
+{
+    const bool otherIsBigger = other.size() > size();
+    const QSet &smallestSet = otherIsBigger ? *this : other;
+    const QSet &biggestSet = otherIsBigger ? other : *this;
+    const bool equalSeeds = q_hash.d->seed == other.q_hash.d->seed;
+    typename QSet::const_iterator i = smallestSet.cbegin();
+    typename QSet::const_iterator e = smallestSet.cend();
+
+    if (Q_LIKELY(equalSeeds)) {
+        // If seeds are equal we take the fast path so no hash is recalculated.
+        while (i != e) {
+            if (*biggestSet.q_hash.findNode(*i, i.i.i->h) != biggestSet.q_hash.e)
+                return true;
+            ++i;
+        }
+    } else {
+        while (i != e) {
+            if (biggestSet.contains(*i))
+                return true;
+            ++i;
+        }
+     }
+
+    return false;
+}
+
+template <class T>
 Q_INLINE_TEMPLATE QSet<T> &QSet<T>::subtract(const QSet<T> &other)
 {
     QSet<T> copy1(*this);