Whitespace cleanup in corelib/tools

Change-Id: Ibe796c398a8e5488b7203abb07aa54740744f1ab
Reviewed-by: Thiago Macieira <thiago.macieira@intel.com>

src/corelib/tools/qbitarray.cpp

@@ -754,7 +754,6 @@ QBitArray operator^(const QBitArray &a1, const QBitArray &a2)
     Sets the value referenced by the QBitRef to \a v.
 */
 
-
 /*****************************************************************************
   QBitArray stream functions
  *****************************************************************************/

src/corelib/tools/qbitarray.h

@@ -44,7 +44,6 @@
 
 QT_BEGIN_NAMESPACE
 
-
 class QBitRef;
 class Q_CORE_EXPORT QBitArray
 {
@@ -148,6 +147,7 @@ private:
     qsizetype i;
     inline QBitRef(QBitArray &array, qsizetype idx) : a(array), i(idx) { }
     friend class QBitArray;
+
 public:
     inline operator bool() const { return a.testBit(i); }
     inline bool operator!() const { return !a.testBit(i); }

src/corelib/tools/qcache.h

@@ -48,7 +48,8 @@ QT_BEGIN_NAMESPACE
 template <class Key, class T>
 class QCache
 {
-    struct Value {
+    struct Value
+    {
         T *t = nullptr;
         qsizetype cost = 0;
         Value() noexcept = default;
@@ -68,19 +69,20 @@ class QCache
             return *this;
         }
         ~Value() { delete t; }
+
     private:
         Q_DISABLE_COPY(Value)
     };
 
-    struct Chain {
+    struct Chain
-        Chain() noexcept
+    {
-            : prev(this), next(this)
+        Chain() noexcept : prev(this), next(this) { }
-        {}
         Chain *prev;
         Chain *next;
     };
 
-    struct Node : public Chain {
+    struct Node : public Chain
+    {
         using KeyType = Key;
         using ValueType = Value;
 

src/corelib/tools/qeasingcurve.cpp

@@ -320,7 +320,8 @@ static bool isConfigFunction(QEasingCurve::Type type)
             type == QEasingCurve::TCBSpline;
 }
 
-struct TCBPoint {
+struct TCBPoint
+{
     QPointF _point;
     qreal _t;
     qreal _c;
@@ -1202,9 +1203,9 @@ bool QEasingCurve::operator==(const QEasingCurve &other) const
 
         } else if (d_ptr->config || other.d_ptr->config) {
             // one one has a config object, which could contain default values
-            res = qFuzzyCompare(amplitude(), other.amplitude()) &&
+            res = qFuzzyCompare(amplitude(), other.amplitude())
-                  qFuzzyCompare(period(), other.period()) &&
+               && qFuzzyCompare(period(), other.period())
-                  qFuzzyCompare(overshoot(), other.overshoot());
+               && qFuzzyCompare(overshoot(), other.overshoot());
         }
     }
     return res;

src/corelib/tools/qeasingcurve.h

@@ -49,7 +49,6 @@ QT_REQUIRE_CONFIG(easingcurve);
 
 QT_BEGIN_NAMESPACE
 
-
 class QEasingCurvePrivate;
 class QPointF;
 class Q_CORE_EXPORT QEasingCurve
@@ -108,6 +107,7 @@ public:
     EasingFunction customType() const;
 
     qreal valueForProgress(qreal progress) const;
+
 private:
     QEasingCurvePrivate *d_ptr;
 #ifndef QT_NO_DEBUG_STREAM

src/corelib/tools/qfreelist_p.h

@@ -56,7 +56,6 @@
 
 QT_BEGIN_NAMESPACE
 
-
 /*! \internal
 
     Element in a QFreeList. ConstReferenceType and ReferenceType are used as

src/corelib/tools/qhash.h

@@ -59,8 +59,7 @@ struct QHashDummyValue
 namespace QHashPrivate {
 
 // QHash uses a power of two growth policy.
-namespace GrowthPolicy
+namespace GrowthPolicy {
-{
 inline constexpr size_t maxNumBuckets() noexcept
 {
     return size_t(1) << (8 * sizeof(size_t) - 1);
@@ -471,7 +470,6 @@ struct Data
         return dd;
     }
 
-
     void clear()
     {
         delete[] spans;
@@ -579,7 +577,8 @@ struct Data
         return it.node();
     }
 
-    struct InsertionResult {
+    struct InsertionResult
+    {
         iterator it;
         bool initialized;
     };

src/corelib/tools/qhashfunctions.h

@@ -172,7 +172,8 @@ template<typename T> inline size_t qHash(const T &t, size_t seed)
 
 namespace QtPrivate {
 
-struct QHashCombine {
+struct QHashCombine
+{
     typedef size_t result_type;
     template <typename T>
     constexpr result_type operator()(size_t seed, const T &t) const noexcept(noexcept(qHash(t)))
@@ -180,7 +181,8 @@ struct QHashCombine {
     { return seed ^ (qHash(t) + 0x9e3779b9 + (seed << 6) + (seed >> 2)) ; }
 };
 
-struct QHashCombineCommutative {
+struct QHashCombineCommutative
+{
     // QHashCombine is a good hash combiner, but is not commutative,
     // ie. it depends on the order of the input elements. That is
     // usually what we want: {0,1,3} should hash differently than

src/corelib/tools/qiterator.h

@@ -205,10 +205,9 @@ public:
         return std::pair<Key, T>(i.key(), i.value());
     }
 
-    struct pointer {
+    struct pointer
-        pointer(value_type&& r_)
+    {
-            : r(std::move(r_))
+        pointer(value_type &&r_) : r(std::move(r_)) { }
-        {}
 
         pointer() = default;
         pointer(const pointer &other) = default;
@@ -216,9 +215,7 @@ public:
         pointer &operator=(const pointer &other) = default;
         pointer &operator=(pointer &&other) = default;
 
-        value_type& operator*() const {
+        value_type &operator*() const { return r; }
-            return r;
-        }
 
         value_type r;
         const value_type *operator->() const {

src/corelib/tools/qpoint.h

@@ -48,7 +48,6 @@ struct CGPoint;
 
 QT_BEGIN_NAMESPACE
 
-
 class QPoint
 {
 public:
@@ -124,79 +123,139 @@ constexpr inline QPoint::QPoint() noexcept : xp(0), yp(0) {}
 constexpr inline QPoint::QPoint(int xpos, int ypos) noexcept : xp(xpos), yp(ypos) {}
 
 constexpr inline bool QPoint::isNull() const noexcept
-{ return xp == 0 && yp == 0; }
+{
+    return xp == 0 && yp == 0;
+}
 
 constexpr inline int QPoint::x() const noexcept
-{ return xp; }
+{
+    return xp;
+}
 
 constexpr inline int QPoint::y() const noexcept
-{ return yp; }
+{
+    return yp;
+}
 
 constexpr inline void QPoint::setX(int xpos) noexcept
-{ xp = xpos; }
+{
+    xp = xpos;
+}
 
 constexpr inline void QPoint::setY(int ypos) noexcept
-{ yp = ypos; }
+{
+    yp = ypos;
+}
 
 inline int constexpr QPoint::manhattanLength() const
-{ return qAbs(x())+qAbs(y()); }
+{
+    return qAbs(x()) + qAbs(y());
+}
 
 constexpr inline int &QPoint::rx() noexcept
-{ return xp; }
+{
+    return xp;
+}
 
 constexpr inline int &QPoint::ry() noexcept
-{ return yp; }
+{
+    return yp;
+}
 
 constexpr inline QPoint &QPoint::operator+=(const QPoint &p)
-{ xp+=p.xp; yp+=p.yp; return *this; }
+{
+    xp += p.xp;
+    yp += p.yp;
+    return *this;
+}
 
 constexpr inline QPoint &QPoint::operator-=(const QPoint &p)
-{ xp-=p.xp; yp-=p.yp; return *this; }
+{
+    xp -= p.xp;
+    yp -= p.yp;
+    return *this;
+}
 
 constexpr inline QPoint &QPoint::operator*=(float factor)
-{ xp = qRound(xp*factor); yp = qRound(yp*factor); return *this; }
+{
+    xp = qRound(xp * factor);
+    yp = qRound(yp * factor);
+    return *this;
+}
 
 constexpr inline QPoint &QPoint::operator*=(double factor)
-{ xp = qRound(xp*factor); yp = qRound(yp*factor); return *this; }
+{
+    xp = qRound(xp * factor);
+    yp = qRound(yp * factor);
+    return *this;
+}
 
 constexpr inline QPoint &QPoint::operator*=(int factor)
-{ xp = xp*factor; yp = yp*factor; return *this; }
+{
+    xp = xp * factor;
+    yp = yp * factor;
+    return *this;
+}
 
 constexpr inline bool operator==(const QPoint &p1, const QPoint &p2) noexcept
-{ return p1.xp == p2.xp && p1.yp == p2.yp; }
+{
+    return p1.xp == p2.xp && p1.yp == p2.yp;
+}
 
 constexpr inline bool operator!=(const QPoint &p1, const QPoint &p2) noexcept
-{ return p1.xp != p2.xp || p1.yp != p2.yp; }
+{
+    return p1.xp != p2.xp || p1.yp != p2.yp;
+}
 
 constexpr inline const QPoint operator+(const QPoint &p1, const QPoint &p2)
-{ return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); }
+{
+    return QPoint(p1.xp + p2.xp, p1.yp + p2.yp);
+}
 
 constexpr inline const QPoint operator-(const QPoint &p1, const QPoint &p2)
-{ return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); }
+{
+    return QPoint(p1.xp - p2.xp, p1.yp - p2.yp);
+}
 
 constexpr inline const QPoint operator*(const QPoint &p, float factor)
-{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }
+{
+    return QPoint(qRound(p.xp * factor), qRound(p.yp * factor));
+}
 
 constexpr inline const QPoint operator*(const QPoint &p, double factor)
-{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }
+{
+    return QPoint(qRound(p.xp * factor), qRound(p.yp * factor));
+}
 
 constexpr inline const QPoint operator*(const QPoint &p, int factor)
-{ return QPoint(p.xp*factor, p.yp*factor); }
+{
+    return QPoint(p.xp * factor, p.yp * factor);
+}
 
 constexpr inline const QPoint operator*(float factor, const QPoint &p)
-{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }
+{
+    return QPoint(qRound(p.xp * factor), qRound(p.yp * factor));
+}
 
 constexpr inline const QPoint operator*(double factor, const QPoint &p)
-{ return QPoint(qRound(p.xp*factor), qRound(p.yp*factor)); }
+{
+    return QPoint(qRound(p.xp * factor), qRound(p.yp * factor));
+}
 
 constexpr inline const QPoint operator*(int factor, const QPoint &p)
-{ return QPoint(p.xp*factor, p.yp*factor); }
+{
+    return QPoint(p.xp * factor, p.yp * factor);
+}
 
 constexpr inline const QPoint operator+(const QPoint &p)
-{ return p; }
+{
+    return p;
+}
 
 constexpr inline const QPoint operator-(const QPoint &p)
-{ return QPoint(-p.xp, -p.yp); }
+{
+    return QPoint(-p.xp, -p.yp);
+}
 
 constexpr inline QPoint &QPoint::operator/=(qreal c)
 {
@@ -246,7 +305,9 @@ public:
     constexpr inline QPointF &operator/=(qreal c);
 
     constexpr static inline qreal dotProduct(const QPointF &p1, const QPointF &p2)
-    { return p1.xp * p2.xp + p1.yp * p2.yp; }
+    {
+        return p1.xp * p2.xp + p1.yp * p2.yp;
+    }
 
     friend constexpr inline bool operator==(const QPointF &, const QPointF &);
     friend constexpr inline bool operator!=(const QPointF &, const QPointF &);
@@ -341,12 +402,16 @@ constexpr inline QPointF &QPointF::operator+=(const QPointF &p)
 
 constexpr inline QPointF &QPointF::operator-=(const QPointF &p)
 {
-    xp-=p.xp; yp-=p.yp; return *this;
+    xp -= p.xp;
+    yp -= p.yp;
+    return *this;
 }
 
 constexpr inline QPointF &QPointF::operator*=(qreal c)
 {
-    xp*=c; yp*=c; return *this;
+    xp *= c;
+    yp *= c;
+    return *this;
 }
 
 QT_WARNING_PUSH

src/corelib/tools/qscopedpointer.h

@@ -240,7 +240,8 @@ public:
     { QScopedPointer<T, Cleanup>::swap(other); }
 
 private:
-    explicit inline QScopedArrayPointer(void *) {
+    explicit inline QScopedArrayPointer(void *)
+    {
         // Enforce the same type.
 
         // If you get a compile error here, make sure you declare

src/corelib/tools/qsize.h

@@ -166,13 +166,25 @@ constexpr inline int &QSize::rheight() noexcept
 { return ht; }
 
 constexpr inline QSize &QSize::operator+=(const QSize &s) noexcept
-{ wd+=s.wd; ht+=s.ht; return *this; }
+{
+    wd += s.wd;
+    ht += s.ht;
+    return *this;
+}
 
 constexpr inline QSize &QSize::operator-=(const QSize &s) noexcept
-{ wd-=s.wd; ht-=s.ht; return *this; }
+{
+    wd -= s.wd;
+    ht -= s.ht;
+    return *this;
+}
 
 constexpr inline QSize &QSize::operator*=(qreal c) noexcept
-{ wd = qRound(wd*c); ht = qRound(ht*c); return *this; }
+{
+    wd = qRound(wd * c);
+    ht = qRound(ht * c);
+    return *this;
+}
 
 constexpr inline bool operator==(const QSize &s1, const QSize &s2) noexcept
 { return s1.wd == s2.wd && s1.ht == s2.ht; }
@@ -184,21 +196,30 @@ constexpr inline size_t qHash(const QSize &s, size_t seed = 0) noexcept
 { return qHashMulti(seed, s.wd, s.ht); }
 
 constexpr inline const QSize operator+(const QSize &s1, const QSize &s2) noexcept
-{ return QSize(s1.wd+s2.wd, s1.ht+s2.ht); }
+{
+    return QSize(s1.wd + s2.wd, s1.ht + s2.ht);
+}
 
 constexpr inline const QSize operator-(const QSize &s1, const QSize &s2) noexcept
-{ return QSize(s1.wd-s2.wd, s1.ht-s2.ht); }
+{
+    return QSize(s1.wd - s2.wd, s1.ht - s2.ht);
+}
 
 constexpr inline const QSize operator*(const QSize &s, qreal c) noexcept
-{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }
+{
+    return QSize(qRound(s.wd * c), qRound(s.ht * c));
+}
 
 constexpr inline const QSize operator*(qreal c, const QSize &s) noexcept
-{ return QSize(qRound(s.wd*c), qRound(s.ht*c)); }
+{
+    return QSize(qRound(s.wd * c), qRound(s.ht * c));
+}
 
 inline QSize &QSize::operator/=(qreal c)
 {
     Q_ASSERT(!qFuzzyIsNull(c));
-    wd = qRound(wd/c); ht = qRound(ht/c);
+    wd = qRound(wd / c);
+    ht = qRound(ht / c);
     return *this;
 }
 
@@ -344,13 +365,25 @@ constexpr inline qreal &QSizeF::rheight() noexcept
 { return ht; }
 
 constexpr inline QSizeF &QSizeF::operator+=(const QSizeF &s) noexcept
-{ wd += s.wd; ht += s.ht; return *this; }
+{
+    wd += s.wd;
+    ht += s.ht;
+    return *this;
+}
 
 constexpr inline QSizeF &QSizeF::operator-=(const QSizeF &s) noexcept
-{ wd -= s.wd; ht -= s.ht; return *this; }
+{
+    wd -= s.wd;
+    ht -= s.ht;
+    return *this;
+}
 
 constexpr inline QSizeF &QSizeF::operator*=(qreal c) noexcept
-{ wd *= c; ht *= c; return *this; }
+{
+    wd *= c;
+    ht *= c;
+    return *this;
+}
 
 constexpr inline bool operator==(const QSizeF &s1, const QSizeF &s2) noexcept
 { return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); }
@@ -359,21 +392,30 @@ constexpr inline bool operator!=(const QSizeF &s1, const QSizeF &s2) noexcept
 { return !qFuzzyCompare(s1.wd, s2.wd) || !qFuzzyCompare(s1.ht, s2.ht); }
 
 constexpr inline const QSizeF operator+(const QSizeF &s1, const QSizeF &s2) noexcept
-{ return QSizeF(s1.wd+s2.wd, s1.ht+s2.ht); }
+{
+    return QSizeF(s1.wd + s2.wd, s1.ht + s2.ht);
+}
 
 constexpr inline const QSizeF operator-(const QSizeF &s1, const QSizeF &s2) noexcept
-{ return QSizeF(s1.wd-s2.wd, s1.ht-s2.ht); }
+{
+    return QSizeF(s1.wd - s2.wd, s1.ht - s2.ht);
+}
 
 constexpr inline const QSizeF operator*(const QSizeF &s, qreal c) noexcept
-{ return QSizeF(s.wd*c, s.ht*c); }
+{
+    return QSizeF(s.wd * c, s.ht * c);
+}
 
 constexpr inline const QSizeF operator*(qreal c, const QSizeF &s) noexcept
-{ return QSizeF(s.wd*c, s.ht*c); }
+{
+    return QSizeF(s.wd * c, s.ht * c);
+}
 
 inline QSizeF &QSizeF::operator/=(qreal c)
 {
     Q_ASSERT(!qFuzzyIsNull(c));
-    wd = wd/c; ht = ht/c;
+    wd = wd / c;
+    ht = ht / c;
     return *this;
 }
 

src/corelib/tools/qtools_p.h

@@ -89,7 +89,8 @@ constexpr inline int fromOct(uint c) noexcept
 // We typically need an extra bit for qNextPowerOfTwo when determining the next allocation size.
 constexpr qsizetype MaxAllocSize = (std::numeric_limits<qsizetype>::max)();
 
-struct CalculateGrowingBlockSizeResult {
+struct CalculateGrowingBlockSizeResult
+{
     qsizetype size;
     qsizetype elementCount;
 };

src/corelib/tools/qvarlengtharray.h

@@ -104,7 +104,8 @@ public:
         std::copy(first, last, std::back_inserter(*this));
     }
 
-    inline ~QVarLengthArray() {
+    inline ~QVarLengthArray()
+    {
         if (QTypeInfo<T>::isComplex) {
             T *i = ptr + s;
             while (i-- != ptr)
@@ -151,7 +152,8 @@ public:
         return *this;
     }
 
-    inline void removeLast() {
+    inline void removeLast()
+    {
         Q_ASSERT(s > 0);
         if (QTypeInfo<T>::isComplex)
             ptr[s - 1].~T();
@@ -160,10 +162,26 @@ public:
     inline qsizetype size() const { return s; }
     inline qsizetype count() const { return s; }
     inline qsizetype length() const { return s; }
-    inline T& first() { Q_ASSERT(!isEmpty()); return *begin(); }
+    inline T &first()
-    inline const T& first() const { Q_ASSERT(!isEmpty()); return *begin(); }
+    {
-    T& last() { Q_ASSERT(!isEmpty()); return *(end() - 1); }
+        Q_ASSERT(!isEmpty());
-    const T& last() const { Q_ASSERT(!isEmpty()); return *(end() - 1); }
+        return *begin();
+    }
+    inline const T &first() const
+    {
+        Q_ASSERT(!isEmpty());
+        return *begin();
+    }
+    T &last()
+    {
+        Q_ASSERT(!isEmpty());
+        return *(end() - 1);
+    }
+    const T &last() const
+    {
+        Q_ASSERT(!isEmpty());
+        return *(end() - 1);
+    }
     inline bool isEmpty() const { return (s == 0); }
     inline void resize(qsizetype size);
     inline void clear() { resize(0); }
@@ -179,11 +197,13 @@ public:
     template <typename AT>
     inline bool contains(const AT &t) const;
 
-    inline T &operator[](qsizetype idx) {
+    inline T &operator[](qsizetype idx)
+    {
         Q_ASSERT(idx >= 0 && idx < s);
         return ptr[idx];
     }
-    inline const T &operator[](qsizetype idx) const {
+    inline const T &operator[](qsizetype idx) const
+    {
         Q_ASSERT(idx >= 0 && idx < s);
         return ptr[idx];
     }
@@ -192,7 +212,8 @@ public:
     T value(qsizetype i) const;
     T value(qsizetype i, const T &defaultValue) const;
 
-    inline void append(const T &t) {
+    inline void append(const T &t)
+    {
         if (s == a) { // i.e. s != 0
             T copy(t);
             reallocate(s, s << 1);
@@ -212,7 +233,8 @@ public:
         }
     }
 
-    void append(T &&t) {
+    void append(T &&t)
+    {
         if (s == a)
             reallocate(s, s << 1);
         const qsizetype idx = s++;
@@ -241,7 +263,6 @@ public:
     void remove(qsizetype i);
     void remove(qsizetype i, qsizetype n);
 
-
     inline T *data() { return ptr; }
     inline const T *data() const { return ptr; }
     inline const T *constData() const { return ptr; }
@@ -253,7 +274,6 @@ public:
     typedef const value_type &const_reference;
     typedef qptrdiff difference_type;
 
-
     typedef T *iterator;
     typedef const T *const_iterator;
     typedef std::reverse_iterator<iterator> reverse_iterator;

src/corelib/tools/qversionnumber.h

@@ -77,7 +77,8 @@ class QVersionNumber
     };
     static_assert(InlineSegmentCount >= 3);   // at least major, minor, micro
 
-    struct SegmentStorage {
+    struct SegmentStorage
+    {
         // Note: we alias the use of dummy and inline_segments in the use of the
         // union below. This is undefined behavior in C++98, but most compilers implement
         // the C++11 behavior. The one known exception is older versions of Sun Studio.