Fix INDEXBITS in QHandleManager, QHandle

QHandleManager worked only when INDEXBITS was set to the default value 16.
This is corrected now so that a QResourceManager<T, 4> created a
QHandleManager<T, 4> which provides QHandle<T, 4>

Follow up commits will follow for the refactoring of QResourcesManager into
subclasses that can implement their own dedicated memory allocation scheme.

Change-Id: If3b3fb43ae1c9473d9777cf9ba984ba37a65cfa9
Reviewed-by: Sean Harmer <sean.harmer@kdab.com>

3 files changed, 40 insertions, 36 deletions

diff --git a/src/core/resources/qhandle.h b/src/core/resources/qhandle.h
index a66d1ab89..6e71443b0 100644
--- a/src/core/resources/qhandle.h
+++ b/src/core/resources/qhandle.h
@@ -60,14 +60,6 @@ public:
         : m_handle(0)
     {}
 
-    QHandle(quint32 index, quint32 counter)
-        : m_index(index)
-        , m_counter(counter)
-        , m_unused(0)
-    {
-        Q_ASSERT(index < MaxIndex);
-        Q_ASSERT(counter < MaxCounter);
-    }
 
     quint32 index() const { return m_index; }
     quint32 counter() const { return m_counter; }
@@ -79,9 +71,8 @@ public:
     static quint32 maxIndex() { return MaxIndex; }
     static quint32 maxCounter() { return MaxCounter; }
 
-private:
-    friend class QHandleManager<T, INDEXBITS>;
 
+private:
     enum {
         // Sizes to use for bit fields
         IndexBits = INDEXBITS,
@@ -92,6 +83,18 @@ private:
         MaxCounter = (1 << CounterBits) - 1
     };
 
+    QHandle(quint32 index, quint32 counter)
+        : m_index(index)
+        , m_counter(counter)
+        , m_unused(0)
+    {
+        Q_ASSERT(index < MaxIndex);
+        Q_ASSERT(counter < MaxCounter);
+    }
+
+
+    friend class QHandleManager<T, INDEXBITS>;
+
     union {
         struct {
             quint32 m_index : IndexBits;
diff --git a/src/core/resources/qhandlemanager.h b/src/core/resources/qhandlemanager.h
index f0fb4ca82..c99f7623d 100644
--- a/src/core/resources/qhandlemanager.h
+++ b/src/core/resources/qhandlemanager.h
@@ -67,11 +67,11 @@ public:
     quint32 activeEntries() const { return m_activeEntryCount; }
 
     void reset();
-    QHandle<T> acquire(T *data);
-    void release(const QHandle<T> &handle);
-    void update(const QHandle<T> &, T *data);
-    T *data(const QHandle<T> &handle, bool *ok = 0);
-    const T *constData(const QHandle<T> &handle, bool *ok = 0) const;
+    QHandle<T, INDEXBITS> acquire(T *data);
+    void release(const QHandle<T, INDEXBITS> &handle);
+    void update(const QHandle<T, INDEXBITS> &, T *data);
+    T *data(const QHandle<T, INDEXBITS> &handle, bool *ok = 0);
+    const T *constData(const QHandle<T, INDEXBITS> &handle, bool *ok = 0) const;
 
 private:
     Q_DISABLE_COPY(QHandleManager)
@@ -96,8 +96,8 @@ private:
         {}
 
         U *m_data;
-        unsigned int m_nextFreeIndex : QHandle<U>::IndexBits;
-        unsigned int m_counter : QHandle<U>::CounterBits;
+        unsigned int m_nextFreeIndex :  QHandle<U, INDEXBITS>::IndexBits;
+        unsigned int m_counter : QHandle<U, INDEXBITS>::CounterBits;
         unsigned int m_active : 1;
         unsigned int m_endOfFreeList : 1;
     };
@@ -113,19 +113,20 @@ void QHandleManager<T, INDEXBITS>::reset()
     m_activeEntryCount = 0;
     m_firstFreeEntry = 0;
 
-    for (int i = 0; i < QHandle<T>::MaxIndex; ++i)
+    for (int i = 0; i < QHandle<T, INDEXBITS >::MaxIndex; ++i)
         m_entries[i] = HandleEntry<T>(i + 1);
-    m_entries[QHandle<T>::MaxIndex] = HandleEntry<T>();
-    m_entries[QHandle<T>::MaxIndex].m_endOfFreeList = true;
+    m_entries[QHandle<T, INDEXBITS>::MaxIndex] = HandleEntry<T>();
+    m_entries[QHandle<T, INDEXBITS>::MaxIndex].m_endOfFreeList = true;
 }
 
 template <typename T, int INDEXBITS>
