Changeset 561 for trunk/src/corelib/tools/qhash.h

Timestamp:

Feb 11, 2010, 11:19:06 PM (15 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.6.1 sources.

Location:

trunk

Files:

• . (modified) (1 prop)
• src/corelib/tools/qhash.h (modified) (19 diffs)

trunk/src/corelib/tools/qhash.h

@@ -2 +2 @@
 **
 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
-** Contact: Qt Software Information ([email protected])
+** All rights reserved.
+** Contact: Nokia Corporation ([email protected])
 **
 ** This file is part of the QtCore module of the Qt Toolkit.
@@ -21 +22 @@
 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
 **
-** In addition, as a special exception, Nokia gives you certain
-** additional rights. These rights are described in the Nokia Qt LGPL
-** Exception version 1.0, included in the file LGPL_EXCEPTION.txt in this
-** package.
+** In addition, as a special exception, Nokia gives you certain additional
+** rights.  These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
 **
 ** GNU General Public License Usage
@@ -34 +34 @@
 ** met: http://www.gnu.org/copyleft/gpl.html.
 **
-** If you are unsure which license is appropriate for your use, please
-** contact the sales department at qt-sales@nokia.com.
+** If you 
+** @nokia.com.
 ** $QT_END_LICENSE$
 **
@@ -53 +53 @@
 QT_BEGIN_NAMESPACE
 
-#undef QT_QHASH_DEBUG
 QT_MODULE(Core)
 
@@ -71 +70 @@
 {
     if (sizeof(ulong) > sizeof(uint)) {
-        return uint((key >> (8 * sizeof(uint) - 1)) ^ key);
+        return uint(();
     } else {
-        return uint(key);
+        return uint(key);
     }
 }
@@ -80 +79 @@
 {
     if (sizeof(quint64) > sizeof(uint)) {
-        return uint((key >> (8 * sizeof(uint) - 1)) ^ key);
+        return uint(();
     } else {
-        return uint(key);
+        return uint(key);
     }
 }
@@ -98 +97 @@
 template <class T> inline uint qHash(const T *key)
 {
-    if (sizeof(const T *) > sizeof(uint))
-        return qHash(reinterpret_cast<quint64>(key));
-    else
-        return uint(reinterpret_cast<ulong>(key));
+    return qHash(reinterpret_cast<quintptr>(key));
 }
 #if defined(Q_CC_MSVC)
@@ -130 +126 @@
     int numBuckets;
     uint sharable : 1;
-
-    void *allocateNode();
+    uint strictAlignment : 1;
+    uint reserved : 30;
+
+    void *allocateNode(); // ### Qt5 remove me
+    void *allocateNode(int nodeAlign);
     void freeNode(void *node);
-    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize);
+    QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize); // ### Qt5 remove me
+    QHashData *detach_helper2(void (*node_duplicate)(Node *, void *), void (*node_delete)(Node *),
+                              int nodeSize, int nodeAlign);
     void mightGrow();
     bool willGrow();
     void hasShrunk();
     void rehash(int hint);
-    void destroyAndFree();
+    void free_helper(void (*node_delete)(Node *));
+    void destroyAndFree(); // ### Qt5 remove me
     Node *firstNode();
 #ifdef QT_QHASH_DEBUG
@@ -151 +153 @@
 
 inline void QHashData::mightGrow() // ### Qt 5: eliminate
-{ 
+{
     if (size >= numBuckets)
         rehash(numBits + 1);
-}  
+}
 
 inline bool QHashData::willGrow()
@@ -168 +170 @@
 inline void QHashData::hasShrunk()
 {
-    if (size <= (numBuckets >> 3) && numBits > userNumBits)
-        rehash(qMax(int(numBits) - 2, int(userNumBits)));
+    if (size <= (numBuckets >> 3) && numBits > userNumBits) {
+        QT_TRY {
+            rehash(qMax(int(numBits) - 2, int(userNumBits)));
+        } QT_CATCH(const std::bad_alloc &) {
+            // ignore bad allocs - shrinking shouldn't throw. rehash is exception safe.
+        }
+    }
 }
 
@@ -264 +271 @@
     }
 
+
+
+
+
+
+
+
+
 public:
     inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); }
@@ -480 +495 @@
     Node *createNode(uint h, const Key &key, const T &value, Node **nextNode);
     void deleteNode(Node *node);
+
 
     static void duplicateNode(QHashData::Node *originalNode, void *newNode);
 };
 
+
 template <class Key, class T>
 Q_INLINE_TEMPLATE void QHash<Key, T>::deleteNode(Node *node)
 {
+
+
+
+
+
+
+
 #ifdef Q_CC_BOR
-    node->~QHashNode<Key, T>();
+    ->~QHashNode<Key, T>();
 #elif defined(QT_NO_PARTIAL_TEMPLATE_SPECIALIZATION)
-    node->~QHashNode();
+    ->~QHashNode();
 #else
-    node->~Node();
-#endif
-    d->freeNode(node);
+    concrete(node)->~Node();
+#endif
 }
 
@@ -515 +538 @@
 
     if (QTypeInfo<T>::isDummy) {
-        node = reinterpret_cast<Node *>(new (d->allocateNode()) DummyNode(akey));
+        node = reinterpret_cast<Node *>(new (d->allocateNode()) DummyNode(akey));
     } else {
-        node = new (d->allocateNode()) Node(akey, avalue);
+        node = new (d->allocateNode()) Node(akey, avalue);
     }
 
@@ -542 +565 @@
 Q_OUTOFLINE_TEMPLATE void QHash<Key, T>::freeData(QHashData *x)
 {
-    Node *e_for_x = reinterpret_cast<Node *>(x);
-    Node **bucket = reinterpret_cast<Node **>(x->buckets);
-    int n = x->numBuckets;
-    while (n--) {
-        Node *cur = *bucket++;
-        while (cur != e_for_x) {
-            Node *next = cur->next;
-            deleteNode(cur);
-            cur = next;
-        }
-    }
-    x->destroyAndFree();
+    x->free_helper(deleteNode2);
 }
 
@@ -565 +577 @@
 Q_OUTOFLINE_TEMPLATE void QHash<Key, T>::detach_helper()
 {
-    QHashData *x = d->detach_helper(duplicateNode,
-        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node));
+    QHashData *x = d->detach_helper2(duplicateNode, deleteNode2,
+        QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node),
+        QTypeInfo<T>::isDummy ? alignOfDummyNode() : alignOfNode());
     if (!d->ref.deref())
         freeData(d);
@@ -764 +777 @@
 Q_OUTOFLINE_TEMPLATE int QHash<Key, T>::remove(const Key &akey)
 {
+
+
     detach();
 
@@ -785 +800 @@
 Q_OUTOFLINE_TEMPLATE T QHash<Key, T>::take(const Key &akey)
 {
+
+
     detach();
 
@@ -915 +932 @@
     { QMultiHash result = *this; result += other; return result; }
 
-#ifndef Q_NO_USING_KEYWORD
+#if !defined(Q_NO_USING_KEYWORD) && !defined(Q_CC_RVCT)
+    // RVCT compiler doesn't handle using-keyword right when used functions are overloaded in child class
     using QHash<Key, T>::contains;
     using QHash<Key, T>::remove;
@@ -985 +1003 @@
     while (i != end && i.key() == key) {
         if (i.value() == value) {
+
+
+
+
             i = erase(i);
+
             ++n;
         } else {