Qt 4.8
qiterator.h
Go to the documentation of this file.
1 /****************************************************************************
2 **
3 ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies).
4 ** Contact: http://www.qt-project.org/legal
5 **
6 ** This file is part of the QtCore module of the Qt Toolkit.
7 **
8 ** $QT_BEGIN_LICENSE:LGPL$
9 ** Commercial License Usage
10 ** Licensees holding valid commercial Qt licenses may use this file in
11 ** accordance with the commercial license agreement provided with the
12 ** Software or, alternatively, in accordance with the terms contained in
13 ** a written agreement between you and Digia. For licensing terms and
14 ** conditions see http://qt.digia.com/licensing. For further information
15 ** use the contact form at http://qt.digia.com/contact-us.
16 **
17 ** GNU Lesser General Public License Usage
18 ** Alternatively, this file may be used under the terms of the GNU Lesser
19 ** General Public License version 2.1 as published by the Free Software
20 ** Foundation and appearing in the file LICENSE.LGPL included in the
21 ** packaging of this file. Please review the following information to
22 ** ensure the GNU Lesser General Public License version 2.1 requirements
23 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
24 **
25 ** In addition, as a special exception, Digia gives you certain additional
26 ** rights. These rights are described in the Digia Qt LGPL Exception
27 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
28 **
29 ** GNU General Public License Usage
30 ** Alternatively, this file may be used under the terms of the GNU
31 ** General Public License version 3.0 as published by the Free Software
32 ** Foundation and appearing in the file LICENSE.GPL included in the
33 ** packaging of this file. Please review the following information to
34 ** ensure the GNU General Public License version 3.0 requirements will be
35 ** met: http://www.gnu.org/copyleft/gpl.html.
36 **
37 **
38 ** $QT_END_LICENSE$
39 **
40 ****************************************************************************/
41 
42 #ifndef QITERATOR_H
43 #define QITERATOR_H
44 
45 #include <QtCore/qglobal.h>
46 
48 
49 #ifdef QT_NO_STL
50 # include <new> // No-op, indirectly include additional configuration headers.
51 # if defined(_LIBCPP_VERSION)
52 // libc++ may declare these structs in an inline namespace. Forward-declare
53 // these iterators in the same namespace so that we do not shadow the original
54 // declarations.
55 
56 // Tell clang not to warn about the use of inline namespaces when not building
57 // in C++11 mode.
58 # if defined(Q_CC_CLANG)
59 # pragma GCC diagnostic push
60 # pragma GCC diagnostic ignored "-Wc++11-extensions"
61 # endif
62 
63 _LIBCPP_BEGIN_NAMESPACE_STD
64  struct bidirectional_iterator_tag;
65  struct random_access_iterator_tag;
66 _LIBCPP_END_NAMESPACE_STD
67 
68 # if defined(Q_CC_CLANG)
69 # pragma GCC diagnostic pop
70 # endif
71 # else
72 namespace std {
73  struct bidirectional_iterator_tag;
74  struct random_access_iterator_tag;
75 }
76 # endif
77 #endif
78 
80 
81 QT_MODULE(Core)
82 
83 #define Q_DECLARE_SEQUENTIAL_ITERATOR(C) \
84 \
85 template <class T> \
86 class Q##C##Iterator \
87 { \
88  typedef typename Q##C<T>::const_iterator const_iterator; \
89  Q##C<T> c; \
90  const_iterator i; \
91 public: \
92  inline Q##C##Iterator(const Q##C<T> &container) \
93  : c(container), i(c.constBegin()) {} \
94  inline Q##C##Iterator &operator=(const Q##C<T> &container) \
95  { c = container; i = c.constBegin(); return *this; } \
96  inline void toFront() { i = c.constBegin(); } \
97  inline void toBack() { i = c.constEnd(); } \
98  inline bool hasNext() const { return i != c.constEnd(); } \
99  inline const T &next() { return *i++; } \
100  inline const T &peekNext() const { return *i; } \
101  inline bool hasPrevious() const { return i != c.constBegin(); } \
102  inline const T &previous() { return *--i; } \
103  inline const T &peekPrevious() const { const_iterator p = i; return *--p; } \
104  inline bool findNext(const T &t) \
105  { while (i != c.constEnd()) if (*i++ == t) return true; return false; } \
106  inline bool findPrevious(const T &t) \
107  { while (i != c.constBegin()) if (*(--i) == t) return true; \
108  return false; } \
109 };
110 
111 #define Q_DECLARE_MUTABLE_SEQUENTIAL_ITERATOR(C) \
112 \
113 template <class T> \
114 class QMutable##C##Iterator \
115 { \
116  typedef typename Q##C<T>::iterator iterator; \
117  typedef typename Q##C<T>::const_iterator const_iterator; \
118  Q##C<T> *c; \
119  iterator i, n; \
120  inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } \
121 public: \
122  inline QMutable##C##Iterator(Q##C<T> &container) \
123  : c(&container) \
124  { c->setSharable(false); i = c->begin(); n = c->end(); } \
125  inline ~QMutable##C##Iterator() \
126  { c->setSharable(true); } \
127  inline QMutable##C##Iterator &operator=(Q##C<T> &container) \
128  { c->setSharable(true); c = &container; c->setSharable(false); \
129  i = c->begin(); n = c->end(); return *this; } \
130  inline void toFront() { i = c->begin(); n = c->end(); } \
131  inline void toBack() { i = c->end(); n = i; } \
132  inline bool hasNext() const { return c->constEnd() != const_iterator(i); } \
133  inline T &next() { n = i++; return *n; } \
134  inline T &peekNext() const { return *i; } \
135  inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } \
136  inline T &previous() { n = --i; return *n; } \
137  inline T &peekPrevious() const { iterator p = i; return *--p; } \
138  inline void remove() \
139  { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } \
140  inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } \
141  inline T &value() { Q_ASSERT(item_exists()); return *n; } \
142  inline const T &value() const { Q_ASSERT(item_exists()); return *n; } \
143  inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } \
144  inline bool findNext(const T &t) \
145  { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } \
146  inline bool findPrevious(const T &t) \
147  { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; \
148  n = c->end(); return false; } \
149 };
150 
151 #define Q_DECLARE_ASSOCIATIVE_ITERATOR(C) \
152 \
153 template <class Key, class T> \
154 class Q##C##Iterator \
155 { \
156  typedef typename Q##C<Key,T>::const_iterator const_iterator; \
157  typedef const_iterator Item; \
158  Q##C<Key,T> c; \
159  const_iterator i, n; \
160  inline bool item_exists() const { return n != c.constEnd(); } \
161 public: \
162  inline Q##C##Iterator(const Q##C<Key,T> &container) \
163  : c(container), i(c.constBegin()), n(c.constEnd()) {} \
164  inline Q##C##Iterator &operator=(const Q##C<Key,T> &container) \
165  { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } \
166  inline void toFront() { i = c.constBegin(); n = c.constEnd(); } \
167  inline void toBack() { i = c.constEnd(); n = c.constEnd(); } \
168  inline bool hasNext() const { return i != c.constEnd(); } \
169  inline Item next() { n = i++; return n; } \
170  inline Item peekNext() const { return i; } \
171  inline bool hasPrevious() const { return i != c.constBegin(); } \
172  inline Item previous() { n = --i; return n; } \
173  inline Item peekPrevious() const { const_iterator p = i; return --p; } \
174  inline const T &value() const { Q_ASSERT(item_exists()); return *n; } \
175  inline const Key &key() const { Q_ASSERT(item_exists()); return n.key(); } \
176  inline bool findNext(const T &t) \
177  { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } \
178  inline bool findPrevious(const T &t) \
179  { while (i != c.constBegin()) if (*(n = --i) == t) return true; \
180  n = c.constEnd(); return false; } \
181 };
182 
183 #define Q_DECLARE_MUTABLE_ASSOCIATIVE_ITERATOR(C) \
184 \
185 template <class Key, class T> \
186 class QMutable##C##Iterator \
187 { \
188  typedef typename Q##C<Key,T>::iterator iterator; \
189  typedef typename Q##C<Key,T>::const_iterator const_iterator; \
190  typedef iterator Item; \
191  Q##C<Key,T> *c; \
192  iterator i, n; \
193  inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } \
194 public: \
195  inline QMutable##C##Iterator(Q##C<Key,T> &container) \
196  : c(&container) \
197  { c->setSharable(false); i = c->begin(); n = c->end(); } \
198  inline ~QMutable##C##Iterator() \
199  { c->setSharable(true); } \
200  inline QMutable##C##Iterator &operator=(Q##C<Key,T> &container) \
201  { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } \
202  inline void toFront() { i = c->begin(); n = c->end(); } \
203  inline void toBack() { i = c->end(); n = c->end(); } \
204  inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } \
205  inline Item next() { n = i++; return n; } \
206  inline Item peekNext() const { return i; } \
207  inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } \
208  inline Item previous() { n = --i; return n; } \
209  inline Item peekPrevious() const { iterator p = i; return --p; } \
210  inline void remove() \
211  { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } \
212  inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } \
213  inline T &value() { Q_ASSERT(item_exists()); return *n; } \
214  inline const T &value() const { Q_ASSERT(item_exists()); return *n; } \
215  inline const Key &key() const { Q_ASSERT(item_exists()); return n.key(); } \
216  inline bool findNext(const T &t) \
217  { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } \
218  inline bool findPrevious(const T &t) \
219  { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; \
220  n = c->end(); return false; } \
221 };
222 
224 
226 
227 #endif // QITERATOR_H
#define QT_END_NAMESPACE
This macro expands to.
Definition: qglobal.h:90
#define QT_MODULE(x)
Definition: qglobal.h:2783
#define QT_BEGIN_HEADER
Definition: qglobal.h:136
STL namespace.
#define QT_BEGIN_NAMESPACE
This macro expands to.
Definition: qglobal.h:89
#define QT_END_HEADER
Definition: qglobal.h:137