Make QByteArray comparison operators hidden friends

Also for QByteArray::FromBase64Result, to reduce ADL noise.

Add explicit overload for comparison with nullptr to avoid
ambiguous overload errors with '0' comparisons.

Change-Id: I7ff9dbc90581707856c10cf7fb835175dfcdb55e
Reviewed-by: Allan Sandfeld Jensen <allan.jensen@qt.io>

2 files changed, 86 insertions, 108 deletions

diff --git a/src/corelib/text/qbytearray.cpp b/src/corelib/text/qbytearray.cpp
index 75552fa3dd..ac46c6f0b7 100644
--- a/src/corelib/text/qbytearray.cpp
+++ b/src/corelib/text/qbytearray.cpp
@@ -3008,9 +3008,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     array to a QString before doing the comparison.
 */
 
-/*! \fn bool operator==(const QByteArray &a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator==(const QByteArray &a1, const QByteArray &a2)
     \overload
 
     Returns \c true if byte array \a a1 is equal to byte array \a a2;
@@ -3019,9 +3017,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator==(const QByteArray &a1, const char *a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator==(const QByteArray &a1, const char *a2)
     \overload
 
     Returns \c true if byte array \a a1 is equal to the '\\0'-terminated string
@@ -3030,9 +3026,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator==(const char *a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator==(const char *a1, const QByteArray &a2)
     \overload
 
     Returns \c true if '\\0'-terminated string \a a1 is equal to byte array \a
@@ -3041,9 +3035,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator!=(const QByteArray &a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator!=(const QByteArray &a1, const QByteArray &a2)
     \overload
 
     Returns \c true if byte array \a a1 is not equal to byte array \a a2;
@@ -3052,9 +3044,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator!=(const QByteArray &a1, const char *a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator!=(const QByteArray &a1, const char *a2)
     \overload
 
     Returns \c true if byte array \a a1 is not equal to the '\\0'-terminated
@@ -3063,9 +3053,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator!=(const char *a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator!=(const char *a1, const QByteArray &a2)
     \overload
 
     Returns \c true if '\\0'-terminated string \a a1 is not equal to byte array
@@ -3074,9 +3062,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator<(const QByteArray &a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator<(const QByteArray &a1, const QByteArray &a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically less than byte array
@@ -3085,9 +3071,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn inline bool operator<(const QByteArray &a1, const char *a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator<(const QByteArray &a1, const char *a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically less than the
@@ -3096,9 +3080,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator<(const char *a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator<(const char *a1, const QByteArray &a2)
     \overload
 
     Returns \c true if '\\0'-terminated string \a a1 is lexically less than byte
@@ -3107,9 +3089,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator<=(const QByteArray &a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator<=(const QByteArray &a1, const QByteArray &a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically less than or equal
@@ -3118,9 +3098,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator<=(const QByteArray &a1, const char *a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator<=(const QByteArray &a1, const char *a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically less than or equal to the
@@ -3129,9 +3107,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator<=(const char *a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator<=(const char *a1, const QByteArray &a2)
     \overload
 
     Returns \c true if '\\0'-terminated string \a a1 is lexically less than or
@@ -3140,9 +3116,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator>(const QByteArray &a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator>(const QByteArray &a1, const QByteArray &a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically greater than byte
@@ -3151,9 +3125,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator>(const QByteArray &a1, const char *a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator>(const QByteArray &a1, const char *a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically greater than the
@@ -3162,9 +3134,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator>(const char *a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator>(const char *a1, const QByteArray &a2)
     \overload
 
     Returns \c true if '\\0'-terminated string \a a1 is lexically greater than
@@ -3173,9 +3143,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator>=(const QByteArray &a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator>=(const QByteArray &a1, const QByteArray &a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically greater than or
@@ -3184,9 +3152,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator>=(const QByteArray &a1, const char *a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator>=(const QByteArray &a1, const char *a2)
     \overload
 
     Returns \c true if byte array \a a1 is lexically greater than or equal to
@@ -3195,9 +3161,7 @@ QDataStream &operator>>(QDataStream &in, QByteArray &ba)
     \sa QByteArray::compare()
 */
 