-QHandle<T> QHandleManager<T, INDEXBITS>::acquire(T *data)
+QHandle<T, INDEXBITS> QHandleManager<T, INDEXBITS>::acquire(T *data)
 {
-    Q_ASSERT(m_activeEntryCount < QHandle<T>::MaxIndex);
+    typedef QHandle<T, INDEXBITS> qHandle;
+    Q_ASSERT(m_activeEntryCount < qHandle::MaxIndex);
 
     const quint32 newIndex = m_firstFreeEntry;
-    Q_ASSERT(newIndex < QHandle<T>::MaxIndex);
+    Q_ASSERT(newIndex < qHandle::MaxIndex);
     Q_ASSERT(m_entries[newIndex].m_active == false);
     Q_ASSERT(!m_entries[newIndex].m_endOfFreeList);
 
@@ -139,11 +140,11 @@ QHandle<T> QHandleManager<T, INDEXBITS>::acquire(T *data)
 
     ++m_activeEntryCount;
 
-    return QHandle<T>(newIndex, m_entries[newIndex].m_counter);
+    return QHandle<T, INDEXBITS>(newIndex, m_entries[newIndex].m_counter);
 }
 
 template <typename T, int INDEXBITS>
-void QHandleManager<T, INDEXBITS>::release(const QHandle<T> &handle)
+void QHandleManager<T, INDEXBITS>::release(const QHandle<T, INDEXBITS> &handle)
 {
     const quint32 index = handle.index();
     Q_ASSERT(m_entries[index].m_counter == handle.counter());
@@ -159,7 +160,7 @@ void QHandleManager<T, INDEXBITS>::release(const QHandle<T> &handle)
 // Needed in case the QResourcesManager has reordered
 // memory so that the handle still points to valid data
 template <typename T, int INDEXBITS>
-void QHandleManager<T, INDEXBITS>::update(const QHandle<T> &handle, T *data)
+void QHandleManager<T, INDEXBITS>::update(const QHandle<T, INDEXBITS> &handle, T *data)
 {
     const quint32 index = handle.index();
     Q_ASSERT(m_entries[index].m_counter == handle.counter());
@@ -168,7 +169,7 @@ void QHandleManager<T, INDEXBITS>::update(const QHandle<T> &handle, T *data)
 }
 
 template <typename T, int INDEXBITS>
-T *QHandleManager<T, INDEXBITS>::data(const QHandle<T> &handle, bool *ok)
+T *QHandleManager<T, INDEXBITS>::data(const QHandle<T, INDEXBITS> &handle, bool *ok)
 {
     const quint32 index = handle.index();
     if (m_entries[index].m_counter != handle.counter() ||
@@ -185,7 +186,7 @@ T *QHandleManager<T, INDEXBITS>::data(const QHandle<T> &handle, bool *ok)
 }
 
 template <typename T, int INDEXBITS>
-const T *QHandleManager<T, INDEXBITS>::constData(const QHandle<T> &handle, bool *ok) const
+const T *QHandleManager<T, INDEXBITS>::constData(const QHandle<T, INDEXBITS> &handle, bool *ok) const
 {
     const quint32 index = handle.index();
     if (m_entries[index].m_counter != handle.counter() ||
diff --git a/src/core/resources/qresourcesmanager.h b/src/core/resources/qresourcesmanager.h
index 24cfb71cd..e2575c2d5 100644
--- a/src/core/resources/qresourcesmanager.h
+++ b/src/core/resources/qresourcesmanager.h
@@ -71,22 +71,22 @@ public:
         m_resourceEntries.clear();
     }
 
-    QHandle<T> acquire();
-    T* data(const QHandle<T> &handle);
-    void release(const QHandle<T> &handle);
+    QHandle<T, INDEXBITS> acquire();
+    T* data(const QHandle<T, INDEXBITS> &handle);
+    void release(const QHandle<T, INDEXBITS> &handle);
     void reset();
 
 private:
     int nextFreeEntry();
 
-    QHandleManager<T> *m_handleManager;
+    QHandleManager<T, INDEXBITS> *m_handleManager;
     QVector<T> m_resourceEntries;
     QHash<int, int> m_handleToResource;
     QList<int> m_freeEntryIndices;
 };
 
 template <typename T, int INDEXBITS>
-void QResourcesManager<T, INDEXBITS>::release(const QHandle<T> &handle)
+void QResourcesManager<T, INDEXBITS>::release(const QHandle<T, INDEXBITS> &handle)
 {
     Q_ASSERT(m_handleToResource.contains(handle.index()));
     m_freeEntryIndices << m_handleToResource[handle.index()];
@@ -106,18 +106,18 @@ void QResourcesManager<T, INDEXBITS>::reset()
 }
 
 template <typename T, int INDEXBITS>
-T* QResourcesManager<T, INDEXBITS>::data(const QHandle<T> &handle)
+T* QResourcesManager<T, INDEXBITS>::data(const QHandle<T, INDEXBITS> &handle)
 {
     return m_handleManager->data(handle);
 }
 
 template <typename T, int INDEXBITS>
-QHandle<T> QResourcesManager<T, INDEXBITS>::acquire()
+QHandle<T, INDEXBITS> QResourcesManager<T, INDEXBITS>::acquire()
 {
     Q_ASSERT(!m_freeEntryIndices.isEmpty());
     int idx = m_freeEntryIndices.takeFirst();
     m_resourceEntries[idx] = T();
-    QHandle<T> handle = m_handleManager->acquire(m_resourceEntries.begin() + idx);
+    QHandle<T, INDEXBITS> handle = m_handleManager->acquire(m_resourceEntries.begin() + idx);
     m_handleToResource[handle.index()] = idx;
     return handle;
 }