src/corelib/concurrent/qtconcurrentresultstore.h

   1 /****************************************************************************
   2 **
   3 ** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
   4 ** All rights reserved.
   5 ** Contact: Nokia Corporation (qt-info@nokia.com)
   6 **
   7 ** This file is part of the QtCore module of the Qt Toolkit.
   8 **
   9 ** $QT_BEGIN_LICENSE:LGPL$
  10 ** No Commercial Usage
  11 ** This file contains pre-release code and may not be distributed.
  12 ** You may use this file in accordance with the terms and conditions
  13 ** contained in the Technology Preview License Agreement accompanying
  14 ** this package.
  15 **
  16 ** GNU Lesser General Public License Usage
  17 ** Alternatively, this file may be used under the terms of the GNU Lesser
  18 ** General Public License version 2.1 as published by the Free Software
  19 ** Foundation and appearing in the file LICENSE.LGPL included in the
  20 ** packaging of this file.  Please review the following information to
  21 ** ensure the GNU Lesser General Public License version 2.1 requirements
  22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
  23 **
  24 ** In addition, as a special exception, Nokia gives you certain additional
  25 ** rights.  These rights are described in the Nokia Qt LGPL Exception
  26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
  27 **
  28 ** If you have questions regarding the use of this file, please contact
  29 ** Nokia at qt-info@nokia.com.
  30 **
  31 **
  32 **
  33 **
  34 **
  35 **
  36 **
  37 **
  38 ** $QT_END_LICENSE$
  39 **
  40 ****************************************************************************/
  41
  42 #ifndef QTCONCURRENT_RESULTSTORE_H
  43 #define QTCONCURRENT_RESULTSTORE_H
  44
  45 #include <QtCore/qglobal.h>
  46
  47 #ifndef QT_NO_QFUTURE
  48
  49 #include <QtCore/qmap.h>
  50 #include <QtCore/qdebug.h>
  51
  52 QT_BEGIN_HEADER
  53 QT_BEGIN_NAMESPACE
  54
  55 QT_MODULE(Core)
  56
  57 /*
  58     ResultStore stores indexed results. Results can be added and retrieved
  59     either individually batched in a QVector. Retriveing results and checking
  60     which indexes are in the store can be done either by iterating or by random
  61     accees. In addition results kan be removed from the front of the store,
  62     either individually or in batches.
  63 */
  64
  65 #ifndef qdoc
  66
  67 namespace QtConcurrent {
  68
  69 class ResultItem
  70 {
  71 public:
  72     ResultItem(const void *_result, int _count) : m_count(_count), result(_result) { } // contruct with vector of results
  73     ResultItem(const void *_result) : m_count(0), result(_result) { } // construct with result
  74     ResultItem() : m_count(0), result(0) { }
  75     bool isValid() const { return result != 0; }
  76     bool isVector() const { return m_count != 0; }
  77     int count() const { return (m_count == 0) ?  1 : m_count; }
  78     int m_count;          // result is either a pointer to a result or to a vector of results,
  79     const void *result; // if count is 0 it's a result, otherwise it's a vector.
  80 };
  81
  82 class Q_CORE_EXPORT ResultIteratorBase
  83 {
  84 public:
  85     ResultIteratorBase();
  86     ResultIteratorBase(QMap<int, ResultItem>::const_iterator _mapIterator, int _vectorIndex = 0);
  87     int vectorIndex() const;
  88     int resultIndex() const;
  89
  90     ResultIteratorBase operator++();
  91     int batchSize() const;
  92     void batchedAdvance();
  93     bool operator==(const ResultIteratorBase &other) const;
  94     bool operator!=(const ResultIteratorBase &other) const;
  95     bool isVector() const;
  96     bool canIncrementVectorIndex() const;
  97 protected:
  98     QMap<int, ResultItem>::const_iterator mapIterator;
  99     int m_vectorIndex;
 100 };
 101
 102 template <typename T>
 103 class  ResultIterator : public ResultIteratorBase
 104 {
 105 public:
 106     ResultIterator(const ResultIteratorBase &base)
 107     : ResultIteratorBase(base) { }
 108
 109     const T &value() const
 110     {
 111         return *pointer();
 112     }
 113
 114     const T *pointer() const
 115     {
 116         if (mapIterator.value().isVector())
 117             return &(reinterpret_cast<const QVector<T> *>(mapIterator.value().result)->at(m_vectorIndex));
 118         else
 119             return reinterpret_cast<const T *>(mapIterator.value().result);
 120     }
 121 };
 122
 123 class Q_CORE_EXPORT ResultStoreBase
 124 {
 125 public:
 126     ResultStoreBase();
 127     void setFilterMode(bool enable);
 128     bool filterMode() const;
 129     int addResult(int index, const void *result);
 130     int addResults(int index, const void *results, int vectorSize, int logicalCount);
 131     ResultIteratorBase begin() const;
 132     ResultIteratorBase end() const;
 133     bool hasNextResult() const;
 134     ResultIteratorBase resultAt(int index) const;
 135     bool contains(int index) const;
 136     int count() const;
 137     virtual ~ResultStoreBase() { };
 138
 139 protected:
 140     int insertResultItem(int index, ResultItem &resultItem);
 141     void insertResultItemIfValid(int index, ResultItem &resultItem);
 142     void syncPendingResults();
 143     void syncResultCount();
 144     int updateInsertIndex(int index, int _count);
 145
 146     QMap<int, ResultItem> m_results;
 147     int insertIndex;     // The index where the next results(s) will be inserted.
 148     int resultCount;     // The number of consecutive results stored, starting at index 0.
 149
 150     bool m_filterMode;
 151     QMap<int, ResultItem> pendingResults;
 152     int filteredResults;
 153
 154 };
 155
 156 template <typename T>
 157 class ResultStore : public ResultStoreBase
 158 {
 159 public:
 160     ResultStore() { }
 161
 162     ResultStore(const ResultStoreBase &base)
 163     : ResultStoreBase(base) { }
 164
 165     int addResult(int index, const T  *result)
 166     {
 167         if (result == 0)
 168             return ResultStoreBase::addResult(index, result);
 169         else
 170             return ResultStoreBase::addResult(index, new T(*result));
 171     }
 172
 173     int addResults(int index, const QVector<T> *results)
 174     {
 175         return ResultStoreBase::addResults(index, new QVector<T>(*results), results->count(), results->count());
 176     }
 177
 178     int addResults(int index, const QVector<T> *results, int totalCount)
 179     {
 180         return ResultStoreBase::addResults(index, new QVector<T>(*results), results->count(), totalCount);
 181     }
 182
 183     int addCanceledResult(int index)
 184     {
 185         return addResult(index, 0);
 186     }
 187
 188     int addCanceledResults(int index, int _count)
 189     {
 190         QVector<T> empty;
 191         return addResults(index, &empty, _count);
 192     }
 193
 194     ResultIterator<T> begin() const
 195     {
 196         return static_cast<ResultIterator<T> >(ResultStoreBase::begin());
 197     }
 198
 199     ResultIterator<T> end() const
 200     {
 201         return static_cast<ResultIterator<T> >(ResultStoreBase::end());
 202     }
 203
 204     ResultIterator<T> resultAt(int index) const
 205     {
 206         return static_cast<ResultIterator<T> >(ResultStoreBase::resultAt(index));
 207     }
 208
 209     void clear()
 210     {
 211         QMap<int, ResultItem>::const_iterator mapIterator = m_results.constBegin();
 212         while (mapIterator != m_results.constEnd()) {
 213             if (mapIterator.value().isVector())
 214                 delete reinterpret_cast<const QVector<T> *>(mapIterator.value().result);
 215             else
 216                 delete reinterpret_cast<const T *>(mapIterator.value().result);
 217             ++mapIterator;
 218         }
 219         resultCount = 0;
 220         m_results.clear();
 221     }
 222
 223     ~ResultStore()
 224     {
 225         clear();
 226     }
 227
 228 };
 229
 230 } // namespace QtConcurrent
 231
 232 #endif //qdoc
 233
 234 QT_END_NAMESPACE
 235 QT_END_HEADER
 236
 237 #endif // QT_NO_CONCURRENT
 238
 239 #endif