-/*! \fn bool operator>=(const char *a1, const QByteArray &a2)
-    \relates QByteArray
-
+/*! \fn bool QByteArray::operator>=(const char *a1, const QByteArray &a2)
     \overload
 
     Returns \c true if '\\0'-terminated string \a a1 is lexically greater than
@@ -4723,8 +4687,7 @@ QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude, const QByteA
 */
 
 /*!
-    \fn bool operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
-    \relates QByteArray::FromBase64Result
+    \fn bool QByteArray::FromBase64Result::operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
 
     Returns \c true if \a lhs and \a rhs are equal, otherwise returns \c false.
 
@@ -4734,8 +4697,7 @@ QByteArray QByteArray::toPercentEncoding(const QByteArray &exclude, const QByteA
 */
 
 /*!
-    \fn bool operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
-    \relates QByteArray::FromBase64Result
+    \fn bool QByteArray::FromBase64Result::operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
 
     Returns \c true if \a lhs and \a rhs are different, otherwise returns \c false.
 */
diff --git a/src/corelib/text/qbytearray.h b/src/corelib/text/qbytearray.h
index c2d65e2c55..c97f3787a6 100644
--- a/src/corelib/text/qbytearray.h
+++ b/src/corelib/text/qbytearray.h
@@ -337,6 +337,57 @@ public:
     QT_ASCII_CAST_WARN inline bool operator<=(const QString &s2) const;
     QT_ASCII_CAST_WARN inline bool operator>=(const QString &s2) const;
 #endif
+    friend inline bool operator==(const QByteArray &a1, const QByteArray &a2) noexcept
+    { return QByteArrayView(a1) == QByteArrayView(a2); }
+    friend inline bool operator==(const QByteArray &a1, const char *a2) noexcept
+    { return a2 ? QtPrivate::compareMemory(a1, a2) == 0 : a1.isEmpty(); }
+    friend inline bool operator==(const char *a1, const QByteArray &a2) noexcept
+    { return a1 ? QtPrivate::compareMemory(a1, a2) == 0 : a2.isEmpty(); }
+    friend inline bool operator!=(const QByteArray &a1, const QByteArray &a2) noexcept
+    { return !(a1==a2); }
+    friend inline bool operator!=(const QByteArray &a1, const char *a2) noexcept
+    { return a2 ? QtPrivate::compareMemory(a1, a2) != 0 : !a1.isEmpty(); }
+    friend inline bool operator!=(const char *a1, const QByteArray &a2) noexcept
+    { return a1 ? QtPrivate::compareMemory(a1, a2) != 0 : !a2.isEmpty(); }
+    friend inline bool operator<(const QByteArray &a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) < 0; }
+    friend inline bool operator<(const QByteArray &a1, const char *a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) < 0; }
+    friend inline bool operator<(const char *a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) < 0; }
+    friend inline bool operator<=(const QByteArray &a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) <= 0; }
+    friend inline bool operator<=(const QByteArray &a1, const char *a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) <= 0; }
+    friend inline bool operator<=(const char *a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) <= 0; }
+    friend inline bool operator>(const QByteArray &a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) > 0; }
+    friend inline bool operator>(const QByteArray &a1, const char *a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) > 0; }
+    friend inline bool operator>(const char *a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) > 0; }
+    friend inline bool operator>=(const QByteArray &a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) >= 0; }
+    friend inline bool operator>=(const QByteArray &a1, const char *a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) >= 0; }
+    friend inline bool operator>=(const char *a1, const QByteArray &a2) noexcept
+    { return QtPrivate::compareMemory(a1, a2) >= 0; }
+
+    // Check isEmpty() instead of isNull() for backwards compatibility.
+    friend inline bool operator==(const QByteArray &a1, std::nullptr_t) noexcept { return a1.isEmpty(); }
+    friend inline bool operator!=(const QByteArray &a1, std::nullptr_t) noexcept { return !a1.isEmpty(); }
+    friend inline bool operator< (const QByteArray &  , std::nullptr_t) noexcept { return false; }
+    friend inline bool operator> (const QByteArray &a1, std::nullptr_t) noexcept { return !a1.isEmpty(); }
+    friend inline bool operator<=(const QByteArray &a1, std::nullptr_t) noexcept { return a1.isEmpty(); }
+    friend inline bool operator>=(const QByteArray &  , std::nullptr_t) noexcept { return true; }
+
+    friend inline bool operator==(std::nullptr_t, const QByteArray &a2) noexcept { return a2 == nullptr; }
+    friend inline bool operator!=(std::nullptr_t, const QByteArray &a2) noexcept { return a2 != nullptr; }
+    friend inline bool operator< (std::nullptr_t, const QByteArray &a2) noexcept { return a2 >  nullptr; }
+    friend inline bool operator> (std::nullptr_t, const QByteArray &a2) noexcept { return a2 <  nullptr; }
+    friend inline bool operator<=(std::nullptr_t, const QByteArray &a2) noexcept { return a2 >= nullptr; }
+    friend inline bool operator>=(std::nullptr_t, const QByteArray &a2) noexcept { return a2 <= nullptr; }
 
     short toShort(bool *ok = nullptr, int base = 10) const;
     ushort toUShort(bool *ok = nullptr, int base = 10) const;
@@ -572,42 +623,6 @@ inline int QByteArray::compare(QByteArrayView a, Qt::CaseSensitivity cs) const n
     return cs == Qt::CaseSensitive ? QtPrivate::compareMemory(*this, a) :
                                      qstrnicmp(data(), size(), a.data(), a.size());
 }
-inline bool operator==(const QByteArray &a1, const QByteArray &a2) noexcept
-{ return QByteArrayView(a1) == QByteArrayView(a2); }
-inline bool operator==(const QByteArray &a1, const char *a2) noexcept
-{ return a2 ? QtPrivate::compareMemory(a1, a2) == 0 : a1.isEmpty(); }
-inline bool operator==(const char *a1, const QByteArray &a2) noexcept
-{ return a1 ? QtPrivate::compareMemory(a1, a2) == 0 : a2.isEmpty(); }
-inline bool operator!=(const QByteArray &a1, const QByteArray &a2) noexcept
-{ return !(a1==a2); }
-inline bool operator!=(const QByteArray &a1, const char *a2) noexcept
-{ return a2 ? QtPrivate::compareMemory(a1, a2) != 0 : !a1.isEmpty(); }
-inline bool operator!=(const char *a1, const QByteArray &a2) noexcept
-{ return a1 ? QtPrivate::compareMemory(a1, a2) != 0 : !a2.isEmpty(); }
-inline bool operator<(const QByteArray &a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) < 0; }
- inline bool operator<(const QByteArray &a1, const char *a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) < 0; }
-inline bool operator<(const char *a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) < 0; }
-inline bool operator<=(const QByteArray &a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) <= 0; }
-inline bool operator<=(const QByteArray &a1, const char *a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) <= 0; }
-inline bool operator<=(const char *a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) <= 0; }
-inline bool operator>(const QByteArray &a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) > 0; }
-inline bool operator>(const QByteArray &a1, const char *a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) > 0; }
-inline bool operator>(const char *a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) > 0; }
-inline bool operator>=(const QByteArray &a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(QByteArrayView(a1), QByteArrayView(a2)) >= 0; }
-inline bool operator>=(const QByteArray &a1, const char *a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) >= 0; }
-inline bool operator>=(const char *a1, const QByteArray &a2) noexcept
-{ return QtPrivate::compareMemory(a1, a2) >= 0; }
 #if !defined(QT_USE_QSTRINGBUILDER)
 inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2)
 { return QByteArray(a1) += a2; }
@@ -680,25 +695,26 @@ public:
     QByteArray &operator*() noexcept { return decoded; }
     const QByteArray &operator*() const noexcept { return decoded; }
 #endif
-};
 
-Q_DECLARE_SHARED(QByteArray::FromBase64Result)
+    friend inline bool operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
+    {
+        if (lhs.decodingStatus != rhs.decodingStatus)
+            return false;
 
-inline bool operator==(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
-{
-    if (lhs.decodingStatus != rhs.decodingStatus)
-        return false;
+        if (lhs.decodingStatus == QByteArray::Base64DecodingStatus::Ok && lhs.decoded != rhs.decoded)
+            return false;
 
-    if (lhs.decodingStatus == QByteArray::Base64DecodingStatus::Ok && lhs.decoded != rhs.decoded)
-        return false;
+        return true;
+    }
 
-    return true;
-}
+    friend inline bool operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
+    {
+        return !(lhs == rhs);
+    }
+};
+
+Q_DECLARE_SHARED(QByteArray::FromBase64Result)
 
-inline bool operator!=(const QByteArray::FromBase64Result &lhs, const QByteArray::FromBase64Result &rhs) noexcept
-{
-    return !operator==(lhs, rhs);
-}
 
 Q_CORE_EXPORT Q_DECL_PURE_FUNCTION size_t qHash(const QByteArray::FromBase64Result &key, size_t seed = 0) noexcept;