]>
Commit | Line | Data |
---|---|---|
81f80d8c MF |
1 | typedef long int ptrdiff_t; |
2 | typedef long unsigned int size_t; | |
3 | typedef signed char qint8; | |
4 | typedef unsigned char quint8; | |
5 | typedef short qint16; | |
6 | typedef unsigned short quint16; | |
7 | typedef int qint32; | |
8 | typedef unsigned int quint32; | |
9 | typedef long long qint64; | |
10 | typedef unsigned long long quint64; | |
11 | typedef qint64 qlonglong; | |
12 | typedef quint64 qulonglong; | |
13 | template <int> class QUintForSize { private: typedef void Type; }; | |
14 | template <> class QUintForSize<4> { public: typedef quint32 Type; }; | |
15 | template <> class QUintForSize<8> { public: typedef quint64 Type; }; | |
16 | template <typename T> class QUintForType : public QUintForSize<sizeof(T)> { }; | |
17 | typedef QUintForType<void *>::Type quintptr; | |
18 | template <int> class QIntForSize { private: typedef void Type; }; | |
19 | template <> class QIntForSize<4> { public: typedef qint32 Type; }; | |
20 | template <> class QIntForSize<8> { public: typedef qint64 Type; }; | |
21 | template <typename T> class QIntForType : public QIntForSize<sizeof(T)> { }; | |
22 | typedef QIntForType<void *>::Type qptrdiff; | |
23 | typedef unsigned char uchar; | |
24 | typedef unsigned short ushort; | |
25 | typedef unsigned int uint; | |
26 | typedef unsigned long ulong; | |
27 | typedef int QNoImplicitBoolCast; | |
28 | typedef double qreal; | |
29 | template <typename T> | |
30 | inline T qAbs(const T &t) { return t >= 0 ? t : -t; } | |
31 | inline int qRound(qreal d) | |
32 | { return d >= 0.0 ? int(d + 0.5) : int(d - int(d-1) + 0.5) + int(d-1); } | |
33 | inline qint64 qRound64(qreal d) | |
34 | { return d >= 0.0 ? qint64(d + 0.5) : qint64(d - qint64(d-1) + 0.5) + qint64(d-1); } | |
35 | template <typename T> | |
36 | inline const T &qMin(const T &a, const T &b) { if (a < b) return a; return b; } | |
37 | template <typename T> | |
38 | inline const T &qMax(const T &a, const T &b) { if (a < b) return b; return a; } | |
39 | template <typename T> | |
40 | inline const T &qBound(const T &min, const T &val, const T &max) | |
41 | { return qMax(min, qMin(max, val)); } | |
42 | class QDataStream; | |
43 | class QString; | |
44 | class __attribute__((visibility("default"))) QSysInfo { | |
45 | public: | |
46 | enum Sizes { | |
47 | WordSize = (sizeof(void *)<<3) | |
48 | }; | |
49 | enum Endian { | |
50 | BigEndian, | |
51 | LittleEndian | |
52 | , ByteOrder = LittleEndian | |
53 | }; | |
54 | }; | |
55 | __attribute__((visibility("default"))) const char *qVersion(); | |
56 | __attribute__((visibility("default"))) bool qSharedBuild(); | |
57 | __attribute__((visibility("default"))) void qDebug(const char *, ...) | |
58 | __attribute__ ((format (printf, 1, 2))) | |
59 | ; | |
60 | __attribute__((visibility("default"))) void qWarning(const char *, ...) | |
61 | __attribute__ ((format (printf, 1, 2))) | |
62 | ; | |
63 | class QString; | |
64 | __attribute__((visibility("default"))) QString qt_error_string(int errorCode = -1); | |
65 | __attribute__((visibility("default"))) void qCritical(const char *, ...) | |
66 | __attribute__ ((format (printf, 1, 2))) | |
67 | ; | |
68 | __attribute__((visibility("default"))) void qFatal(const char *, ...) | |
69 | __attribute__ ((format (printf, 1, 2))) | |
70 | ; | |
71 | __attribute__((visibility("default"))) void qErrnoWarning(int code, const char *msg, ...); | |
72 | __attribute__((visibility("default"))) void qErrnoWarning(const char *msg, ...); | |
73 | class QDebug; | |
74 | class QNoDebug; | |
75 | __attribute__((visibility("default"))) inline QDebug qDebug(); | |
76 | __attribute__((visibility("default"))) inline QDebug qWarning(); | |
77 | __attribute__((visibility("default"))) inline QDebug qCritical(); | |
78 | inline void qt_noop() {} | |
79 | __attribute__((visibility("default"))) void qt_assert(const char *assertion, const char *file, int line); | |
80 | __attribute__((visibility("default"))) void qt_assert_x(const char *where, const char *what, const char *file, int line); | |
81 | __attribute__((visibility("default"))) void qt_check_pointer(const char *, int); | |
82 | enum QtMsgType { QtDebugMsg, QtWarningMsg, QtCriticalMsg, QtFatalMsg, QtSystemMsg = QtCriticalMsg }; | |
83 | __attribute__((visibility("default"))) void qt_message_output(QtMsgType, const char *buf); | |
84 | typedef void (*QtMsgHandler)(QtMsgType, const char *); | |
85 | __attribute__((visibility("default"))) QtMsgHandler qInstallMsgHandler(QtMsgHandler); | |
86 | template <typename T> class QBasicAtomicPointer; | |
87 | template <typename T> | |
88 | class QGlobalStatic | |
89 | { | |
90 | public: | |
91 | QBasicAtomicPointer<T> pointer; | |
92 | bool destroyed; | |
93 | }; | |
94 | template <typename T> | |
95 | class QGlobalStaticDeleter | |
96 | { | |
97 | public: | |
98 | QGlobalStatic<T> &globalStatic; | |
99 | QGlobalStaticDeleter(QGlobalStatic<T> &_globalStatic) | |
100 | : globalStatic(_globalStatic) | |
101 | { } | |
102 | inline ~QGlobalStaticDeleter() | |
103 | { | |
104 | delete globalStatic.pointer; | |
105 | globalStatic.pointer = 0; | |
106 | globalStatic.destroyed = true; | |
107 | } | |
108 | }; | |
109 | class QBool | |
110 | { | |
111 | bool b; | |
112 | public: | |
113 | inline explicit QBool(bool B) : b(B) {} | |
114 | inline operator const void *() const | |
115 | { return b ? static_cast<const void *>(this) : static_cast<const void *>(0); } | |
116 | }; | |
117 | inline bool operator==(QBool b1, bool b2) { return !b1 == !b2; } | |
118 | inline bool operator==(bool b1, QBool b2) { return !b1 == !b2; } | |
119 | inline bool operator==(QBool b1, QBool b2) { return !b1 == !b2; } | |
120 | inline bool operator!=(QBool b1, bool b2) { return !b1 != !b2; } | |
121 | inline bool operator!=(bool b1, QBool b2) { return !b1 != !b2; } | |
122 | inline bool operator!=(QBool b1, QBool b2) { return !b1 != !b2; } | |
123 | static inline bool qFuzzyCompare(double p1, double p2) | |
124 | { | |
125 | return (qAbs(p1 - p2) <= 0.000000000001 * qMin(qAbs(p1), qAbs(p2))); | |
126 | } | |
127 | static inline bool qFuzzyCompare(float p1, float p2) | |
128 | { | |
129 | return (qAbs(p1 - p2) <= 0.00001f * qMin(qAbs(p1), qAbs(p2))); | |
130 | } | |
131 | static inline bool qIsNull(double d) | |
132 | { | |
133 | union U { | |
134 | double d; | |
135 | quint64 u; | |
136 | }; | |
137 | U val; | |
138 | val.d = d; | |
139 | return val.u == quint64(0); | |
140 | } | |
141 | static inline bool qIsNull(float f) | |
142 | { | |
143 | union U { | |
144 | float f; | |
145 | quint32 u; | |
146 | }; | |
147 | U val; | |
148 | val.f = f; | |
149 | return val.u == 0u; | |
150 | } | |
151 | template <typename T> inline bool qIsDetached(T &) { return true; } | |
152 | template <typename T> | |
153 | class QTypeInfo | |
154 | { | |
155 | public: | |
156 | enum { | |
157 | isPointer = false, | |
158 | isComplex = true, | |
159 | isStatic = true, | |
160 | isLarge = (sizeof(T)>sizeof(void*)), | |
161 | isDummy = false | |
162 | }; | |
163 | }; | |
164 | template <typename T> | |
165 | class QTypeInfo<T*> | |
166 | { | |
167 | public: | |
168 | enum { | |
169 | isPointer = true, | |
170 | isComplex = false, | |
171 | isStatic = false, | |
172 | isLarge = false, | |
173 | isDummy = false | |
174 | }; | |
175 | }; | |
176 | enum { | |
177 | Q_COMPLEX_TYPE = 0, | |
178 | Q_PRIMITIVE_TYPE = 0x1, | |
179 | Q_STATIC_TYPE = 0, | |
180 | Q_MOVABLE_TYPE = 0x2, | |
181 | Q_DUMMY_TYPE = 0x4 | |
182 | }; | |
183 | template <> class QTypeInfo<bool> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(bool)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "bool"; } }; | |
184 | template <> class QTypeInfo<char> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "char"; } }; | |
185 | template <> class QTypeInfo<signed char> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(signed char)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "signed char"; } }; | |
186 | template <> class QTypeInfo<uchar> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uchar)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uchar"; } }; | |
187 | template <> class QTypeInfo<short> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(short)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "short"; } }; | |
188 | template <> class QTypeInfo<ushort> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ushort)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ushort"; } }; | |
189 | template <> class QTypeInfo<int> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(int)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "int"; } }; | |
190 | template <> class QTypeInfo<uint> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(uint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "uint"; } }; | |
191 | template <> class QTypeInfo<long> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long"; } }; | |
192 | template <> class QTypeInfo<ulong> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(ulong)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "ulong"; } }; | |
193 | template <> class QTypeInfo<qint64> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(qint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "qint64"; } }; | |
194 | template <> class QTypeInfo<quint64> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(quint64)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "quint64"; } }; | |
195 | template <> class QTypeInfo<float> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(float)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "float"; } }; | |
196 | template <> class QTypeInfo<double> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "double"; } }; | |
197 | template <> class QTypeInfo<long double> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(long double)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "long double"; } }; | |
198 | __attribute__((visibility("default"))) void *qMalloc(size_t size); | |
199 | __attribute__((visibility("default"))) void qFree(void *ptr); | |
200 | __attribute__((visibility("default"))) void *qRealloc(void *ptr, size_t size); | |
201 | __attribute__((visibility("default"))) void *qMemCopy(void *dest, const void *src, size_t n); | |
202 | __attribute__((visibility("default"))) void *qMemSet(void *dest, int c, size_t n); | |
203 | class __attribute__((visibility("default"))) QFlag | |
204 | { | |
205 | int i; | |
206 | public: | |
207 | inline QFlag(int i); | |
208 | inline operator int() const { return i; } | |
209 | }; | |
210 | inline QFlag::QFlag(int ai) : i(ai) {} | |
211 | class __attribute__((visibility("default"))) QIncompatibleFlag | |
212 | { | |
213 | int i; | |
214 | public: | |
215 | inline explicit QIncompatibleFlag(int i); | |
216 | inline operator int() const { return i; } | |
217 | }; | |
218 | inline QIncompatibleFlag::QIncompatibleFlag(int ai) : i(ai) {} | |
219 | template<typename Enum> | |
220 | class QFlags | |
221 | { | |
222 | typedef void **Zero; | |
223 | int i; | |
224 | public: | |
225 | typedef Enum enum_type; | |
226 | inline QFlags(const QFlags &f) : i(f.i) {} | |
227 | inline QFlags(Enum f) : i(f) {} | |
228 | inline QFlags(Zero = 0) : i(0) {} | |
229 | inline QFlags(QFlag f) : i(f) {} | |
230 | inline QFlags &operator=(const QFlags &f) { i = f.i; return *this; } | |
231 | inline QFlags &operator&=(int mask) { i &= mask; return *this; } | |
232 | inline QFlags &operator&=(uint mask) { i &= mask; return *this; } | |
233 | inline QFlags &operator|=(QFlags f) { i |= f.i; return *this; } | |
234 | inline QFlags &operator|=(Enum f) { i |= f; return *this; } | |
235 | inline QFlags &operator^=(QFlags f) { i ^= f.i; return *this; } | |
236 | inline QFlags &operator^=(Enum f) { i ^= f; return *this; } | |
237 | inline operator int() const { return i; } | |
238 | inline QFlags operator|(QFlags f) const { QFlags g; g.i = i | f.i; return g; } | |
239 | inline QFlags operator|(Enum f) const { QFlags g; g.i = i | f; return g; } | |
240 | inline QFlags operator^(QFlags f) const { QFlags g; g.i = i ^ f.i; return g; } | |
241 | inline QFlags operator^(Enum f) const { QFlags g; g.i = i ^ f; return g; } | |
242 | inline QFlags operator&(int mask) const { QFlags g; g.i = i & mask; return g; } | |
243 | inline QFlags operator&(uint mask) const { QFlags g; g.i = i & mask; return g; } | |
244 | inline QFlags operator&(Enum f) const { QFlags g; g.i = i & f; return g; } | |
245 | inline QFlags operator~() const { QFlags g; g.i = ~i; return g; } | |
246 | inline bool operator!() const { return !i; } | |
247 | inline bool testFlag(Enum f) const { return (i & f) == f; } | |
248 | }; | |
249 | template <typename T> | |
250 | class QForeachContainer { | |
251 | public: | |
252 | inline QForeachContainer(const T& t) : c(t), brk(0), i(c.begin()), e(c.end()) { } | |
253 | const T c; | |
254 | int brk; | |
255 | typename T::const_iterator i, e; | |
256 | }; | |
257 | class QByteArray; | |
258 | __attribute__((visibility("default"))) QByteArray qgetenv(const char *varName); | |
259 | __attribute__((visibility("default"))) bool qputenv(const char *varName, const QByteArray& value); | |
260 | inline int qIntCast(double f) { return int(f); } | |
261 | inline int qIntCast(float f) { return int(f); } | |
262 | __attribute__((visibility("default"))) void qsrand(uint seed); | |
263 | __attribute__((visibility("default"))) int qrand(); | |
264 | enum QtValidLicenseForCoreModule { LicensedCore = true }; | |
265 | enum QtValidLicenseForGuiModule { LicensedGui = true }; | |
266 | enum QtValidLicenseForNetworkModule { LicensedNetwork = true }; | |
267 | enum QtValidLicenseForOpenGLModule { LicensedOpenGL = true }; | |
268 | enum QtValidLicenseForSqlModule { LicensedSql = true }; | |
269 | enum QtValidLicenseForXmlModule { LicensedXml = true }; | |
270 | enum QtValidLicenseForXmlPatternsModule { LicensedXmlPatterns = true }; | |
271 | enum QtValidLicenseForHelpModule { LicensedHelp = true }; | |
272 | enum QtValidLicenseForScriptModule { LicensedScript = true }; | |
273 | enum QtValidLicenseForScriptToolsModule { LicensedScriptTools = true }; | |
274 | enum QtValidLicenseForQt3SupportLightModule { LicensedQt3SupportLight = true }; | |
275 | enum QtValidLicenseForQt3SupportModule { LicensedQt3Support = true }; | |
276 | enum QtValidLicenseForSvgModule { LicensedSvg = true }; | |
277 | enum QtValidLicenseForTestModule { LicensedTest = true }; | |
278 | enum QtValidLicenseForDBusModule { LicensedDBus = true }; | |
279 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
280 | namespace QAlgorithmsPrivate { | |
281 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
282 | void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan); | |
283 | template <typename RandomAccessIterator, typename T> | |
284 | inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy); | |
285 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
286 | void qStableSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan); | |
287 | template <typename RandomAccessIterator, typename T> | |
288 | inline void qStableSortHelper(RandomAccessIterator, RandomAccessIterator, const T &); | |
289 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
290 | RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan); | |
291 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
292 | RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan); | |
293 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
294 | RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan); | |
295 | } | |
296 | template <typename InputIterator, typename OutputIterator> | |
297 | inline OutputIterator qCopy(InputIterator begin, InputIterator end, OutputIterator dest) | |
298 | { | |
299 | while (begin != end) | |
300 | *dest++ = *begin++; | |
301 | return dest; | |
302 | } | |
303 | template <typename BiIterator1, typename BiIterator2> | |
304 | inline BiIterator2 qCopyBackward(BiIterator1 begin, BiIterator1 end, BiIterator2 dest) | |
305 | { | |
306 | while (begin != end) | |
307 | *--dest = *--end; | |
308 | return dest; | |
309 | } | |
310 | template <typename InputIterator1, typename InputIterator2> | |
311 | inline bool qEqual(InputIterator1 first1, InputIterator1 last1, InputIterator2 first2) | |
312 | { | |
313 | for (; first1 != last1; ++first1, ++first2) | |
314 | if (!(*first1 == *first2)) | |
315 | return false; | |
316 | return true; | |
317 | } | |
318 | template <typename ForwardIterator, typename T> | |
319 | inline void qFill(ForwardIterator first, ForwardIterator last, const T &val) | |
320 | { | |
321 | for (; first != last; ++first) | |
322 | *first = val; | |
323 | } | |
324 | template <typename Container, typename T> | |
325 | inline void qFill(Container &container, const T &val) | |
326 | { | |
327 | qFill(container.begin(), container.end(), val); | |
328 | } | |
329 | template <typename InputIterator, typename T> | |
330 | inline InputIterator qFind(InputIterator first, InputIterator last, const T &val) | |
331 | { | |
332 | while (first != last && !(*first == val)) | |
333 | ++first; | |
334 | return first; | |
335 | } | |
336 | template <typename Container, typename T> | |
337 | inline typename Container::const_iterator qFind(const Container &container, const T &val) | |
338 | { | |
339 | return qFind(container.constBegin(), container.constEnd(), val); | |
340 | } | |
341 | template <typename InputIterator, typename T, typename Size> | |
342 | inline void qCount(InputIterator first, InputIterator last, const T &value, Size &n) | |
343 | { | |
344 | for (; first != last; ++first) | |
345 | if (*first == value) | |
346 | ++n; | |
347 | } | |
348 | template <typename Container, typename T, typename Size> | |
349 | inline void qCount(const Container &container, const T &value, Size &n) | |
350 | { | |
351 | qCount(container.constBegin(), container.constEnd(), value, n); | |
352 | } | |
353 | template <typename T> | |
354 | inline void qSwap(T &value1, T &value2) | |
355 | { | |
356 | T t = value1; | |
357 | value1 = value2; | |
358 | value2 = t; | |
359 | } | |
360 | template <typename T> | |
361 | class qLess | |
362 | { | |
363 | public: | |
364 | inline bool operator()(const T &t1, const T &t2) const | |
365 | { | |
366 | return (t1 < t2); | |
367 | } | |
368 | }; | |
369 | template <typename T> | |
370 | class qGreater | |
371 | { | |
372 | public: | |
373 | inline bool operator()(const T &t1, const T &t2) const | |
374 | { | |
375 | return (t2 < t1); | |
376 | } | |
377 | }; | |
378 | template <typename RandomAccessIterator> | |
379 | inline void qSort(RandomAccessIterator start, RandomAccessIterator end) | |
380 | { | |
381 | if (start != end) | |
382 | QAlgorithmsPrivate::qSortHelper(start, end, *start); | |
383 | } | |
384 | template <typename RandomAccessIterator, typename LessThan> | |
385 | inline void qSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan) | |
386 | { | |
387 | if (start != end) | |
388 | QAlgorithmsPrivate::qSortHelper(start, end, *start, lessThan); | |
389 | } | |
390 | template<typename Container> | |
391 | inline void qSort(Container &c) | |
392 | { | |
393 | if (!c.empty()) | |
394 | QAlgorithmsPrivate::qSortHelper(c.begin(), c.end(), *c.begin()); | |
395 | } | |
396 | template <typename RandomAccessIterator> | |
397 | inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end) | |
398 | { | |
399 | if (start != end) | |
400 | QAlgorithmsPrivate::qStableSortHelper(start, end, *start); | |
401 | } | |
402 | template <typename RandomAccessIterator, typename LessThan> | |
403 | inline void qStableSort(RandomAccessIterator start, RandomAccessIterator end, LessThan lessThan) | |
404 | { | |
405 | if (start != end) | |
406 | QAlgorithmsPrivate::qStableSortHelper(start, end, *start, lessThan); | |
407 | } | |
408 | template<typename Container> | |
409 | inline void qStableSort(Container &c) | |
410 | { | |
411 | if (!c.empty()) | |
412 | QAlgorithmsPrivate::qStableSortHelper(c.begin(), c.end(), *c.begin()); | |
413 | } | |
414 | template <typename RandomAccessIterator, typename T> | |
415 | RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value) | |
416 | { | |
417 | RandomAccessIterator middle; | |
418 | int n = end - begin; | |
419 | int half; | |
420 | while (n > 0) { | |
421 | half = n >> 1; | |
422 | middle = begin + half; | |
423 | if (*middle < value) { | |
424 | begin = middle + 1; | |
425 | n -= half + 1; | |
426 | } else { | |
427 | n = half; | |
428 | } | |
429 | } | |
430 | return begin; | |
431 | } | |
432 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
433 | RandomAccessIterator qLowerBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) | |
434 | { | |
435 | return QAlgorithmsPrivate::qLowerBoundHelper(begin, end, value, lessThan); | |
436 | } | |
437 | template <typename Container, typename T> | |
438 | typename Container::const_iterator qLowerBound(const Container &container, const T &value) | |
439 | { | |
440 | return QAlgorithmsPrivate::qLowerBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>()); | |
441 | } | |
442 | template <typename RandomAccessIterator, typename T> | |
443 | RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value) | |
444 | { | |
445 | RandomAccessIterator middle; | |
446 | int n = end - begin; | |
447 | int half; | |
448 | while (n > 0) { | |
449 | half = n >> 1; | |
450 | middle = begin + half; | |
451 | if (value < *middle) { | |
452 | n = half; | |
453 | } else { | |
454 | begin = middle + 1; | |
455 | n -= half + 1; | |
456 | } | |
457 | } | |
458 | return begin; | |
459 | } | |
460 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
461 | RandomAccessIterator qUpperBound(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) | |
462 | { | |
463 | return QAlgorithmsPrivate::qUpperBoundHelper(begin, end, value, lessThan); | |
464 | } | |
465 | template <typename Container, typename T> | |
466 | typename Container::const_iterator qUpperBound(const Container &container, const T &value) | |
467 | { | |
468 | return QAlgorithmsPrivate::qUpperBoundHelper(container.constBegin(), container.constEnd(), value, qLess<T>()); | |
469 | } | |
470 | template <typename RandomAccessIterator, typename T> | |
471 | RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value) | |
472 | { | |
473 | qint64 l = 0; | |
474 | qint64 r = end - begin - 1; | |
475 | if (r < 0) | |
476 | return end; | |
477 | qint64 i = (l + r + 1) / 2; | |
478 | while (r != l) { | |
479 | if (value < begin[i]) | |
480 | r = i - 1; | |
481 | else | |
482 | l = i; | |
483 | i = (l + r + 1) / 2; | |
484 | } | |
485 | if (begin[i] < value || value < begin[i]) | |
486 | return end; | |
487 | else | |
488 | return begin + i; | |
489 | } | |
490 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
491 | RandomAccessIterator qBinaryFind(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) | |
492 | { | |
493 | return QAlgorithmsPrivate::qBinaryFindHelper(begin, end, value, lessThan); | |
494 | } | |
495 | template <typename Container, typename T> | |
496 | typename Container::const_iterator qBinaryFind(const Container &container, const T &value) | |
497 | { | |
498 | return QAlgorithmsPrivate::qBinaryFindHelper(container.constBegin(), container.constEnd(), value, qLess<T>()); | |
499 | } | |
500 | template <typename ForwardIterator> | |
501 | void qDeleteAll(ForwardIterator begin, ForwardIterator end) | |
502 | { | |
503 | while (begin != end) { | |
504 | delete *begin; | |
505 | ++begin; | |
506 | } | |
507 | } | |
508 | template <typename Container> | |
509 | inline void qDeleteAll(const Container &c) | |
510 | { | |
511 | qDeleteAll(c.begin(), c.end()); | |
512 | } | |
513 | namespace QAlgorithmsPrivate { | |
514 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
515 | void qSortHelper(RandomAccessIterator start, RandomAccessIterator end, const T &t, LessThan lessThan) | |
516 | { | |
517 | top: | |
518 | int span = end - start; | |
519 | if (span < 2) | |
520 | return; | |
521 | --end; | |
522 | RandomAccessIterator low = start, high = end - 1; | |
523 | RandomAccessIterator pivot = start + span / 2; | |
524 | if (lessThan(*end, *start)) | |
525 | qSwap(*end, *start); | |
526 | if (span == 2) | |
527 | return; | |
528 | if (lessThan(*pivot, *start)) | |
529 | qSwap(*pivot, *start); | |
530 | if (lessThan(*end, *pivot)) | |
531 | qSwap(*end, *pivot); | |
532 | if (span == 3) | |
533 | return; | |
534 | qSwap(*pivot, *end); | |
535 | while (low < high) { | |
536 | while (low < high && lessThan(*low, *end)) | |
537 | ++low; | |
538 | while (high > low && lessThan(*end, *high)) | |
539 | --high; | |
540 | if (low < high) { | |
541 | qSwap(*low, *high); | |
542 | ++low; | |
543 | --high; | |
544 | } else { | |
545 | break; | |
546 | } | |
547 | } | |
548 | if (lessThan(*low, *end)) | |
549 | ++low; | |
550 | qSwap(*end, *low); | |
551 | qSortHelper(start, low, t, lessThan); | |
552 | start = low + 1; | |
553 | ++end; | |
554 | goto top; | |
555 | } | |
556 | template <typename RandomAccessIterator, typename T> | |
557 | inline void qSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy) | |
558 | { | |
559 | qSortHelper(begin, end, dummy, qLess<T>()); | |
560 | } | |
561 | template <typename RandomAccessIterator> | |
562 | void qReverse(RandomAccessIterator begin, RandomAccessIterator end) | |
563 | { | |
564 | --end; | |
565 | while (begin < end) | |
566 | qSwap(*begin++, *end--); | |
567 | } | |
568 | template <typename RandomAccessIterator> | |
569 | void qRotate(RandomAccessIterator begin, RandomAccessIterator middle, RandomAccessIterator end) | |
570 | { | |
571 | qReverse(begin, middle); | |
572 | qReverse(middle, end); | |
573 | qReverse(begin, end); | |
574 | } | |
575 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
576 | void qMerge(RandomAccessIterator begin, RandomAccessIterator pivot, RandomAccessIterator end, T &t, LessThan lessThan) | |
577 | { | |
578 | const int len1 = pivot - begin; | |
579 | const int len2 = end - pivot; | |
580 | if (len1 == 0 || len2 == 0) | |
581 | return; | |
582 | if (len1 + len2 == 2) { | |
583 | if (lessThan(*(begin + 1), *(begin))) | |
584 | qSwap(*begin, *(begin + 1)); | |
585 | return; | |
586 | } | |
587 | RandomAccessIterator firstCut; | |
588 | RandomAccessIterator secondCut; | |
589 | int len2Half; | |
590 | if (len1 > len2) { | |
591 | const int len1Half = len1 / 2; | |
592 | firstCut = begin + len1Half; | |
593 | secondCut = qLowerBound(pivot, end, *firstCut, lessThan); | |
594 | len2Half = secondCut - pivot; | |
595 | } else { | |
596 | len2Half = len2 / 2; | |
597 | secondCut = pivot + len2Half; | |
598 | firstCut = qUpperBound(begin, pivot, *secondCut, lessThan); | |
599 | } | |
600 | qRotate(firstCut, pivot, secondCut); | |
601 | const RandomAccessIterator newPivot = firstCut + len2Half; | |
602 | qMerge(begin, firstCut, newPivot, t, lessThan); | |
603 | qMerge(newPivot, secondCut, end, t, lessThan); | |
604 | } | |
605 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
606 | void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &t, LessThan lessThan) | |
607 | { | |
608 | const int span = end - begin; | |
609 | if (span < 2) | |
610 | return; | |
611 | const RandomAccessIterator middle = begin + span / 2; | |
612 | qStableSortHelper(begin, middle, t, lessThan); | |
613 | qStableSortHelper(middle, end, t, lessThan); | |
614 | qMerge(begin, middle, end, t, lessThan); | |
615 | } | |
616 | template <typename RandomAccessIterator, typename T> | |
617 | inline void qStableSortHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &dummy) | |
618 | { | |
619 | qStableSortHelper(begin, end, dummy, qLess<T>()); | |
620 | } | |
621 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
622 | RandomAccessIterator qLowerBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) | |
623 | { | |
624 | RandomAccessIterator middle; | |
625 | int n = end - begin; | |
626 | int half; | |
627 | while (n > 0) { | |
628 | half = n >> 1; | |
629 | middle = begin + half; | |
630 | if (lessThan(*middle, value)) { | |
631 | begin = middle + 1; | |
632 | n -= half + 1; | |
633 | } else { | |
634 | n = half; | |
635 | } | |
636 | } | |
637 | return begin; | |
638 | } | |
639 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
640 | RandomAccessIterator qUpperBoundHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) | |
641 | { | |
642 | RandomAccessIterator middle; | |
643 | int n = end - begin; | |
644 | int half; | |
645 | while (n > 0) { | |
646 | half = n >> 1; | |
647 | middle = begin + half; | |
648 | if (lessThan(value, *middle)) { | |
649 | n = half; | |
650 | } else { | |
651 | begin = middle + 1; | |
652 | n -= half + 1; | |
653 | } | |
654 | } | |
655 | return begin; | |
656 | } | |
657 | template <typename RandomAccessIterator, typename T, typename LessThan> | |
658 | RandomAccessIterator qBinaryFindHelper(RandomAccessIterator begin, RandomAccessIterator end, const T &value, LessThan lessThan) | |
659 | { | |
660 | qint64 l = 0; | |
661 | qint64 r = end - begin - 1; | |
662 | if (r < 0) | |
663 | return end; | |
664 | qint64 i = (l + r + 1) / 2; | |
665 | while (r != l) { | |
666 | if (lessThan(value, begin[i])) | |
667 | r = i - 1; | |
668 | else | |
669 | l = i; | |
670 | i = (l + r + 1) / 2; | |
671 | } | |
672 | if (lessThan(begin[i], value) || lessThan(value, begin[i])) | |
673 | return end; | |
674 | else | |
675 | return begin + i; | |
676 | } | |
677 | } | |
678 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
679 | class __attribute__((visibility("default"))) QBasicAtomicInt | |
680 | { | |
681 | public: | |
682 | volatile int _q_value; | |
683 | inline bool operator==(int value) const | |
684 | { | |
685 | return _q_value == value; | |
686 | } | |
687 | inline bool operator!=(int value) const | |
688 | { | |
689 | return _q_value != value; | |
690 | } | |
691 | inline bool operator!() const | |
692 | { | |
693 | return _q_value == 0; | |
694 | } | |
695 | inline operator int() const | |
696 | { | |
697 | return _q_value; | |
698 | } | |
699 | inline QBasicAtomicInt &operator=(int value) | |
700 | { | |
701 | _q_value = value; | |
702 | return *this; | |
703 | } | |
704 | static bool isReferenceCountingNative(); | |
705 | static bool isReferenceCountingWaitFree(); | |
706 | bool ref(); | |
707 | bool deref(); | |
708 | static bool isTestAndSetNative(); | |
709 | static bool isTestAndSetWaitFree(); | |
710 | bool testAndSetRelaxed(int expectedValue, int newValue); | |
711 | bool testAndSetAcquire(int expectedValue, int newValue); | |
712 | bool testAndSetRelease(int expectedValue, int newValue); | |
713 | bool testAndSetOrdered(int expectedValue, int newValue); | |
714 | static bool isFetchAndStoreNative(); | |
715 | static bool isFetchAndStoreWaitFree(); | |
716 | int fetchAndStoreRelaxed(int newValue); | |
717 | int fetchAndStoreAcquire(int newValue); | |
718 | int fetchAndStoreRelease(int newValue); | |
719 | int fetchAndStoreOrdered(int newValue); | |
720 | static bool isFetchAndAddNative(); | |
721 | static bool isFetchAndAddWaitFree(); | |
722 | int fetchAndAddRelaxed(int valueToAdd); | |
723 | int fetchAndAddAcquire(int valueToAdd); | |
724 | int fetchAndAddRelease(int valueToAdd); | |
725 | int fetchAndAddOrdered(int valueToAdd); | |
726 | }; | |
727 | template <typename T> | |
728 | class QBasicAtomicPointer | |
729 | { | |
730 | public: | |
731 | T * volatile _q_value; | |
732 | inline bool operator==(T *value) const | |
733 | { | |
734 | return _q_value == value; | |
735 | } | |
736 | inline bool operator!=(T *value) const | |
737 | { | |
738 | return !operator==(value); | |
739 | } | |
740 | inline bool operator!() const | |
741 | { | |
742 | return operator==(0); | |
743 | } | |
744 | inline operator T *() const | |
745 | { | |
746 | return _q_value; | |
747 | } | |
748 | inline T *operator->() const | |
749 | { | |
750 | return _q_value; | |
751 | } | |
752 | inline QBasicAtomicPointer<T> &operator=(T *value) | |
753 | { | |
754 | _q_value = value; | |
755 | return *this; | |
756 | } | |
757 | static bool isTestAndSetNative(); | |
758 | static bool isTestAndSetWaitFree(); | |
759 | bool testAndSetRelaxed(T *expectedValue, T *newValue); | |
760 | bool testAndSetAcquire(T *expectedValue, T *newValue); | |
761 | bool testAndSetRelease(T *expectedValue, T *newValue); | |
762 | bool testAndSetOrdered(T *expectedValue, T *newValue); | |
763 | static bool isFetchAndStoreNative(); | |
764 | static bool isFetchAndStoreWaitFree(); | |
765 | T *fetchAndStoreRelaxed(T *newValue); | |
766 | T *fetchAndStoreAcquire(T *newValue); | |
767 | T *fetchAndStoreRelease(T *newValue); | |
768 | T *fetchAndStoreOrdered(T *newValue); | |
769 | static bool isFetchAndAddNative(); | |
770 | static bool isFetchAndAddWaitFree(); | |
771 | T *fetchAndAddRelaxed(qptrdiff valueToAdd); | |
772 | T *fetchAndAddAcquire(qptrdiff valueToAdd); | |
773 | T *fetchAndAddRelease(qptrdiff valueToAdd); | |
774 | T *fetchAndAddOrdered(qptrdiff valueToAdd); | |
775 | }; | |
776 | inline bool QBasicAtomicInt::isReferenceCountingNative() | |
777 | { return false; } | |
778 | inline bool QBasicAtomicInt::isReferenceCountingWaitFree() | |
779 | { return false; } | |
780 | inline bool QBasicAtomicInt::isTestAndSetNative() | |
781 | { return false; } | |
782 | inline bool QBasicAtomicInt::isTestAndSetWaitFree() | |
783 | { return false; } | |
784 | inline bool QBasicAtomicInt::isFetchAndStoreNative() | |
785 | { return false; } | |
786 | inline bool QBasicAtomicInt::isFetchAndStoreWaitFree() | |
787 | { return false; } | |
788 | inline bool QBasicAtomicInt::isFetchAndAddNative() | |
789 | { return false; } | |
790 | inline bool QBasicAtomicInt::isFetchAndAddWaitFree() | |
791 | { return false; } | |
792 | template <typename T> | |
793 | inline bool QBasicAtomicPointer<T>::isTestAndSetNative() | |
794 | { return false; } | |
795 | template <typename T> | |
796 | inline bool QBasicAtomicPointer<T>::isTestAndSetWaitFree() | |
797 | { return false; } | |
798 | template <typename T> | |
799 | inline bool QBasicAtomicPointer<T>::isFetchAndStoreNative() | |
800 | { return false; } | |
801 | template <typename T> | |
802 | inline bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree() | |
803 | { return false; } | |
804 | template <typename T> | |
805 | inline bool QBasicAtomicPointer<T>::isFetchAndAddNative() | |
806 | { return false; } | |
807 | template <typename T> | |
808 | inline bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree() | |
809 | { return false; } | |
810 | __attribute__((visibility("default"))) bool QBasicAtomicInt_testAndSetOrdered(volatile int *, int, int); | |
811 | __attribute__((visibility("default"))) int QBasicAtomicInt_fetchAndStoreOrdered(volatile int *, int); | |
812 | __attribute__((visibility("default"))) int QBasicAtomicInt_fetchAndAddOrdered(volatile int *, int); | |
813 | __attribute__((visibility("default"))) bool QBasicAtomicPointer_testAndSetOrdered(void * volatile *, void *, void *); | |
814 | __attribute__((visibility("default"))) void *QBasicAtomicPointer_fetchAndStoreOrdered(void * volatile *, void *); | |
815 | __attribute__((visibility("default"))) void *QBasicAtomicPointer_fetchAndAddOrdered(void * volatile *, qptrdiff); | |
816 | inline bool QBasicAtomicInt::ref() | |
817 | { | |
818 | return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, 1) != -1; | |
819 | } | |
820 | inline bool QBasicAtomicInt::deref() | |
821 | { | |
822 | return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, -1) != 1; | |
823 | } | |
824 | inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue) | |
825 | { | |
826 | return QBasicAtomicInt_testAndSetOrdered(&_q_value, expectedValue, newValue); | |
827 | } | |
828 | inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue) | |
829 | { | |
830 | return testAndSetOrdered(expectedValue, newValue); | |
831 | } | |
832 | inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue) | |
833 | { | |
834 | return testAndSetOrdered(expectedValue, newValue); | |
835 | } | |
836 | inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue) | |
837 | { | |
838 | return testAndSetOrdered(expectedValue, newValue); | |
839 | } | |
840 | inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue) | |
841 | { | |
842 | return QBasicAtomicInt_fetchAndStoreOrdered(&_q_value, newValue); | |
843 | } | |
844 | inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue) | |
845 | { | |
846 | return fetchAndStoreOrdered(newValue); | |
847 | } | |
848 | inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue) | |
849 | { | |
850 | return fetchAndStoreOrdered(newValue); | |
851 | } | |
852 | inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue) | |
853 | { | |
854 | return fetchAndStoreOrdered(newValue); | |
855 | } | |
856 | inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd) | |
857 | { | |
858 | return QBasicAtomicInt_fetchAndAddOrdered(&_q_value, valueToAdd); | |
859 | } | |
860 | inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd) | |
861 | { | |
862 | return fetchAndAddOrdered(valueToAdd); | |
863 | } | |
864 | inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd) | |
865 | { | |
866 | return fetchAndAddOrdered(valueToAdd); | |
867 | } | |
868 | inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd) | |
869 | { | |
870 | return fetchAndAddOrdered(valueToAdd); | |
871 | } | |
872 | template <typename T> | |
873 | inline bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue) | |
874 | { | |
875 | union { T * volatile * typed; void * volatile * voidp; } pointer; | |
876 | pointer.typed = &_q_value; | |
877 | return QBasicAtomicPointer_testAndSetOrdered(pointer.voidp, expectedValue, newValue); | |
878 | } | |
879 | template <typename T> | |
880 | inline bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue) | |
881 | { | |
882 | return testAndSetOrdered(expectedValue, newValue); | |
883 | } | |
884 | template <typename T> | |
885 | inline bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue) | |
886 | { | |
887 | return testAndSetOrdered(expectedValue, newValue); | |
888 | } | |
889 | template <typename T> | |
890 | inline bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue) | |
891 | { | |
892 | return testAndSetOrdered(expectedValue, newValue); | |
893 | } | |
894 | template <typename T> | |
895 | inline T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue) | |
896 | { | |
897 | union { T * volatile * typed; void * volatile * voidp; } pointer; | |
898 | union { T *typed; void *voidp; } returnValue; | |
899 | pointer.typed = &_q_value; | |
900 | returnValue.voidp = QBasicAtomicPointer_fetchAndStoreOrdered(pointer.voidp, newValue); | |
901 | return returnValue.typed; | |
902 | } | |
903 | template <typename T> | |
904 | inline T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue) | |
905 | { | |
906 | return fetchAndStoreOrdered(newValue); | |
907 | } | |
908 | template <typename T> | |
909 | inline T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue) | |
910 | { | |
911 | return fetchAndStoreOrdered(newValue); | |
912 | } | |
913 | template <typename T> | |
914 | inline T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue) | |
915 | { | |
916 | return fetchAndStoreOrdered(newValue); | |
917 | } | |
918 | template <typename T> | |
919 | inline T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd) | |
920 | { | |
921 | union { T * volatile *typed; void * volatile *voidp; } pointer; | |
922 | union { T *typed; void *voidp; } returnValue; | |
923 | pointer.typed = &_q_value; | |
924 | returnValue.voidp = QBasicAtomicPointer_fetchAndAddOrdered(pointer.voidp, valueToAdd * sizeof(T)); | |
925 | return returnValue.typed; | |
926 | } | |
927 | template <typename T> | |
928 | inline T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd) | |
929 | { | |
930 | return fetchAndAddOrdered(valueToAdd); | |
931 | } | |
932 | template <typename T> | |
933 | inline T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd) | |
934 | { | |
935 | return fetchAndAddOrdered(valueToAdd); | |
936 | } | |
937 | template <typename T> | |
938 | inline T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd) | |
939 | { | |
940 | return fetchAndAddOrdered(valueToAdd); | |
941 | } | |
942 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
943 | class __attribute__((visibility("default"))) QAtomicInt : public QBasicAtomicInt | |
944 | { | |
945 | public: | |
946 | inline QAtomicInt(int value = 0) | |
947 | { | |
948 | _q_value = value; | |
949 | } | |
950 | inline QAtomicInt(const QAtomicInt &other) | |
951 | { | |
952 | _q_value = other._q_value; | |
953 | } | |
954 | inline QAtomicInt &operator=(int value) | |
955 | { | |
956 | (void) QBasicAtomicInt::operator=(value); | |
957 | return *this; | |
958 | } | |
959 | inline QAtomicInt &operator=(const QAtomicInt &other) | |
960 | { | |
961 | (void) QBasicAtomicInt::operator=(other); | |
962 | return *this; | |
963 | } | |
964 | }; | |
965 | template <typename T> | |
966 | class QAtomicPointer : public QBasicAtomicPointer<T> | |
967 | { | |
968 | public: | |
969 | inline QAtomicPointer(T *value = 0) | |
970 | { | |
971 | QBasicAtomicPointer<T>::_q_value = value; | |
972 | } | |
973 | inline QAtomicPointer(const QAtomicPointer<T> &other) | |
974 | { | |
975 | QBasicAtomicPointer<T>::_q_value = other._q_value; | |
976 | } | |
977 | inline QAtomicPointer<T> &operator=(T *value) | |
978 | { | |
979 | (void) QBasicAtomicPointer<T>::operator=(value); | |
980 | return *this; | |
981 | } | |
982 | inline QAtomicPointer<T> &operator=(const QAtomicPointer<T> &other) | |
983 | { | |
984 | (void) QBasicAtomicPointer<T>::operator=(other); | |
985 | return *this; | |
986 | } | |
987 | }; | |
988 | template <typename T> | |
989 | inline void qAtomicAssign(T *&d, T *x) | |
990 | { | |
991 | if (d == x) | |
992 | return; | |
993 | x->ref.ref(); | |
994 | if (!d->ref.deref()) | |
995 | delete d; | |
996 | d = x; | |
997 | } | |
998 | template <typename T> | |
999 | inline void qAtomicDetach(T *&d) | |
1000 | { | |
1001 | if (d->ref == 1) | |
1002 | return; | |
1003 | T *x = d; | |
1004 | d = new T(*d); | |
1005 | if (!x->ref.deref()) | |
1006 | delete x; | |
1007 | } | |
1008 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
1009 | class QString; | |
1010 | struct QLatin1Char | |
1011 | { | |
1012 | public: | |
1013 | inline explicit QLatin1Char(char c) : ch(c) {} | |
1014 | inline char toLatin1() const { return ch; } | |
1015 | inline ushort unicode() const { return ushort(uchar(ch)); } | |
1016 | private: | |
1017 | char ch; | |
1018 | }; | |
1019 | class __attribute__((visibility("default"))) QChar { | |
1020 | public: | |
1021 | QChar(); | |
1022 | __attribute__ ((__deprecated__)) QChar(char c); | |
1023 | __attribute__ ((__deprecated__)) QChar(uchar c); | |
1024 | QChar(QLatin1Char ch); | |
1025 | QChar(uchar c, uchar r); | |
1026 | inline QChar(ushort rc) : ucs(rc){} | |
1027 | QChar(short rc); | |
1028 | QChar(uint rc); | |
1029 | QChar(int rc); | |
1030 | enum SpecialCharacter { | |
1031 | Null = 0x0000, | |
1032 | Nbsp = 0x00a0, | |
1033 | ReplacementCharacter = 0xfffd, | |
1034 | ObjectReplacementCharacter = 0xfffc, | |
1035 | ByteOrderMark = 0xfeff, | |
1036 | ByteOrderSwapped = 0xfffe, | |
1037 | ParagraphSeparator = 0x2029, | |
1038 | LineSeparator = 0x2028 | |
1039 | }; | |
1040 | QChar(SpecialCharacter sc); | |
1041 | enum Category | |
1042 | { | |
1043 | NoCategory, | |
1044 | Mark_NonSpacing, | |
1045 | Mark_SpacingCombining, | |
1046 | Mark_Enclosing, | |
1047 | Number_DecimalDigit, | |
1048 | Number_Letter, | |
1049 | Number_Other, | |
1050 | Separator_Space, | |
1051 | Separator_Line, | |
1052 | Separator_Paragraph, | |
1053 | Other_Control, | |
1054 | Other_Format, | |
1055 | Other_Surrogate, | |
1056 | Other_PrivateUse, | |
1057 | Other_NotAssigned, | |
1058 | Letter_Uppercase, | |
1059 | Letter_Lowercase, | |
1060 | Letter_Titlecase, | |
1061 | Letter_Modifier, | |
1062 | Letter_Other, | |
1063 | Punctuation_Connector, | |
1064 | Punctuation_Dash, | |
1065 | Punctuation_Open, | |
1066 | Punctuation_Close, | |
1067 | Punctuation_InitialQuote, | |
1068 | Punctuation_FinalQuote, | |
1069 | Punctuation_Other, | |
1070 | Symbol_Math, | |
1071 | Symbol_Currency, | |
1072 | Symbol_Modifier, | |
1073 | Symbol_Other, | |
1074 | Punctuation_Dask = Punctuation_Dash | |
1075 | }; | |
1076 | enum Direction | |
1077 | { | |
1078 | DirL, DirR, DirEN, DirES, DirET, DirAN, DirCS, DirB, DirS, DirWS, DirON, | |
1079 | DirLRE, DirLRO, DirAL, DirRLE, DirRLO, DirPDF, DirNSM, DirBN | |
1080 | }; | |
1081 | enum Decomposition | |
1082 | { | |
1083 | NoDecomposition, | |
1084 | Canonical, | |
1085 | Font, | |
1086 | NoBreak, | |
1087 | Initial, | |
1088 | Medial, | |
1089 | Final, | |
1090 | Isolated, | |
1091 | Circle, | |
1092 | Super, | |
1093 | Sub, | |
1094 | Vertical, | |
1095 | Wide, | |
1096 | Narrow, | |
1097 | Small, | |
1098 | Square, | |
1099 | Compat, | |
1100 | Fraction | |
1101 | }; | |
1102 | enum Joining | |
1103 | { | |
1104 | OtherJoining, Dual, Right, Center | |
1105 | }; | |
1106 | enum CombiningClass | |
1107 | { | |
1108 | Combining_BelowLeftAttached = 200, | |
1109 | Combining_BelowAttached = 202, | |
1110 | Combining_BelowRightAttached = 204, | |
1111 | Combining_LeftAttached = 208, | |
1112 | Combining_RightAttached = 210, | |
1113 | Combining_AboveLeftAttached = 212, | |
1114 | Combining_AboveAttached = 214, | |
1115 | Combining_AboveRightAttached = 216, | |
1116 | Combining_BelowLeft = 218, | |
1117 | Combining_Below = 220, | |
1118 | Combining_BelowRight = 222, | |
1119 | Combining_Left = 224, | |
1120 | Combining_Right = 226, | |
1121 | Combining_AboveLeft = 228, | |
1122 | Combining_Above = 230, | |
1123 | Combining_AboveRight = 232, | |
1124 | Combining_DoubleBelow = 233, | |
1125 | Combining_DoubleAbove = 234, | |
1126 | Combining_IotaSubscript = 240 | |
1127 | }; | |
1128 | enum UnicodeVersion { | |
1129 | Unicode_Unassigned, | |
1130 | Unicode_1_1, | |
1131 | Unicode_2_0, | |
1132 | Unicode_2_1_2, | |
1133 | Unicode_3_0, | |
1134 | Unicode_3_1, | |
1135 | Unicode_3_2, | |
1136 | Unicode_4_0, | |
1137 | Unicode_4_1, | |
1138 | Unicode_5_0 | |
1139 | }; | |
1140 | Category category() const; | |
1141 | Direction direction() const; | |
1142 | Joining joining() const; | |
1143 | bool hasMirrored() const; | |
1144 | unsigned char combiningClass() const; | |
1145 | QChar mirroredChar() const; | |
1146 | QString decomposition() const; | |
1147 | Decomposition decompositionTag() const; | |
1148 | int digitValue() const; | |
1149 | QChar toLower() const; | |
1150 | QChar toUpper() const; | |
1151 | QChar toTitleCase() const; | |
1152 | QChar toCaseFolded() const; | |
1153 | UnicodeVersion unicodeVersion() const; | |
1154 | char toAscii() const; | |
1155 | inline char toLatin1() const; | |
1156 | inline ushort unicode() const { return ucs; } | |
1157 | inline ushort &unicode() { return const_cast<ushort&>(ucs); } | |
1158 | static QChar fromAscii(char c); | |
1159 | static QChar fromLatin1(char c); | |
1160 | inline bool isNull() const { return ucs == 0; } | |
1161 | bool isPrint() const; | |
1162 | bool isPunct() const; | |
1163 | bool isSpace() const; | |
1164 | bool isMark() const; | |
1165 | bool isLetter() const; | |
1166 | bool isNumber() const; | |
1167 | bool isLetterOrNumber() const; | |
1168 | bool isDigit() const; | |
1169 | bool isSymbol() const; | |
1170 | inline bool isLower() const { return category() == Letter_Lowercase; } | |
1171 | inline bool isUpper() const { return category() == Letter_Uppercase; } | |
1172 | inline bool isTitleCase() const { return category() == Letter_Titlecase; } | |
1173 | inline bool isHighSurrogate() const { | |
1174 | return ((ucs & 0xfc00) == 0xd800); | |
1175 | } | |
1176 | inline bool isLowSurrogate() const { | |
1177 | return ((ucs & 0xfc00) == 0xdc00); | |
1178 | } | |
1179 | inline uchar cell() const { return uchar(ucs & 0xff); } | |
1180 | inline uchar row() const { return uchar((ucs>>8)&0xff); } | |
1181 | inline void setCell(uchar cell); | |
1182 | inline void setRow(uchar row); | |
1183 | static inline uint surrogateToUcs4(ushort high, ushort low) { | |
1184 | return (uint(high)<<10) + low - 0x35fdc00; | |
1185 | } | |
1186 | static inline uint surrogateToUcs4(QChar high, QChar low) { | |
1187 | return (uint(high.ucs)<<10) + low.ucs - 0x35fdc00; | |
1188 | } | |
1189 | static inline ushort highSurrogate(uint ucs4) { | |
1190 | return (ucs4>>10) + 0xd7c0; | |
1191 | } | |
1192 | static inline ushort lowSurrogate(uint ucs4) { | |
1193 | return ucs4%0x400 + 0xdc00; | |
1194 | } | |
1195 | static Category category(uint ucs4); | |
1196 | static Category category(ushort ucs2); | |
1197 | static Direction direction(uint ucs4); | |
1198 | static Direction direction(ushort ucs2); | |
1199 | static Joining joining(uint ucs4); | |
1200 | static Joining joining(ushort ucs2); | |
1201 | static unsigned char combiningClass(uint ucs4); | |
1202 | static unsigned char combiningClass(ushort ucs2); | |
1203 | static uint mirroredChar(uint ucs4); | |
1204 | static ushort mirroredChar(ushort ucs2); | |
1205 | static Decomposition decompositionTag(uint ucs4); | |
1206 | static int digitValue(uint ucs4); | |
1207 | static int digitValue(ushort ucs2); | |
1208 | static uint toLower(uint ucs4); | |
1209 | static ushort toLower(ushort ucs2); | |
1210 | static uint toUpper(uint ucs4); | |
1211 | static ushort toUpper(ushort ucs2); | |
1212 | static uint toTitleCase(uint ucs4); | |
1213 | static ushort toTitleCase(ushort ucs2); | |
1214 | static uint toCaseFolded(uint ucs4); | |
1215 | static ushort toCaseFolded(ushort ucs2); | |
1216 | static UnicodeVersion unicodeVersion(uint ucs4); | |
1217 | static UnicodeVersion unicodeVersion(ushort ucs2); | |
1218 | static QString decomposition(uint ucs4); | |
1219 | private: | |
1220 | ushort ucs; | |
1221 | } | |
1222 | ; | |
1223 | template <> class QTypeInfo<QChar> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QChar)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QChar"; } }; | |
1224 | inline QChar::QChar() : ucs(0) {} | |
1225 | inline char QChar::toLatin1() const { return ucs > 0xff ? '\0' : char(ucs); } | |
1226 | inline QChar QChar::fromLatin1(char c) { return QChar(ushort(uchar(c))); } | |
1227 | inline QChar::QChar(uchar c, uchar r) : ucs((r << 8) | c){} | |
1228 | inline QChar::QChar(short rc) : ucs(ushort(rc)){} | |
1229 | inline QChar::QChar(uint rc) : ucs(ushort(rc & 0xffff)){} | |
1230 | inline QChar::QChar(int rc) : ucs(ushort(rc & 0xffff)){} | |
1231 | inline QChar::QChar(SpecialCharacter s) : ucs(ushort(s)) {} | |
1232 | inline QChar::QChar(QLatin1Char ch) : ucs(ch.unicode()) {} | |
1233 | inline void QChar::setCell(uchar acell) | |
1234 | { ucs = (ucs & 0xff00) + acell; } | |
1235 | inline void QChar::setRow(uchar arow) | |
1236 | { ucs = (ushort(arow)<<8) + (ucs&0xff); } | |
1237 | inline bool operator==(QChar c1, QChar c2) { return c1.unicode() == c2.unicode(); } | |
1238 | inline bool operator!=(QChar c1, QChar c2) { return c1.unicode() != c2.unicode(); } | |
1239 | inline bool operator<=(QChar c1, QChar c2) { return c1.unicode() <= c2.unicode(); } | |
1240 | inline bool operator>=(QChar c1, QChar c2) { return c1.unicode() >= c2.unicode(); } | |
1241 | inline bool operator<(QChar c1, QChar c2) { return c1.unicode() < c2.unicode(); } | |
1242 | inline bool operator>(QChar c1, QChar c2) { return c1.unicode() > c2.unicode(); } | |
1243 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QChar &); | |
1244 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QChar &); | |
1245 | namespace std { | |
1246 | struct bidirectional_iterator_tag; | |
1247 | struct random_access_iterator_tag; | |
1248 | } | |
1249 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
1250 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1251 | } | |
1252 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1253 | using ::ptrdiff_t; | |
1254 | using ::size_t; | |
1255 | } | |
1256 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1257 | struct input_iterator_tag {}; | |
1258 | struct output_iterator_tag {}; | |
1259 | struct forward_iterator_tag : public input_iterator_tag {}; | |
1260 | struct bidirectional_iterator_tag : public forward_iterator_tag {}; | |
1261 | struct random_access_iterator_tag : public bidirectional_iterator_tag {}; | |
1262 | template<typename _Category, typename _Tp, typename _Distance = ptrdiff_t, | |
1263 | typename _Pointer = _Tp*, typename _Reference = _Tp&> | |
1264 | struct iterator | |
1265 | { | |
1266 | typedef _Category iterator_category; | |
1267 | typedef _Tp value_type; | |
1268 | typedef _Distance difference_type; | |
1269 | typedef _Pointer pointer; | |
1270 | typedef _Reference reference; | |
1271 | }; | |
1272 | template<typename _Iterator> | |
1273 | struct iterator_traits | |
1274 | { | |
1275 | typedef typename _Iterator::iterator_category iterator_category; | |
1276 | typedef typename _Iterator::value_type value_type; | |
1277 | typedef typename _Iterator::difference_type difference_type; | |
1278 | typedef typename _Iterator::pointer pointer; | |
1279 | typedef typename _Iterator::reference reference; | |
1280 | }; | |
1281 | template<typename _Tp> | |
1282 | struct iterator_traits<_Tp*> | |
1283 | { | |
1284 | typedef random_access_iterator_tag iterator_category; | |
1285 | typedef _Tp value_type; | |
1286 | typedef ptrdiff_t difference_type; | |
1287 | typedef _Tp* pointer; | |
1288 | typedef _Tp& reference; | |
1289 | }; | |
1290 | template<typename _Tp> | |
1291 | struct iterator_traits<const _Tp*> | |
1292 | { | |
1293 | typedef random_access_iterator_tag iterator_category; | |
1294 | typedef _Tp value_type; | |
1295 | typedef ptrdiff_t difference_type; | |
1296 | typedef const _Tp* pointer; | |
1297 | typedef const _Tp& reference; | |
1298 | }; | |
1299 | template<typename _Iter> | |
1300 | inline typename iterator_traits<_Iter>::iterator_category | |
1301 | __iterator_category(const _Iter&) | |
1302 | { return typename iterator_traits<_Iter>::iterator_category(); } | |
1303 | } | |
1304 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1305 | template<typename _InputIterator> | |
1306 | inline typename iterator_traits<_InputIterator>::difference_type | |
1307 | __distance(_InputIterator __first, _InputIterator __last, | |
1308 | input_iterator_tag) | |
1309 | { | |
1310 | typename iterator_traits<_InputIterator>::difference_type __n = 0; | |
1311 | while (__first != __last) | |
1312 | { | |
1313 | ++__first; | |
1314 | ++__n; | |
1315 | } | |
1316 | return __n; | |
1317 | } | |
1318 | template<typename _RandomAccessIterator> | |
1319 | inline typename iterator_traits<_RandomAccessIterator>::difference_type | |
1320 | __distance(_RandomAccessIterator __first, _RandomAccessIterator __last, | |
1321 | random_access_iterator_tag) | |
1322 | { | |
1323 | return __last - __first; | |
1324 | } | |
1325 | template<typename _InputIterator> | |
1326 | inline typename iterator_traits<_InputIterator>::difference_type | |
1327 | distance(_InputIterator __first, _InputIterator __last) | |
1328 | { | |
1329 | return std::__distance(__first, __last, | |
1330 | std::__iterator_category(__first)); | |
1331 | } | |
1332 | template<typename _InputIterator, typename _Distance> | |
1333 | inline void | |
1334 | __advance(_InputIterator& __i, _Distance __n, input_iterator_tag) | |
1335 | { | |
1336 | while (__n--) | |
1337 | ++__i; | |
1338 | } | |
1339 | template<typename _BidirectionalIterator, typename _Distance> | |
1340 | inline void | |
1341 | __advance(_BidirectionalIterator& __i, _Distance __n, | |
1342 | bidirectional_iterator_tag) | |
1343 | { | |
1344 | if (__n > 0) | |
1345 | while (__n--) | |
1346 | ++__i; | |
1347 | else | |
1348 | while (__n++) | |
1349 | --__i; | |
1350 | } | |
1351 | template<typename _RandomAccessIterator, typename _Distance> | |
1352 | inline void | |
1353 | __advance(_RandomAccessIterator& __i, _Distance __n, | |
1354 | random_access_iterator_tag) | |
1355 | { | |
1356 | __i += __n; | |
1357 | } | |
1358 | template<typename _InputIterator, typename _Distance> | |
1359 | inline void | |
1360 | advance(_InputIterator& __i, _Distance __n) | |
1361 | { | |
1362 | typename iterator_traits<_InputIterator>::difference_type __d = __n; | |
1363 | std::__advance(__i, __d, std::__iterator_category(__i)); | |
1364 | } | |
1365 | } | |
1366 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
1367 | template<typename _Iterator, typename _Container> | |
1368 | class __normal_iterator; | |
1369 | } | |
1370 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1371 | struct __true_type { }; | |
1372 | struct __false_type { }; | |
1373 | template<bool> | |
1374 | struct __truth_type | |
1375 | { typedef __false_type __type; }; | |
1376 | template<> | |
1377 | struct __truth_type<true> | |
1378 | { typedef __true_type __type; }; | |
1379 | template<class _Sp, class _Tp> | |
1380 | struct __traitor | |
1381 | { | |
1382 | enum { __value = bool(_Sp::__value) || bool(_Tp::__value) }; | |
1383 | typedef typename __truth_type<__value>::__type __type; | |
1384 | }; | |
1385 | template<class _Sp, class _Tp> | |
1386 | struct __traitand | |
1387 | { | |
1388 | enum { __value = bool(_Sp::__value) && bool(_Tp::__value) }; | |
1389 | typedef typename __truth_type<__value>::__type __type; | |
1390 | }; | |
1391 | template<typename, typename> | |
1392 | struct __are_same | |
1393 | { | |
1394 | enum { __value = 0 }; | |
1395 | typedef __false_type __type; | |
1396 | }; | |
1397 | template<typename _Tp> | |
1398 | struct __are_same<_Tp, _Tp> | |
1399 | { | |
1400 | enum { __value = 1 }; | |
1401 | typedef __true_type __type; | |
1402 | }; | |
1403 | template<typename _Tp> | |
1404 | struct __is_void | |
1405 | { | |
1406 | enum { __value = 0 }; | |
1407 | typedef __false_type __type; | |
1408 | }; | |
1409 | template<> | |
1410 | struct __is_void<void> | |
1411 | { | |
1412 | enum { __value = 1 }; | |
1413 | typedef __true_type __type; | |
1414 | }; | |
1415 | template<typename _Tp> | |
1416 | struct __is_integer | |
1417 | { | |
1418 | enum { __value = 0 }; | |
1419 | typedef __false_type __type; | |
1420 | }; | |
1421 | template<> | |
1422 | struct __is_integer<bool> | |
1423 | { | |
1424 | enum { __value = 1 }; | |
1425 | typedef __true_type __type; | |
1426 | }; | |
1427 | template<> | |
1428 | struct __is_integer<char> | |
1429 | { | |
1430 | enum { __value = 1 }; | |
1431 | typedef __true_type __type; | |
1432 | }; | |
1433 | template<> | |
1434 | struct __is_integer<signed char> | |
1435 | { | |
1436 | enum { __value = 1 }; | |
1437 | typedef __true_type __type; | |
1438 | }; | |
1439 | template<> | |
1440 | struct __is_integer<unsigned char> | |
1441 | { | |
1442 | enum { __value = 1 }; | |
1443 | typedef __true_type __type; | |
1444 | }; | |
1445 | template<> | |
1446 | struct __is_integer<short> | |
1447 | { | |
1448 | enum { __value = 1 }; | |
1449 | typedef __true_type __type; | |
1450 | }; | |
1451 | template<> | |
1452 | struct __is_integer<unsigned short> | |
1453 | { | |
1454 | enum { __value = 1 }; | |
1455 | typedef __true_type __type; | |
1456 | }; | |
1457 | template<> | |
1458 | struct __is_integer<int> | |
1459 | { | |
1460 | enum { __value = 1 }; | |
1461 | typedef __true_type __type; | |
1462 | }; | |
1463 | template<> | |
1464 | struct __is_integer<unsigned int> | |
1465 | { | |
1466 | enum { __value = 1 }; | |
1467 | typedef __true_type __type; | |
1468 | }; | |
1469 | template<> | |
1470 | struct __is_integer<long> | |
1471 | { | |
1472 | enum { __value = 1 }; | |
1473 | typedef __true_type __type; | |
1474 | }; | |
1475 | template<> | |
1476 | struct __is_integer<unsigned long> | |
1477 | { | |
1478 | enum { __value = 1 }; | |
1479 | typedef __true_type __type; | |
1480 | }; | |
1481 | template<> | |
1482 | struct __is_integer<long long> | |
1483 | { | |
1484 | enum { __value = 1 }; | |
1485 | typedef __true_type __type; | |
1486 | }; | |
1487 | template<> | |
1488 | struct __is_integer<unsigned long long> | |
1489 | { | |
1490 | enum { __value = 1 }; | |
1491 | typedef __true_type __type; | |
1492 | }; | |
1493 | template<typename _Tp> | |
1494 | struct __is_floating | |
1495 | { | |
1496 | enum { __value = 0 }; | |
1497 | typedef __false_type __type; | |
1498 | }; | |
1499 | template<> | |
1500 | struct __is_floating<float> | |
1501 | { | |
1502 | enum { __value = 1 }; | |
1503 | typedef __true_type __type; | |
1504 | }; | |
1505 | template<> | |
1506 | struct __is_floating<double> | |
1507 | { | |
1508 | enum { __value = 1 }; | |
1509 | typedef __true_type __type; | |
1510 | }; | |
1511 | template<> | |
1512 | struct __is_floating<long double> | |
1513 | { | |
1514 | enum { __value = 1 }; | |
1515 | typedef __true_type __type; | |
1516 | }; | |
1517 | template<typename _Tp> | |
1518 | struct __is_pointer | |
1519 | { | |
1520 | enum { __value = 0 }; | |
1521 | typedef __false_type __type; | |
1522 | }; | |
1523 | template<typename _Tp> | |
1524 | struct __is_pointer<_Tp*> | |
1525 | { | |
1526 | enum { __value = 1 }; | |
1527 | typedef __true_type __type; | |
1528 | }; | |
1529 | template<typename _Tp> | |
1530 | struct __is_normal_iterator | |
1531 | { | |
1532 | enum { __value = 0 }; | |
1533 | typedef __false_type __type; | |
1534 | }; | |
1535 | template<typename _Iterator, typename _Container> | |
1536 | struct __is_normal_iterator< __gnu_cxx::__normal_iterator<_Iterator, | |
1537 | _Container> > | |
1538 | { | |
1539 | enum { __value = 1 }; | |
1540 | typedef __true_type __type; | |
1541 | }; | |
1542 | template<typename _Tp> | |
1543 | struct __is_arithmetic | |
1544 | : public __traitor<__is_integer<_Tp>, __is_floating<_Tp> > | |
1545 | { }; | |
1546 | template<typename _Tp> | |
1547 | struct __is_fundamental | |
1548 | : public __traitor<__is_void<_Tp>, __is_arithmetic<_Tp> > | |
1549 | { }; | |
1550 | template<typename _Tp> | |
1551 | struct __is_scalar | |
1552 | : public __traitor<__is_arithmetic<_Tp>, __is_pointer<_Tp> > | |
1553 | { }; | |
1554 | template<typename _Tp> | |
1555 | struct __is_char | |
1556 | { | |
1557 | enum { __value = 0 }; | |
1558 | typedef __false_type __type; | |
1559 | }; | |
1560 | template<> | |
1561 | struct __is_char<char> | |
1562 | { | |
1563 | enum { __value = 1 }; | |
1564 | typedef __true_type __type; | |
1565 | }; | |
1566 | template<typename _Tp> | |
1567 | struct __is_byte | |
1568 | { | |
1569 | enum { __value = 0 }; | |
1570 | typedef __false_type __type; | |
1571 | }; | |
1572 | template<> | |
1573 | struct __is_byte<char> | |
1574 | { | |
1575 | enum { __value = 1 }; | |
1576 | typedef __true_type __type; | |
1577 | }; | |
1578 | template<> | |
1579 | struct __is_byte<signed char> | |
1580 | { | |
1581 | enum { __value = 1 }; | |
1582 | typedef __true_type __type; | |
1583 | }; | |
1584 | template<> | |
1585 | struct __is_byte<unsigned char> | |
1586 | { | |
1587 | enum { __value = 1 }; | |
1588 | typedef __true_type __type; | |
1589 | }; | |
1590 | template<typename _Tp> | |
1591 | struct __is_move_iterator | |
1592 | { | |
1593 | enum { __value = 0 }; | |
1594 | typedef __false_type __type; | |
1595 | }; | |
1596 | } | |
1597 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
1598 | template<bool, typename> | |
1599 | struct __enable_if | |
1600 | { }; | |
1601 | template<typename _Tp> | |
1602 | struct __enable_if<true, _Tp> | |
1603 | { typedef _Tp __type; }; | |
1604 | template<bool _Cond, typename _Iftrue, typename _Iffalse> | |
1605 | struct __conditional_type | |
1606 | { typedef _Iftrue __type; }; | |
1607 | template<typename _Iftrue, typename _Iffalse> | |
1608 | struct __conditional_type<false, _Iftrue, _Iffalse> | |
1609 | { typedef _Iffalse __type; }; | |
1610 | template<typename _Tp> | |
1611 | struct __add_unsigned | |
1612 | { | |
1613 | private: | |
1614 | typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type; | |
1615 | public: | |
1616 | typedef typename __if_type::__type __type; | |
1617 | }; | |
1618 | template<> | |
1619 | struct __add_unsigned<char> | |
1620 | { typedef unsigned char __type; }; | |
1621 | template<> | |
1622 | struct __add_unsigned<signed char> | |
1623 | { typedef unsigned char __type; }; | |
1624 | template<> | |
1625 | struct __add_unsigned<short> | |
1626 | { typedef unsigned short __type; }; | |
1627 | template<> | |
1628 | struct __add_unsigned<int> | |
1629 | { typedef unsigned int __type; }; | |
1630 | template<> | |
1631 | struct __add_unsigned<long> | |
1632 | { typedef unsigned long __type; }; | |
1633 | template<> | |
1634 | struct __add_unsigned<long long> | |
1635 | { typedef unsigned long long __type; }; | |
1636 | template<> | |
1637 | struct __add_unsigned<bool>; | |
1638 | template<> | |
1639 | struct __add_unsigned<wchar_t>; | |
1640 | template<typename _Tp> | |
1641 | struct __remove_unsigned | |
1642 | { | |
1643 | private: | |
1644 | typedef __enable_if<std::__is_integer<_Tp>::__value, _Tp> __if_type; | |
1645 | public: | |
1646 | typedef typename __if_type::__type __type; | |
1647 | }; | |
1648 | template<> | |
1649 | struct __remove_unsigned<char> | |
1650 | { typedef signed char __type; }; | |
1651 | template<> | |
1652 | struct __remove_unsigned<unsigned char> | |
1653 | { typedef signed char __type; }; | |
1654 | template<> | |
1655 | struct __remove_unsigned<unsigned short> | |
1656 | { typedef short __type; }; | |
1657 | template<> | |
1658 | struct __remove_unsigned<unsigned int> | |
1659 | { typedef int __type; }; | |
1660 | template<> | |
1661 | struct __remove_unsigned<unsigned long> | |
1662 | { typedef long __type; }; | |
1663 | template<> | |
1664 | struct __remove_unsigned<unsigned long long> | |
1665 | { typedef long long __type; }; | |
1666 | template<> | |
1667 | struct __remove_unsigned<bool>; | |
1668 | template<> | |
1669 | struct __remove_unsigned<wchar_t>; | |
1670 | template<typename _Type> | |
1671 | inline bool | |
1672 | __is_null_pointer(_Type* __ptr) | |
1673 | { return __ptr == 0; } | |
1674 | template<typename _Type> | |
1675 | inline bool | |
1676 | __is_null_pointer(_Type) | |
1677 | { return false; } | |
1678 | template<typename _Tp, bool = std::__is_integer<_Tp>::__value> | |
1679 | struct __promote | |
1680 | { typedef double __type; }; | |
1681 | template<typename _Tp> | |
1682 | struct __promote<_Tp, false> | |
1683 | { typedef _Tp __type; }; | |
1684 | template<typename _Tp, typename _Up> | |
1685 | struct __promote_2 | |
1686 | { | |
1687 | private: | |
1688 | typedef typename __promote<_Tp>::__type __type1; | |
1689 | typedef typename __promote<_Up>::__type __type2; | |
1690 | public: | |
1691 | typedef __typeof__(__type1() + __type2()) __type; | |
1692 | }; | |
1693 | template<typename _Tp, typename _Up, typename _Vp> | |
1694 | struct __promote_3 | |
1695 | { | |
1696 | private: | |
1697 | typedef typename __promote<_Tp>::__type __type1; | |
1698 | typedef typename __promote<_Up>::__type __type2; | |
1699 | typedef typename __promote<_Vp>::__type __type3; | |
1700 | public: | |
1701 | typedef __typeof__(__type1() + __type2() + __type3()) __type; | |
1702 | }; | |
1703 | template<typename _Tp, typename _Up, typename _Vp, typename _Wp> | |
1704 | struct __promote_4 | |
1705 | { | |
1706 | private: | |
1707 | typedef typename __promote<_Tp>::__type __type1; | |
1708 | typedef typename __promote<_Up>::__type __type2; | |
1709 | typedef typename __promote<_Vp>::__type __type3; | |
1710 | typedef typename __promote<_Wp>::__type __type4; | |
1711 | public: | |
1712 | typedef __typeof__(__type1() + __type2() + __type3() + __type4()) __type; | |
1713 | }; | |
1714 | } | |
1715 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1716 | template<typename _Tp> | |
1717 | inline void | |
1718 | swap(_Tp& __a, _Tp& __b) | |
1719 | { | |
1720 | _Tp __tmp = (__a); | |
1721 | __a = (__b); | |
1722 | __b = (__tmp); | |
1723 | } | |
1724 | } | |
1725 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
1726 | template<typename _Iterator> | |
1727 | class reverse_iterator | |
1728 | : public iterator<typename iterator_traits<_Iterator>::iterator_category, | |
1729 | typename iterator_traits<_Iterator>::value_type, | |
1730 | typename iterator_traits<_Iterator>::difference_type, | |
1731 | typename iterator_traits<_Iterator>::pointer, | |
1732 | typename iterator_traits<_Iterator>::reference> | |
1733 | { | |
1734 | protected: | |
1735 | _Iterator current; | |
1736 | public: | |
1737 | typedef _Iterator iterator_type; | |
1738 | typedef typename iterator_traits<_Iterator>::difference_type | |
1739 | difference_type; | |
1740 | typedef typename iterator_traits<_Iterator>::reference reference; | |
1741 | typedef typename iterator_traits<_Iterator>::pointer pointer; | |
1742 | public: | |
1743 | reverse_iterator() : current() { } | |
1744 | explicit | |
1745 | reverse_iterator(iterator_type __x) : current(__x) { } | |
1746 | reverse_iterator(const reverse_iterator& __x) | |
1747 | : current(__x.current) { } | |
1748 | template<typename _Iter> | |
1749 | reverse_iterator(const reverse_iterator<_Iter>& __x) | |
1750 | : current(__x.base()) { } | |
1751 | iterator_type | |
1752 | base() const | |
1753 | { return current; } | |
1754 | reference | |
1755 | operator*() const | |
1756 | { | |
1757 | _Iterator __tmp = current; | |
1758 | return *--__tmp; | |
1759 | } | |
1760 | pointer | |
1761 | operator->() const | |
1762 | { return &(operator*()); } | |
1763 | reverse_iterator& | |
1764 | operator++() | |
1765 | { | |
1766 | --current; | |
1767 | return *this; | |
1768 | } | |
1769 | reverse_iterator | |
1770 | operator++(int) | |
1771 | { | |
1772 | reverse_iterator __tmp = *this; | |
1773 | --current; | |
1774 | return __tmp; | |
1775 | } | |
1776 | reverse_iterator& | |
1777 | operator--() | |
1778 | { | |
1779 | ++current; | |
1780 | return *this; | |
1781 | } | |
1782 | reverse_iterator | |
1783 | operator--(int) | |
1784 | { | |
1785 | reverse_iterator __tmp = *this; | |
1786 | ++current; | |
1787 | return __tmp; | |
1788 | } | |
1789 | reverse_iterator | |
1790 | operator+(difference_type __n) const | |
1791 | { return reverse_iterator(current - __n); } | |
1792 | reverse_iterator& | |
1793 | operator+=(difference_type __n) | |
1794 | { | |
1795 | current -= __n; | |
1796 | return *this; | |
1797 | } | |
1798 | reverse_iterator | |
1799 | operator-(difference_type __n) const | |
1800 | { return reverse_iterator(current + __n); } | |
1801 | reverse_iterator& | |
1802 | operator-=(difference_type __n) | |
1803 | { | |
1804 | current += __n; | |
1805 | return *this; | |
1806 | } | |
1807 | reference | |
1808 | operator[](difference_type __n) const | |
1809 | { return *(*this + __n); } | |
1810 | }; | |
1811 | template<typename _Iterator> | |
1812 | inline bool | |
1813 | operator==(const reverse_iterator<_Iterator>& __x, | |
1814 | const reverse_iterator<_Iterator>& __y) | |
1815 | { return __x.base() == __y.base(); } | |
1816 | template<typename _Iterator> | |
1817 | inline bool | |
1818 | operator<(const reverse_iterator<_Iterator>& __x, | |
1819 | const reverse_iterator<_Iterator>& __y) | |
1820 | { return __y.base() < __x.base(); } | |
1821 | template<typename _Iterator> | |
1822 | inline bool | |
1823 | operator!=(const reverse_iterator<_Iterator>& __x, | |
1824 | const reverse_iterator<_Iterator>& __y) | |
1825 | { return !(__x == __y); } | |
1826 | template<typename _Iterator> | |
1827 | inline bool | |
1828 | operator>(const reverse_iterator<_Iterator>& __x, | |
1829 | const reverse_iterator<_Iterator>& __y) | |
1830 | { return __y < __x; } | |
1831 | template<typename _Iterator> | |
1832 | inline bool | |
1833 | operator<=(const reverse_iterator<_Iterator>& __x, | |
1834 | const reverse_iterator<_Iterator>& __y) | |
1835 | { return !(__y < __x); } | |
1836 | template<typename _Iterator> | |
1837 | inline bool | |
1838 | operator>=(const reverse_iterator<_Iterator>& __x, | |
1839 | const reverse_iterator<_Iterator>& __y) | |
1840 | { return !(__x < __y); } | |
1841 | template<typename _Iterator> | |
1842 | inline typename reverse_iterator<_Iterator>::difference_type | |
1843 | operator-(const reverse_iterator<_Iterator>& __x, | |
1844 | const reverse_iterator<_Iterator>& __y) | |
1845 | { return __y.base() - __x.base(); } | |
1846 | template<typename _Iterator> | |
1847 | inline reverse_iterator<_Iterator> | |
1848 | operator+(typename reverse_iterator<_Iterator>::difference_type __n, | |
1849 | const reverse_iterator<_Iterator>& __x) | |
1850 | { return reverse_iterator<_Iterator>(__x.base() - __n); } | |
1851 | template<typename _IteratorL, typename _IteratorR> | |
1852 | inline bool | |
1853 | operator==(const reverse_iterator<_IteratorL>& __x, | |
1854 | const reverse_iterator<_IteratorR>& __y) | |
1855 | { return __x.base() == __y.base(); } | |
1856 | template<typename _IteratorL, typename _IteratorR> | |
1857 | inline bool | |
1858 | operator<(const reverse_iterator<_IteratorL>& __x, | |
1859 | const reverse_iterator<_IteratorR>& __y) | |
1860 | { return __y.base() < __x.base(); } | |
1861 | template<typename _IteratorL, typename _IteratorR> | |
1862 | inline bool | |
1863 | operator!=(const reverse_iterator<_IteratorL>& __x, | |
1864 | const reverse_iterator<_IteratorR>& __y) | |
1865 | { return !(__x == __y); } | |
1866 | template<typename _IteratorL, typename _IteratorR> | |
1867 | inline bool | |
1868 | operator>(const reverse_iterator<_IteratorL>& __x, | |
1869 | const reverse_iterator<_IteratorR>& __y) | |
1870 | { return __y < __x; } | |
1871 | template<typename _IteratorL, typename _IteratorR> | |
1872 | inline bool | |
1873 | operator<=(const reverse_iterator<_IteratorL>& __x, | |
1874 | const reverse_iterator<_IteratorR>& __y) | |
1875 | { return !(__y < __x); } | |
1876 | template<typename _IteratorL, typename _IteratorR> | |
1877 | inline bool | |
1878 | operator>=(const reverse_iterator<_IteratorL>& __x, | |
1879 | const reverse_iterator<_IteratorR>& __y) | |
1880 | { return !(__x < __y); } | |
1881 | template<typename _IteratorL, typename _IteratorR> | |
1882 | inline typename reverse_iterator<_IteratorL>::difference_type | |
1883 | operator-(const reverse_iterator<_IteratorL>& __x, | |
1884 | const reverse_iterator<_IteratorR>& __y) | |
1885 | { return __y.base() - __x.base(); } | |
1886 | template<typename _Container> | |
1887 | class back_insert_iterator | |
1888 | : public iterator<output_iterator_tag, void, void, void, void> | |
1889 | { | |
1890 | protected: | |
1891 | _Container* container; | |
1892 | public: | |
1893 | typedef _Container container_type; | |
1894 | explicit | |
1895 | back_insert_iterator(_Container& __x) : container(&__x) { } | |
1896 | back_insert_iterator& | |
1897 | operator=(typename _Container::const_reference __value) | |
1898 | { | |
1899 | container->push_back(__value); | |
1900 | return *this; | |
1901 | } | |
1902 | back_insert_iterator& | |
1903 | operator*() | |
1904 | { return *this; } | |
1905 | back_insert_iterator& | |
1906 | operator++() | |
1907 | { return *this; } | |
1908 | back_insert_iterator | |
1909 | operator++(int) | |
1910 | { return *this; } | |
1911 | }; | |
1912 | template<typename _Container> | |
1913 | inline back_insert_iterator<_Container> | |
1914 | back_inserter(_Container& __x) | |
1915 | { return back_insert_iterator<_Container>(__x); } | |
1916 | template<typename _Container> | |
1917 | class front_insert_iterator | |
1918 | : public iterator<output_iterator_tag, void, void, void, void> | |
1919 | { | |
1920 | protected: | |
1921 | _Container* container; | |
1922 | public: | |
1923 | typedef _Container container_type; | |
1924 | explicit front_insert_iterator(_Container& __x) : container(&__x) { } | |
1925 | front_insert_iterator& | |
1926 | operator=(typename _Container::const_reference __value) | |
1927 | { | |
1928 | container->push_front(__value); | |
1929 | return *this; | |
1930 | } | |
1931 | front_insert_iterator& | |
1932 | operator*() | |
1933 | { return *this; } | |
1934 | front_insert_iterator& | |
1935 | operator++() | |
1936 | { return *this; } | |
1937 | front_insert_iterator | |
1938 | operator++(int) | |
1939 | { return *this; } | |
1940 | }; | |
1941 | template<typename _Container> | |
1942 | inline front_insert_iterator<_Container> | |
1943 | front_inserter(_Container& __x) | |
1944 | { return front_insert_iterator<_Container>(__x); } | |
1945 | template<typename _Container> | |
1946 | class insert_iterator | |
1947 | : public iterator<output_iterator_tag, void, void, void, void> | |
1948 | { | |
1949 | protected: | |
1950 | _Container* container; | |
1951 | typename _Container::iterator iter; | |
1952 | public: | |
1953 | typedef _Container container_type; | |
1954 | insert_iterator(_Container& __x, typename _Container::iterator __i) | |
1955 | : container(&__x), iter(__i) {} | |
1956 | insert_iterator& | |
1957 | operator=(typename _Container::const_reference __value) | |
1958 | { | |
1959 | iter = container->insert(iter, __value); | |
1960 | ++iter; | |
1961 | return *this; | |
1962 | } | |
1963 | insert_iterator& | |
1964 | operator*() | |
1965 | { return *this; } | |
1966 | insert_iterator& | |
1967 | operator++() | |
1968 | { return *this; } | |
1969 | insert_iterator& | |
1970 | operator++(int) | |
1971 | { return *this; } | |
1972 | }; | |
1973 | template<typename _Container, typename _Iterator> | |
1974 | inline insert_iterator<_Container> | |
1975 | inserter(_Container& __x, _Iterator __i) | |
1976 | { | |
1977 | return insert_iterator<_Container>(__x, | |
1978 | typename _Container::iterator(__i)); | |
1979 | } | |
1980 | } | |
1981 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
1982 | using std::iterator_traits; | |
1983 | using std::iterator; | |
1984 | template<typename _Iterator, typename _Container> | |
1985 | class __normal_iterator | |
1986 | { | |
1987 | protected: | |
1988 | _Iterator _M_current; | |
1989 | public: | |
1990 | typedef _Iterator iterator_type; | |
1991 | typedef typename iterator_traits<_Iterator>::iterator_category | |
1992 | iterator_category; | |
1993 | typedef typename iterator_traits<_Iterator>::value_type value_type; | |
1994 | typedef typename iterator_traits<_Iterator>::difference_type | |
1995 | difference_type; | |
1996 | typedef typename iterator_traits<_Iterator>::reference reference; | |
1997 | typedef typename iterator_traits<_Iterator>::pointer pointer; | |
1998 | __normal_iterator() : _M_current(_Iterator()) { } | |
1999 | explicit | |
2000 | __normal_iterator(const _Iterator& __i) : _M_current(__i) { } | |
2001 | template<typename _Iter> | |
2002 | __normal_iterator(const __normal_iterator<_Iter, | |
2003 | typename __enable_if< | |
2004 | (std::__are_same<_Iter, typename _Container::pointer>::__value), | |
2005 | _Container>::__type>& __i) | |
2006 | : _M_current(__i.base()) { } | |
2007 | reference | |
2008 | operator*() const | |
2009 | { return *_M_current; } | |
2010 | pointer | |
2011 | operator->() const | |
2012 | { return _M_current; } | |
2013 | __normal_iterator& | |
2014 | operator++() | |
2015 | { | |
2016 | ++_M_current; | |
2017 | return *this; | |
2018 | } | |
2019 | __normal_iterator | |
2020 | operator++(int) | |
2021 | { return __normal_iterator(_M_current++); } | |
2022 | __normal_iterator& | |
2023 | operator--() | |
2024 | { | |
2025 | --_M_current; | |
2026 | return *this; | |
2027 | } | |
2028 | __normal_iterator | |
2029 | operator--(int) | |
2030 | { return __normal_iterator(_M_current--); } | |
2031 | reference | |
2032 | operator[](const difference_type& __n) const | |
2033 | { return _M_current[__n]; } | |
2034 | __normal_iterator& | |
2035 | operator+=(const difference_type& __n) | |
2036 | { _M_current += __n; return *this; } | |
2037 | __normal_iterator | |
2038 | operator+(const difference_type& __n) const | |
2039 | { return __normal_iterator(_M_current + __n); } | |
2040 | __normal_iterator& | |
2041 | operator-=(const difference_type& __n) | |
2042 | { _M_current -= __n; return *this; } | |
2043 | __normal_iterator | |
2044 | operator-(const difference_type& __n) const | |
2045 | { return __normal_iterator(_M_current - __n); } | |
2046 | const _Iterator& | |
2047 | base() const | |
2048 | { return _M_current; } | |
2049 | }; | |
2050 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2051 | inline bool | |
2052 | operator==(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2053 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2054 | { return __lhs.base() == __rhs.base(); } | |
2055 | template<typename _Iterator, typename _Container> | |
2056 | inline bool | |
2057 | operator==(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2058 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2059 | { return __lhs.base() == __rhs.base(); } | |
2060 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2061 | inline bool | |
2062 | operator!=(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2063 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2064 | { return __lhs.base() != __rhs.base(); } | |
2065 | template<typename _Iterator, typename _Container> | |
2066 | inline bool | |
2067 | operator!=(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2068 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2069 | { return __lhs.base() != __rhs.base(); } | |
2070 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2071 | inline bool | |
2072 | operator<(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2073 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2074 | { return __lhs.base() < __rhs.base(); } | |
2075 | template<typename _Iterator, typename _Container> | |
2076 | inline bool | |
2077 | operator<(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2078 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2079 | { return __lhs.base() < __rhs.base(); } | |
2080 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2081 | inline bool | |
2082 | operator>(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2083 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2084 | { return __lhs.base() > __rhs.base(); } | |
2085 | template<typename _Iterator, typename _Container> | |
2086 | inline bool | |
2087 | operator>(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2088 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2089 | { return __lhs.base() > __rhs.base(); } | |
2090 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2091 | inline bool | |
2092 | operator<=(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2093 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2094 | { return __lhs.base() <= __rhs.base(); } | |
2095 | template<typename _Iterator, typename _Container> | |
2096 | inline bool | |
2097 | operator<=(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2098 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2099 | { return __lhs.base() <= __rhs.base(); } | |
2100 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2101 | inline bool | |
2102 | operator>=(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2103 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2104 | { return __lhs.base() >= __rhs.base(); } | |
2105 | template<typename _Iterator, typename _Container> | |
2106 | inline bool | |
2107 | operator>=(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2108 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2109 | { return __lhs.base() >= __rhs.base(); } | |
2110 | template<typename _IteratorL, typename _IteratorR, typename _Container> | |
2111 | inline typename __normal_iterator<_IteratorL, _Container>::difference_type | |
2112 | operator-(const __normal_iterator<_IteratorL, _Container>& __lhs, | |
2113 | const __normal_iterator<_IteratorR, _Container>& __rhs) | |
2114 | { return __lhs.base() - __rhs.base(); } | |
2115 | template<typename _Iterator, typename _Container> | |
2116 | inline typename __normal_iterator<_Iterator, _Container>::difference_type | |
2117 | operator-(const __normal_iterator<_Iterator, _Container>& __lhs, | |
2118 | const __normal_iterator<_Iterator, _Container>& __rhs) | |
2119 | { return __lhs.base() - __rhs.base(); } | |
2120 | template<typename _Iterator, typename _Container> | |
2121 | inline __normal_iterator<_Iterator, _Container> | |
2122 | operator+(typename __normal_iterator<_Iterator, _Container>::difference_type | |
2123 | __n, const __normal_iterator<_Iterator, _Container>& __i) | |
2124 | { return __normal_iterator<_Iterator, _Container>(__i.base() + __n); } | |
2125 | } | |
2126 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2127 | template<typename _Alloc> | |
2128 | class allocator; | |
2129 | template<class _CharT> | |
2130 | struct char_traits; | |
2131 | template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
2132 | typename _Alloc = allocator<_CharT> > | |
2133 | class basic_string; | |
2134 | template<> struct char_traits<char>; | |
2135 | typedef basic_string<char> string; | |
2136 | } | |
2137 | extern "C" | |
2138 | { | |
2139 | typedef struct | |
2140 | { | |
2141 | int __fill[6]; | |
2142 | } mbstate_t; | |
2143 | } | |
2144 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2145 | using ::mbstate_t; | |
2146 | } | |
2147 | typedef signed char int8_t; | |
2148 | typedef short int int16_t; | |
2149 | typedef int int32_t; | |
2150 | __extension__ | |
2151 | typedef long long int int64_t; | |
2152 | typedef unsigned char uint8_t; | |
2153 | typedef unsigned short int uint16_t; | |
2154 | typedef unsigned int uint32_t; | |
2155 | __extension__ | |
2156 | typedef unsigned long long int uint64_t; | |
2157 | typedef signed char int_least8_t; | |
2158 | typedef short int int_least16_t; | |
2159 | typedef int int_least32_t; | |
2160 | __extension__ | |
2161 | typedef long long int int_least64_t; | |
2162 | typedef unsigned char uint_least8_t; | |
2163 | typedef unsigned short int uint_least16_t; | |
2164 | typedef unsigned int uint_least32_t; | |
2165 | __extension__ | |
2166 | typedef unsigned long long int uint_least64_t; | |
2167 | typedef signed char int_fast8_t; | |
2168 | typedef int int_fast16_t; | |
2169 | typedef int int_fast32_t; | |
2170 | __extension__ | |
2171 | typedef long long int int_fast64_t; | |
2172 | typedef unsigned char uint_fast8_t; | |
2173 | typedef unsigned int uint_fast16_t; | |
2174 | typedef unsigned int uint_fast32_t; | |
2175 | __extension__ | |
2176 | typedef unsigned long long int uint_fast64_t; | |
2177 | typedef int intptr_t; | |
2178 | typedef unsigned int uintptr_t; | |
2179 | __extension__ | |
2180 | typedef long long int intmax_t; | |
2181 | __extension__ | |
2182 | typedef unsigned long long int uintmax_t; | |
2183 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2184 | typedef int64_t streamoff; | |
2185 | typedef ptrdiff_t streamsize; | |
2186 | template<typename _StateT> | |
2187 | class fpos | |
2188 | { | |
2189 | private: | |
2190 | streamoff _M_off; | |
2191 | _StateT _M_state; | |
2192 | public: | |
2193 | fpos() | |
2194 | : _M_off(0), _M_state() { } | |
2195 | fpos(streamoff __off) | |
2196 | : _M_off(__off), _M_state() { } | |
2197 | operator streamoff() const { return _M_off; } | |
2198 | void | |
2199 | state(_StateT __st) | |
2200 | { _M_state = __st; } | |
2201 | _StateT | |
2202 | state() const | |
2203 | { return _M_state; } | |
2204 | fpos& | |
2205 | operator+=(streamoff __off) | |
2206 | { | |
2207 | _M_off += __off; | |
2208 | return *this; | |
2209 | } | |
2210 | fpos& | |
2211 | operator-=(streamoff __off) | |
2212 | { | |
2213 | _M_off -= __off; | |
2214 | return *this; | |
2215 | } | |
2216 | fpos | |
2217 | operator+(streamoff __off) const | |
2218 | { | |
2219 | fpos __pos(*this); | |
2220 | __pos += __off; | |
2221 | return __pos; | |
2222 | } | |
2223 | fpos | |
2224 | operator-(streamoff __off) const | |
2225 | { | |
2226 | fpos __pos(*this); | |
2227 | __pos -= __off; | |
2228 | return __pos; | |
2229 | } | |
2230 | streamoff | |
2231 | operator-(const fpos& __other) const | |
2232 | { return _M_off - __other._M_off; } | |
2233 | }; | |
2234 | template<typename _StateT> | |
2235 | inline bool | |
2236 | operator==(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) | |
2237 | { return streamoff(__lhs) == streamoff(__rhs); } | |
2238 | template<typename _StateT> | |
2239 | inline bool | |
2240 | operator!=(const fpos<_StateT>& __lhs, const fpos<_StateT>& __rhs) | |
2241 | { return streamoff(__lhs) != streamoff(__rhs); } | |
2242 | typedef fpos<mbstate_t> streampos; | |
2243 | typedef fpos<mbstate_t> wstreampos; | |
2244 | } | |
2245 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2246 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2247 | class basic_ios; | |
2248 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2249 | class basic_streambuf; | |
2250 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2251 | class basic_istream; | |
2252 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2253 | class basic_ostream; | |
2254 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2255 | class basic_iostream; | |
2256 | template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
2257 | typename _Alloc = allocator<_CharT> > | |
2258 | class basic_stringbuf; | |
2259 | template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
2260 | typename _Alloc = allocator<_CharT> > | |
2261 | class basic_istringstream; | |
2262 | template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
2263 | typename _Alloc = allocator<_CharT> > | |
2264 | class basic_ostringstream; | |
2265 | template<typename _CharT, typename _Traits = char_traits<_CharT>, | |
2266 | typename _Alloc = allocator<_CharT> > | |
2267 | class basic_stringstream; | |
2268 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2269 | class basic_filebuf; | |
2270 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2271 | class basic_ifstream; | |
2272 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2273 | class basic_ofstream; | |
2274 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2275 | class basic_fstream; | |
2276 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2277 | class istreambuf_iterator; | |
2278 | template<typename _CharT, typename _Traits = char_traits<_CharT> > | |
2279 | class ostreambuf_iterator; | |
2280 | class ios_base; | |
2281 | typedef basic_ios<char> ios; | |
2282 | typedef basic_streambuf<char> streambuf; | |
2283 | typedef basic_istream<char> istream; | |
2284 | typedef basic_ostream<char> ostream; | |
2285 | typedef basic_iostream<char> iostream; | |
2286 | typedef basic_stringbuf<char> stringbuf; | |
2287 | typedef basic_istringstream<char> istringstream; | |
2288 | typedef basic_ostringstream<char> ostringstream; | |
2289 | typedef basic_stringstream<char> stringstream; | |
2290 | typedef basic_filebuf<char> filebuf; | |
2291 | typedef basic_ifstream<char> ifstream; | |
2292 | typedef basic_ofstream<char> ofstream; | |
2293 | typedef basic_fstream<char> fstream; | |
2294 | } | |
2295 | extern "C++" { | |
2296 | namespace std | |
2297 | { | |
2298 | class exception | |
2299 | { | |
2300 | public: | |
2301 | exception() throw() { } | |
2302 | virtual ~exception() throw(); | |
2303 | virtual const char* what() const throw(); | |
2304 | }; | |
2305 | class bad_exception : public exception | |
2306 | { | |
2307 | public: | |
2308 | bad_exception() throw() { } | |
2309 | virtual ~bad_exception() throw(); | |
2310 | virtual const char* what() const throw(); | |
2311 | }; | |
2312 | typedef void (*terminate_handler) (); | |
2313 | typedef void (*unexpected_handler) (); | |
2314 | terminate_handler set_terminate(terminate_handler) throw(); | |
2315 | void terminate() __attribute__ ((__noreturn__)); | |
2316 | unexpected_handler set_unexpected(unexpected_handler) throw(); | |
2317 | void unexpected() __attribute__ ((__noreturn__)); | |
2318 | bool uncaught_exception() throw(); | |
2319 | } | |
2320 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
2321 | void __verbose_terminate_handler (); | |
2322 | } | |
2323 | } | |
2324 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2325 | void | |
2326 | __throw_bad_exception(void) __attribute__((__noreturn__)); | |
2327 | void | |
2328 | __throw_bad_alloc(void) __attribute__((__noreturn__)); | |
2329 | void | |
2330 | __throw_bad_cast(void) __attribute__((__noreturn__)); | |
2331 | void | |
2332 | __throw_bad_typeid(void) __attribute__((__noreturn__)); | |
2333 | void | |
2334 | __throw_logic_error(const char*) __attribute__((__noreturn__)); | |
2335 | void | |
2336 | __throw_domain_error(const char*) __attribute__((__noreturn__)); | |
2337 | void | |
2338 | __throw_invalid_argument(const char*) __attribute__((__noreturn__)); | |
2339 | void | |
2340 | __throw_length_error(const char*) __attribute__((__noreturn__)); | |
2341 | void | |
2342 | __throw_out_of_range(const char*) __attribute__((__noreturn__)); | |
2343 | void | |
2344 | __throw_runtime_error(const char*) __attribute__((__noreturn__)); | |
2345 | void | |
2346 | __throw_range_error(const char*) __attribute__((__noreturn__)); | |
2347 | void | |
2348 | __throw_overflow_error(const char*) __attribute__((__noreturn__)); | |
2349 | void | |
2350 | __throw_underflow_error(const char*) __attribute__((__noreturn__)); | |
2351 | void | |
2352 | __throw_ios_failure(const char*) __attribute__((__noreturn__)); | |
2353 | } | |
2354 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
2355 | template<typename _Value> | |
2356 | struct __numeric_traits_integer | |
2357 | { | |
2358 | static const _Value __min = (((_Value)(-1) < 0) ? (_Value)1 << (sizeof(_Value) * 8 - ((_Value)(-1) < 0)) : (_Value)0); | |
2359 | static const _Value __max = (((_Value)(-1) < 0) ? (((((_Value)1 << ((sizeof(_Value) * 8 - ((_Value)(-1) < 0)) - 1)) - 1) << 1) + 1) : ~(_Value)0); | |
2360 | static const bool __is_signed = ((_Value)(-1) < 0); | |
2361 | static const int __digits = (sizeof(_Value) * 8 - ((_Value)(-1) < 0)); | |
2362 | }; | |
2363 | template<typename _Value> | |
2364 | const _Value __numeric_traits_integer<_Value>::__min; | |
2365 | template<typename _Value> | |
2366 | const _Value __numeric_traits_integer<_Value>::__max; | |
2367 | template<typename _Value> | |
2368 | const bool __numeric_traits_integer<_Value>::__is_signed; | |
2369 | template<typename _Value> | |
2370 | const int __numeric_traits_integer<_Value>::__digits; | |
2371 | template<typename _Value> | |
2372 | struct __numeric_traits_floating | |
2373 | { | |
2374 | static const int __max_digits10 = (2 + (std::__are_same<_Value, float>::__value ? 24 : std::__are_same<_Value, double>::__value ? 53 : 53) * 3010 / 10000); | |
2375 | static const bool __is_signed = true; | |
2376 | static const int __digits10 = (std::__are_same<_Value, float>::__value ? 6 : std::__are_same<_Value, double>::__value ? 15 : 15); | |
2377 | static const int __max_exponent10 = (std::__are_same<_Value, float>::__value ? 38 : std::__are_same<_Value, double>::__value ? 308 : 308); | |
2378 | }; | |
2379 | template<typename _Value> | |
2380 | const int __numeric_traits_floating<_Value>::__max_digits10; | |
2381 | template<typename _Value> | |
2382 | const bool __numeric_traits_floating<_Value>::__is_signed; | |
2383 | template<typename _Value> | |
2384 | const int __numeric_traits_floating<_Value>::__digits10; | |
2385 | template<typename _Value> | |
2386 | const int __numeric_traits_floating<_Value>::__max_exponent10; | |
2387 | template<typename _Value> | |
2388 | struct __numeric_traits | |
2389 | : public __conditional_type<std::__is_integer<_Value>::__value, | |
2390 | __numeric_traits_integer<_Value>, | |
2391 | __numeric_traits_floating<_Value> >::__type | |
2392 | { }; | |
2393 | } | |
2394 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2395 | template<class _T1, class _T2> | |
2396 | struct pair | |
2397 | { | |
2398 | typedef _T1 first_type; | |
2399 | typedef _T2 second_type; | |
2400 | _T1 first; | |
2401 | _T2 second; | |
2402 | pair() | |
2403 | : first(), second() { } | |
2404 | pair(const _T1& __a, const _T2& __b) | |
2405 | : first(__a), second(__b) { } | |
2406 | template<class _U1, class _U2> | |
2407 | pair(const pair<_U1, _U2>& __p) | |
2408 | : first(__p.first), | |
2409 | second(__p.second) { } | |
2410 | }; | |
2411 | template<class _T1, class _T2> | |
2412 | inline bool | |
2413 | operator==(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
2414 | { return __x.first == __y.first && __x.second == __y.second; } | |
2415 | template<class _T1, class _T2> | |
2416 | inline bool | |
2417 | operator<(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
2418 | { return __x.first < __y.first | |
2419 | || (!(__y.first < __x.first) && __x.second < __y.second); } | |
2420 | template<class _T1, class _T2> | |
2421 | inline bool | |
2422 | operator!=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
2423 | { return !(__x == __y); } | |
2424 | template<class _T1, class _T2> | |
2425 | inline bool | |
2426 | operator>(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
2427 | { return __y < __x; } | |
2428 | template<class _T1, class _T2> | |
2429 | inline bool | |
2430 | operator<=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
2431 | { return !(__y < __x); } | |
2432 | template<class _T1, class _T2> | |
2433 | inline bool | |
2434 | operator>=(const pair<_T1, _T2>& __x, const pair<_T1, _T2>& __y) | |
2435 | { return !(__x < __y); } | |
2436 | template<class _T1, class _T2> | |
2437 | inline pair<_T1, _T2> | |
2438 | make_pair(_T1 __x, _T2 __y) | |
2439 | { return pair<_T1, _T2>(__x, __y); } | |
2440 | } | |
2441 | namespace std | |
2442 | { | |
2443 | namespace __debug { } | |
2444 | } | |
2445 | namespace __gnu_debug | |
2446 | { | |
2447 | using namespace std::__debug; | |
2448 | } | |
2449 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2450 | template<bool _BoolType> | |
2451 | struct __iter_swap | |
2452 | { | |
2453 | template<typename _ForwardIterator1, typename _ForwardIterator2> | |
2454 | static void | |
2455 | iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) | |
2456 | { | |
2457 | typedef typename iterator_traits<_ForwardIterator1>::value_type | |
2458 | _ValueType1; | |
2459 | _ValueType1 __tmp = (*__a); | |
2460 | *__a = (*__b); | |
2461 | *__b = (__tmp); | |
2462 | } | |
2463 | }; | |
2464 | template<> | |
2465 | struct __iter_swap<true> | |
2466 | { | |
2467 | template<typename _ForwardIterator1, typename _ForwardIterator2> | |
2468 | static void | |
2469 | iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) | |
2470 | { | |
2471 | swap(*__a, *__b); | |
2472 | } | |
2473 | }; | |
2474 | template<typename _ForwardIterator1, typename _ForwardIterator2> | |
2475 | inline void | |
2476 | iter_swap(_ForwardIterator1 __a, _ForwardIterator2 __b) | |
2477 | { | |
2478 | typedef typename iterator_traits<_ForwardIterator1>::value_type | |
2479 | _ValueType1; | |
2480 | typedef typename iterator_traits<_ForwardIterator2>::value_type | |
2481 | _ValueType2; | |
2482 | typedef typename iterator_traits<_ForwardIterator1>::reference | |
2483 | _ReferenceType1; | |
2484 | typedef typename iterator_traits<_ForwardIterator2>::reference | |
2485 | _ReferenceType2; | |
2486 | std::__iter_swap<__are_same<_ValueType1, _ValueType2>::__value | |
2487 | && __are_same<_ValueType1&, _ReferenceType1>::__value | |
2488 | && __are_same<_ValueType2&, _ReferenceType2>::__value>:: | |
2489 | iter_swap(__a, __b); | |
2490 | } | |
2491 | template<typename _ForwardIterator1, typename _ForwardIterator2> | |
2492 | _ForwardIterator2 | |
2493 | swap_ranges(_ForwardIterator1 __first1, _ForwardIterator1 __last1, | |
2494 | _ForwardIterator2 __first2) | |
2495 | { | |
2496 | ; | |
2497 | for (; __first1 != __last1; ++__first1, ++__first2) | |
2498 | std::iter_swap(__first1, __first2); | |
2499 | return __first2; | |
2500 | } | |
2501 | template<typename _Tp> | |
2502 | inline const _Tp& | |
2503 | min(const _Tp& __a, const _Tp& __b) | |
2504 | { | |
2505 | if (__b < __a) | |
2506 | return __b; | |
2507 | return __a; | |
2508 | } | |
2509 | template<typename _Tp> | |
2510 | inline const _Tp& | |
2511 | max(const _Tp& __a, const _Tp& __b) | |
2512 | { | |
2513 | if (__a < __b) | |
2514 | return __b; | |
2515 | return __a; | |
2516 | } | |
2517 | template<typename _Tp, typename _Compare> | |
2518 | inline const _Tp& | |
2519 | min(const _Tp& __a, const _Tp& __b, _Compare __comp) | |
2520 | { | |
2521 | if (__comp(__b, __a)) | |
2522 | return __b; | |
2523 | return __a; | |
2524 | } | |
2525 | template<typename _Tp, typename _Compare> | |
2526 | inline const _Tp& | |
2527 | max(const _Tp& __a, const _Tp& __b, _Compare __comp) | |
2528 | { | |
2529 | if (__comp(__a, __b)) | |
2530 | return __b; | |
2531 | return __a; | |
2532 | } | |
2533 | template<typename _Iterator, | |
2534 | bool _IsNormal = __is_normal_iterator<_Iterator>::__value> | |
2535 | struct __niter_base | |
2536 | { | |
2537 | static _Iterator | |
2538 | __b(_Iterator __it) | |
2539 | { return __it; } | |
2540 | }; | |
2541 | template<typename _Iterator> | |
2542 | struct __niter_base<_Iterator, true> | |
2543 | { | |
2544 | static typename _Iterator::iterator_type | |
2545 | __b(_Iterator __it) | |
2546 | { return __it.base(); } | |
2547 | }; | |
2548 | template<typename _Iterator, | |
2549 | bool _IsMove = __is_move_iterator<_Iterator>::__value> | |
2550 | struct __miter_base | |
2551 | { | |
2552 | static _Iterator | |
2553 | __b(_Iterator __it) | |
2554 | { return __it; } | |
2555 | }; | |
2556 | template<typename _Iterator> | |
2557 | struct __miter_base<_Iterator, true> | |
2558 | { | |
2559 | static typename _Iterator::iterator_type | |
2560 | __b(_Iterator __it) | |
2561 | { return __it.base(); } | |
2562 | }; | |
2563 | template<bool, bool, typename> | |
2564 | struct __copy_move | |
2565 | { | |
2566 | template<typename _II, typename _OI> | |
2567 | static _OI | |
2568 | __copy_m(_II __first, _II __last, _OI __result) | |
2569 | { | |
2570 | for (; __first != __last; ++__result, ++__first) | |
2571 | *__result = *__first; | |
2572 | return __result; | |
2573 | } | |
2574 | }; | |
2575 | template<> | |
2576 | struct __copy_move<false, false, random_access_iterator_tag> | |
2577 | { | |
2578 | template<typename _II, typename _OI> | |
2579 | static _OI | |
2580 | __copy_m(_II __first, _II __last, _OI __result) | |
2581 | { | |
2582 | typedef typename iterator_traits<_II>::difference_type _Distance; | |
2583 | for(_Distance __n = __last - __first; __n > 0; --__n) | |
2584 | { | |
2585 | *__result = *__first; | |
2586 | ++__first; | |
2587 | ++__result; | |
2588 | } | |
2589 | return __result; | |
2590 | } | |
2591 | }; | |
2592 | template<bool _IsMove> | |
2593 | struct __copy_move<_IsMove, true, random_access_iterator_tag> | |
2594 | { | |
2595 | template<typename _Tp> | |
2596 | static _Tp* | |
2597 | __copy_m(const _Tp* __first, const _Tp* __last, _Tp* __result) | |
2598 | { | |
2599 | __builtin_memmove(__result, __first, | |
2600 | sizeof(_Tp) * (__last - __first)); | |
2601 | return __result + (__last - __first); | |
2602 | } | |
2603 | }; | |
2604 | template<bool _IsMove, typename _II, typename _OI> | |
2605 | inline _OI | |
2606 | __copy_move_a(_II __first, _II __last, _OI __result) | |
2607 | { | |
2608 | typedef typename iterator_traits<_II>::value_type _ValueTypeI; | |
2609 | typedef typename iterator_traits<_OI>::value_type _ValueTypeO; | |
2610 | typedef typename iterator_traits<_II>::iterator_category _Category; | |
2611 | const bool __simple = (__is_pod(_ValueTypeI) | |
2612 | && __is_pointer<_II>::__value | |
2613 | && __is_pointer<_OI>::__value | |
2614 | && __are_same<_ValueTypeI, _ValueTypeO>::__value); | |
2615 | return std::__copy_move<_IsMove, __simple, | |
2616 | _Category>::__copy_m(__first, __last, __result); | |
2617 | } | |
2618 | template<typename _CharT> | |
2619 | struct char_traits; | |
2620 | template<typename _CharT, typename _Traits> | |
2621 | class istreambuf_iterator; | |
2622 | template<typename _CharT, typename _Traits> | |
2623 | class ostreambuf_iterator; | |
2624 | template<bool _IsMove, typename _CharT> | |
2625 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
2626 | ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type | |
2627 | __copy_move_a2(_CharT*, _CharT*, | |
2628 | ostreambuf_iterator<_CharT, char_traits<_CharT> >); | |
2629 | template<bool _IsMove, typename _CharT> | |
2630 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
2631 | ostreambuf_iterator<_CharT, char_traits<_CharT> > >::__type | |
2632 | __copy_move_a2(const _CharT*, const _CharT*, | |
2633 | ostreambuf_iterator<_CharT, char_traits<_CharT> >); | |
2634 | template<bool _IsMove, typename _CharT> | |
2635 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
2636 | _CharT*>::__type | |
2637 | __copy_move_a2(istreambuf_iterator<_CharT, char_traits<_CharT> >, | |
2638 | istreambuf_iterator<_CharT, char_traits<_CharT> >, _CharT*); | |
2639 | template<bool _IsMove, typename _II, typename _OI> | |
2640 | inline _OI | |
2641 | __copy_move_a2(_II __first, _II __last, _OI __result) | |
2642 | { | |
2643 | return _OI(std::__copy_move_a<_IsMove> | |
2644 | (std::__niter_base<_II>::__b(__first), | |
2645 | std::__niter_base<_II>::__b(__last), | |
2646 | std::__niter_base<_OI>::__b(__result))); | |
2647 | } | |
2648 | template<typename _II, typename _OI> | |
2649 | inline _OI | |
2650 | copy(_II __first, _II __last, _OI __result) | |
2651 | { | |
2652 | ; | |
2653 | return (std::__copy_move_a2<__is_move_iterator<_II>::__value> | |
2654 | (std::__miter_base<_II>::__b(__first), | |
2655 | std::__miter_base<_II>::__b(__last), __result)); | |
2656 | } | |
2657 | template<bool, bool, typename> | |
2658 | struct __copy_move_backward | |
2659 | { | |
2660 | template<typename _BI1, typename _BI2> | |
2661 | static _BI2 | |
2662 | __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) | |
2663 | { | |
2664 | while (__first != __last) | |
2665 | *--__result = *--__last; | |
2666 | return __result; | |
2667 | } | |
2668 | }; | |
2669 | template<> | |
2670 | struct __copy_move_backward<false, false, random_access_iterator_tag> | |
2671 | { | |
2672 | template<typename _BI1, typename _BI2> | |
2673 | static _BI2 | |
2674 | __copy_move_b(_BI1 __first, _BI1 __last, _BI2 __result) | |
2675 | { | |
2676 | typename iterator_traits<_BI1>::difference_type __n; | |
2677 | for (__n = __last - __first; __n > 0; --__n) | |
2678 | *--__result = *--__last; | |
2679 | return __result; | |
2680 | } | |
2681 | }; | |
2682 | template<bool _IsMove> | |
2683 | struct __copy_move_backward<_IsMove, true, random_access_iterator_tag> | |
2684 | { | |
2685 | template<typename _Tp> | |
2686 | static _Tp* | |
2687 | __copy_move_b(const _Tp* __first, const _Tp* __last, _Tp* __result) | |
2688 | { | |
2689 | const ptrdiff_t _Num = __last - __first; | |
2690 | __builtin_memmove(__result - _Num, __first, sizeof(_Tp) * _Num); | |
2691 | return __result - _Num; | |
2692 | } | |
2693 | }; | |
2694 | template<bool _IsMove, typename _BI1, typename _BI2> | |
2695 | inline _BI2 | |
2696 | __copy_move_backward_a(_BI1 __first, _BI1 __last, _BI2 __result) | |
2697 | { | |
2698 | typedef typename iterator_traits<_BI1>::value_type _ValueType1; | |
2699 | typedef typename iterator_traits<_BI2>::value_type _ValueType2; | |
2700 | typedef typename iterator_traits<_BI1>::iterator_category _Category; | |
2701 | const bool __simple = (__is_pod(_ValueType1) | |
2702 | && __is_pointer<_BI1>::__value | |
2703 | && __is_pointer<_BI2>::__value | |
2704 | && __are_same<_ValueType1, _ValueType2>::__value); | |
2705 | return std::__copy_move_backward<_IsMove, __simple, | |
2706 | _Category>::__copy_move_b(__first, | |
2707 | __last, | |
2708 | __result); | |
2709 | } | |
2710 | template<bool _IsMove, typename _BI1, typename _BI2> | |
2711 | inline _BI2 | |
2712 | __copy_move_backward_a2(_BI1 __first, _BI1 __last, _BI2 __result) | |
2713 | { | |
2714 | return _BI2(std::__copy_move_backward_a<_IsMove> | |
2715 | (std::__niter_base<_BI1>::__b(__first), | |
2716 | std::__niter_base<_BI1>::__b(__last), | |
2717 | std::__niter_base<_BI2>::__b(__result))); | |
2718 | } | |
2719 | template<typename _BI1, typename _BI2> | |
2720 | inline _BI2 | |
2721 | copy_backward(_BI1 __first, _BI1 __last, _BI2 __result) | |
2722 | { | |
2723 | ; | |
2724 | return (std::__copy_move_backward_a2<__is_move_iterator<_BI1>::__value> | |
2725 | (std::__miter_base<_BI1>::__b(__first), | |
2726 | std::__miter_base<_BI1>::__b(__last), __result)); | |
2727 | } | |
2728 | template<typename _ForwardIterator, typename _Tp> | |
2729 | inline typename | |
2730 | __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, void>::__type | |
2731 | __fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
2732 | const _Tp& __value) | |
2733 | { | |
2734 | for (; __first != __last; ++__first) | |
2735 | *__first = __value; | |
2736 | } | |
2737 | template<typename _ForwardIterator, typename _Tp> | |
2738 | inline typename | |
2739 | __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, void>::__type | |
2740 | __fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
2741 | const _Tp& __value) | |
2742 | { | |
2743 | const _Tp __tmp = __value; | |
2744 | for (; __first != __last; ++__first) | |
2745 | *__first = __tmp; | |
2746 | } | |
2747 | template<typename _Tp> | |
2748 | inline typename | |
2749 | __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, void>::__type | |
2750 | __fill_a(_Tp* __first, _Tp* __last, const _Tp& __c) | |
2751 | { | |
2752 | const _Tp __tmp = __c; | |
2753 | __builtin_memset(__first, static_cast<unsigned char>(__tmp), | |
2754 | __last - __first); | |
2755 | } | |
2756 | template<typename _ForwardIterator, typename _Tp> | |
2757 | inline void | |
2758 | fill(_ForwardIterator __first, _ForwardIterator __last, const _Tp& __value) | |
2759 | { | |
2760 | ; | |
2761 | std::__fill_a(std::__niter_base<_ForwardIterator>::__b(__first), | |
2762 | std::__niter_base<_ForwardIterator>::__b(__last), __value); | |
2763 | } | |
2764 | template<typename _OutputIterator, typename _Size, typename _Tp> | |
2765 | inline typename | |
2766 | __gnu_cxx::__enable_if<!__is_scalar<_Tp>::__value, _OutputIterator>::__type | |
2767 | __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) | |
2768 | { | |
2769 | for (; __n > 0; --__n, ++__first) | |
2770 | *__first = __value; | |
2771 | return __first; | |
2772 | } | |
2773 | template<typename _OutputIterator, typename _Size, typename _Tp> | |
2774 | inline typename | |
2775 | __gnu_cxx::__enable_if<__is_scalar<_Tp>::__value, _OutputIterator>::__type | |
2776 | __fill_n_a(_OutputIterator __first, _Size __n, const _Tp& __value) | |
2777 | { | |
2778 | const _Tp __tmp = __value; | |
2779 | for (; __n > 0; --__n, ++__first) | |
2780 | *__first = __tmp; | |
2781 | return __first; | |
2782 | } | |
2783 | template<typename _Size, typename _Tp> | |
2784 | inline typename | |
2785 | __gnu_cxx::__enable_if<__is_byte<_Tp>::__value, _Tp*>::__type | |
2786 | __fill_n_a(_Tp* __first, _Size __n, const _Tp& __c) | |
2787 | { | |
2788 | std::__fill_a(__first, __first + __n, __c); | |
2789 | return __first + __n; | |
2790 | } | |
2791 | template<typename _OI, typename _Size, typename _Tp> | |
2792 | inline _OI | |
2793 | fill_n(_OI __first, _Size __n, const _Tp& __value) | |
2794 | { | |
2795 | return _OI(std::__fill_n_a(std::__niter_base<_OI>::__b(__first), | |
2796 | __n, __value)); | |
2797 | } | |
2798 | template<bool _BoolType> | |
2799 | struct __equal | |
2800 | { | |
2801 | template<typename _II1, typename _II2> | |
2802 | static bool | |
2803 | equal(_II1 __first1, _II1 __last1, _II2 __first2) | |
2804 | { | |
2805 | for (; __first1 != __last1; ++__first1, ++__first2) | |
2806 | if (!(*__first1 == *__first2)) | |
2807 | return false; | |
2808 | return true; | |
2809 | } | |
2810 | }; | |
2811 | template<> | |
2812 | struct __equal<true> | |
2813 | { | |
2814 | template<typename _Tp> | |
2815 | static bool | |
2816 | equal(const _Tp* __first1, const _Tp* __last1, const _Tp* __first2) | |
2817 | { | |
2818 | return !__builtin_memcmp(__first1, __first2, sizeof(_Tp) | |
2819 | * (__last1 - __first1)); | |
2820 | } | |
2821 | }; | |
2822 | template<typename _II1, typename _II2> | |
2823 | inline bool | |
2824 | __equal_aux(_II1 __first1, _II1 __last1, _II2 __first2) | |
2825 | { | |
2826 | typedef typename iterator_traits<_II1>::value_type _ValueType1; | |
2827 | typedef typename iterator_traits<_II2>::value_type _ValueType2; | |
2828 | const bool __simple = (__is_integer<_ValueType1>::__value | |
2829 | && __is_pointer<_II1>::__value | |
2830 | && __is_pointer<_II2>::__value | |
2831 | && __are_same<_ValueType1, _ValueType2>::__value); | |
2832 | return std::__equal<__simple>::equal(__first1, __last1, __first2); | |
2833 | } | |
2834 | template<typename, typename> | |
2835 | struct __lc_rai | |
2836 | { | |
2837 | template<typename _II1, typename _II2> | |
2838 | static _II1 | |
2839 | __newlast1(_II1, _II1 __last1, _II2, _II2) | |
2840 | { return __last1; } | |
2841 | template<typename _II> | |
2842 | static bool | |
2843 | __cnd2(_II __first, _II __last) | |
2844 | { return __first != __last; } | |
2845 | }; | |
2846 | template<> | |
2847 | struct __lc_rai<random_access_iterator_tag, random_access_iterator_tag> | |
2848 | { | |
2849 | template<typename _RAI1, typename _RAI2> | |
2850 | static _RAI1 | |
2851 | __newlast1(_RAI1 __first1, _RAI1 __last1, | |
2852 | _RAI2 __first2, _RAI2 __last2) | |
2853 | { | |
2854 | const typename iterator_traits<_RAI1>::difference_type | |
2855 | __diff1 = __last1 - __first1; | |
2856 | const typename iterator_traits<_RAI2>::difference_type | |
2857 | __diff2 = __last2 - __first2; | |
2858 | return __diff2 < __diff1 ? __first1 + __diff2 : __last1; | |
2859 | } | |
2860 | template<typename _RAI> | |
2861 | static bool | |
2862 | __cnd2(_RAI, _RAI) | |
2863 | { return true; } | |
2864 | }; | |
2865 | template<bool _BoolType> | |
2866 | struct __lexicographical_compare | |
2867 | { | |
2868 | template<typename _II1, typename _II2> | |
2869 | static bool __lc(_II1, _II1, _II2, _II2); | |
2870 | }; | |
2871 | template<bool _BoolType> | |
2872 | template<typename _II1, typename _II2> | |
2873 | bool | |
2874 | __lexicographical_compare<_BoolType>:: | |
2875 | __lc(_II1 __first1, _II1 __last1, _II2 __first2, _II2 __last2) | |
2876 | { | |
2877 | typedef typename iterator_traits<_II1>::iterator_category _Category1; | |
2878 | typedef typename iterator_traits<_II2>::iterator_category _Category2; | |
2879 | typedef std::__lc_rai<_Category1, _Category2> __rai_type; | |
2880 | __last1 = __rai_type::__newlast1(__first1, __last1, | |
2881 | __first2, __last2); | |
2882 | for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); | |
2883 | ++__first1, ++__first2) | |
2884 | { | |
2885 | if (*__first1 < *__first2) | |
2886 | return true; | |
2887 | if (*__first2 < *__first1) | |
2888 | return false; | |
2889 | } | |
2890 | return __first1 == __last1 && __first2 != __last2; | |
2891 | } | |
2892 | template<> | |
2893 | struct __lexicographical_compare<true> | |
2894 | { | |
2895 | template<typename _Tp, typename _Up> | |
2896 | static bool | |
2897 | __lc(const _Tp* __first1, const _Tp* __last1, | |
2898 | const _Up* __first2, const _Up* __last2) | |
2899 | { | |
2900 | const size_t __len1 = __last1 - __first1; | |
2901 | const size_t __len2 = __last2 - __first2; | |
2902 | const int __result = __builtin_memcmp(__first1, __first2, | |
2903 | std::min(__len1, __len2)); | |
2904 | return __result != 0 ? __result < 0 : __len1 < __len2; | |
2905 | } | |
2906 | }; | |
2907 | template<typename _II1, typename _II2> | |
2908 | inline bool | |
2909 | __lexicographical_compare_aux(_II1 __first1, _II1 __last1, | |
2910 | _II2 __first2, _II2 __last2) | |
2911 | { | |
2912 | typedef typename iterator_traits<_II1>::value_type _ValueType1; | |
2913 | typedef typename iterator_traits<_II2>::value_type _ValueType2; | |
2914 | const bool __simple = | |
2915 | (__is_byte<_ValueType1>::__value && __is_byte<_ValueType2>::__value | |
2916 | && !__gnu_cxx::__numeric_traits<_ValueType1>::__is_signed | |
2917 | && !__gnu_cxx::__numeric_traits<_ValueType2>::__is_signed | |
2918 | && __is_pointer<_II1>::__value | |
2919 | && __is_pointer<_II2>::__value); | |
2920 | return std::__lexicographical_compare<__simple>::__lc(__first1, __last1, | |
2921 | __first2, __last2); | |
2922 | } | |
2923 | } | |
2924 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
2925 | template<typename _II1, typename _II2> | |
2926 | inline bool | |
2927 | equal(_II1 __first1, _II1 __last1, _II2 __first2) | |
2928 | { | |
2929 | ; | |
2930 | return std::__equal_aux(std::__niter_base<_II1>::__b(__first1), | |
2931 | std::__niter_base<_II1>::__b(__last1), | |
2932 | std::__niter_base<_II2>::__b(__first2)); | |
2933 | } | |
2934 | template<typename _IIter1, typename _IIter2, typename _BinaryPredicate> | |
2935 | inline bool | |
2936 | equal(_IIter1 __first1, _IIter1 __last1, | |
2937 | _IIter2 __first2, _BinaryPredicate __binary_pred) | |
2938 | { | |
2939 | ; | |
2940 | for (; __first1 != __last1; ++__first1, ++__first2) | |
2941 | if (!bool(__binary_pred(*__first1, *__first2))) | |
2942 | return false; | |
2943 | return true; | |
2944 | } | |
2945 | template<typename _II1, typename _II2> | |
2946 | inline bool | |
2947 | lexicographical_compare(_II1 __first1, _II1 __last1, | |
2948 | _II2 __first2, _II2 __last2) | |
2949 | { | |
2950 | typedef typename iterator_traits<_II1>::value_type _ValueType1; | |
2951 | typedef typename iterator_traits<_II2>::value_type _ValueType2; | |
2952 | ; | |
2953 | ; | |
2954 | return std::__lexicographical_compare_aux | |
2955 | (std::__niter_base<_II1>::__b(__first1), | |
2956 | std::__niter_base<_II1>::__b(__last1), | |
2957 | std::__niter_base<_II2>::__b(__first2), | |
2958 | std::__niter_base<_II2>::__b(__last2)); | |
2959 | } | |
2960 | template<typename _II1, typename _II2, typename _Compare> | |
2961 | bool | |
2962 | lexicographical_compare(_II1 __first1, _II1 __last1, | |
2963 | _II2 __first2, _II2 __last2, _Compare __comp) | |
2964 | { | |
2965 | typedef typename iterator_traits<_II1>::iterator_category _Category1; | |
2966 | typedef typename iterator_traits<_II2>::iterator_category _Category2; | |
2967 | typedef std::__lc_rai<_Category1, _Category2> __rai_type; | |
2968 | ; | |
2969 | ; | |
2970 | __last1 = __rai_type::__newlast1(__first1, __last1, __first2, __last2); | |
2971 | for (; __first1 != __last1 && __rai_type::__cnd2(__first2, __last2); | |
2972 | ++__first1, ++__first2) | |
2973 | { | |
2974 | if (__comp(*__first1, *__first2)) | |
2975 | return true; | |
2976 | if (__comp(*__first2, *__first1)) | |
2977 | return false; | |
2978 | } | |
2979 | return __first1 == __last1 && __first2 != __last2; | |
2980 | } | |
2981 | template<typename _InputIterator1, typename _InputIterator2> | |
2982 | pair<_InputIterator1, _InputIterator2> | |
2983 | mismatch(_InputIterator1 __first1, _InputIterator1 __last1, | |
2984 | _InputIterator2 __first2) | |
2985 | { | |
2986 | ; | |
2987 | while (__first1 != __last1 && *__first1 == *__first2) | |
2988 | { | |
2989 | ++__first1; | |
2990 | ++__first2; | |
2991 | } | |
2992 | return pair<_InputIterator1, _InputIterator2>(__first1, __first2); | |
2993 | } | |
2994 | template<typename _InputIterator1, typename _InputIterator2, | |
2995 | typename _BinaryPredicate> | |
2996 | pair<_InputIterator1, _InputIterator2> | |
2997 | mismatch(_InputIterator1 __first1, _InputIterator1 __last1, | |
2998 | _InputIterator2 __first2, _BinaryPredicate __binary_pred) | |
2999 | { | |
3000 | ; | |
3001 | while (__first1 != __last1 && bool(__binary_pred(*__first1, *__first2))) | |
3002 | { | |
3003 | ++__first1; | |
3004 | ++__first2; | |
3005 | } | |
3006 | return pair<_InputIterator1, _InputIterator2>(__first1, __first2); | |
3007 | } | |
3008 | } | |
3009 | extern "C" { | |
3010 | typedef unsigned short __kernel_dev_t; | |
3011 | typedef unsigned long __kernel_ino_t; | |
3012 | typedef unsigned short __kernel_mode_t; | |
3013 | typedef unsigned short __kernel_nlink_t; | |
3014 | typedef long __kernel_off_t; | |
3015 | typedef int __kernel_pid_t; | |
3016 | typedef unsigned int __kernel_ipc_pid_t; | |
3017 | typedef unsigned int __kernel_uid_t; | |
3018 | typedef unsigned int __kernel_gid_t; | |
3019 | typedef unsigned int __kernel_size_t; | |
3020 | typedef int __kernel_ssize_t; | |
3021 | typedef int __kernel_ptrdiff_t; | |
3022 | typedef long __kernel_time_t; | |
3023 | typedef long __kernel_suseconds_t; | |
3024 | typedef long __kernel_clock_t; | |
3025 | typedef int __kernel_daddr_t; | |
3026 | typedef char * __kernel_caddr_t; | |
3027 | typedef unsigned short __kernel_uid16_t; | |
3028 | typedef unsigned short __kernel_gid16_t; | |
3029 | typedef unsigned int __kernel_uid32_t; | |
3030 | typedef unsigned int __kernel_gid32_t; | |
3031 | typedef unsigned short __kernel_old_uid_t; | |
3032 | typedef unsigned short __kernel_old_gid_t; | |
3033 | typedef long long __kernel_loff_t; | |
3034 | typedef __kernel_dev_t __kernel_old_dev_t; | |
3035 | typedef struct { | |
3036 | int __val[2]; | |
3037 | } __kernel_fsid_t; | |
3038 | typedef unsigned char __u_char; | |
3039 | typedef unsigned short int __u_short; | |
3040 | typedef unsigned int __u_int; | |
3041 | typedef unsigned long int __u_long; | |
3042 | typedef signed char __int8_t; | |
3043 | typedef unsigned char __uint8_t; | |
3044 | typedef signed short int __int16_t; | |
3045 | typedef unsigned short int __uint16_t; | |
3046 | typedef signed int __int32_t; | |
3047 | typedef unsigned int __uint32_t; | |
3048 | __extension__ typedef signed long long int __int64_t; | |
3049 | __extension__ typedef unsigned long long int __uint64_t; | |
3050 | __extension__ typedef long long int __quad_t; | |
3051 | __extension__ typedef unsigned long long int __u_quad_t; | |
3052 | __extension__ typedef __u_quad_t __dev_t; | |
3053 | __extension__ typedef unsigned int __uid_t; | |
3054 | __extension__ typedef unsigned int __gid_t; | |
3055 | __extension__ typedef unsigned long int __ino_t; | |
3056 | __extension__ typedef __u_quad_t __ino64_t; | |
3057 | __extension__ typedef unsigned int __mode_t; | |
3058 | __extension__ typedef unsigned int __nlink_t; | |
3059 | __extension__ typedef long int __off_t; | |
3060 | __extension__ typedef __quad_t __off64_t; | |
3061 | __extension__ typedef int __pid_t; | |
3062 | __extension__ typedef struct { int __val[2]; } __fsid_t; | |
3063 | __extension__ typedef long int __clock_t; | |
3064 | __extension__ typedef unsigned long int __rlim_t; | |
3065 | __extension__ typedef __u_quad_t __rlim64_t; | |
3066 | __extension__ typedef unsigned int __id_t; | |
3067 | __extension__ typedef long int __time_t; | |
3068 | __extension__ typedef unsigned int __useconds_t; | |
3069 | __extension__ typedef long int __suseconds_t; | |
3070 | __extension__ typedef int __daddr_t; | |
3071 | __extension__ typedef long int __swblk_t; | |
3072 | __extension__ typedef int __key_t; | |
3073 | __extension__ typedef int __clockid_t; | |
3074 | __extension__ typedef void * __timer_t; | |
3075 | __extension__ typedef long int __blksize_t; | |
3076 | __extension__ typedef long int __blkcnt_t; | |
3077 | __extension__ typedef __quad_t __blkcnt64_t; | |
3078 | __extension__ typedef unsigned long int __fsblkcnt_t; | |
3079 | __extension__ typedef __u_quad_t __fsblkcnt64_t; | |
3080 | __extension__ typedef unsigned long int __fsfilcnt_t; | |
3081 | __extension__ typedef __u_quad_t __fsfilcnt64_t; | |
3082 | __extension__ typedef long int __ssize_t; | |
3083 | typedef __off64_t __loff_t; | |
3084 | typedef __quad_t *__qaddr_t; | |
3085 | typedef char *__caddr_t; | |
3086 | __extension__ typedef int __intptr_t; | |
3087 | __extension__ typedef unsigned int __socklen_t; | |
3088 | typedef __kernel_ipc_pid_t __ipc_pid_t; | |
3089 | struct __sched_param | |
3090 | { | |
3091 | int __sched_priority; | |
3092 | }; | |
3093 | struct _pthread_fastlock | |
3094 | { | |
3095 | long int __status; | |
3096 | int __spinlock; | |
3097 | }; | |
3098 | typedef struct _pthread_descr_struct *_pthread_descr; | |
3099 | typedef struct __pthread_attr_s | |
3100 | { | |
3101 | int __detachstate; | |
3102 | int __schedpolicy; | |
3103 | struct __sched_param __schedparam; | |
3104 | int __inheritsched; | |
3105 | int __scope; | |
3106 | size_t __guardsize; | |
3107 | int __stackaddr_set; | |
3108 | void *__stackaddr; | |
3109 | size_t __stacksize; | |
3110 | } pthread_attr_t; | |
3111 | typedef struct | |
3112 | { | |
3113 | struct _pthread_fastlock __c_lock; | |
3114 | _pthread_descr __c_waiting; | |
3115 | } pthread_cond_t; | |
3116 | typedef struct | |
3117 | { | |
3118 | int __dummy; | |
3119 | } pthread_condattr_t; | |
3120 | typedef unsigned int pthread_key_t; | |
3121 | typedef struct | |
3122 | { | |
3123 | int __m_reserved; | |
3124 | int __m_count; | |
3125 | _pthread_descr __m_owner; | |
3126 | int __m_kind; | |
3127 | struct _pthread_fastlock __m_lock; | |
3128 | } pthread_mutex_t; | |
3129 | typedef struct | |
3130 | { | |
3131 | int __mutexkind; | |
3132 | } pthread_mutexattr_t; | |
3133 | typedef int pthread_once_t; | |
3134 | typedef struct _pthread_rwlock_t | |
3135 | { | |
3136 | struct _pthread_fastlock __rw_lock; | |
3137 | int __rw_readers; | |
3138 | _pthread_descr __rw_writer; | |
3139 | _pthread_descr __rw_read_waiting; | |
3140 | _pthread_descr __rw_write_waiting; | |
3141 | int __rw_kind; | |
3142 | int __rw_pshared; | |
3143 | } pthread_rwlock_t; | |
3144 | typedef struct | |
3145 | { | |
3146 | int __lockkind; | |
3147 | int __pshared; | |
3148 | } pthread_rwlockattr_t; | |
3149 | typedef volatile int pthread_spinlock_t; | |
3150 | typedef struct { | |
3151 | struct _pthread_fastlock __ba_lock; | |
3152 | int __ba_required; | |
3153 | int __ba_present; | |
3154 | _pthread_descr __ba_waiting; | |
3155 | } pthread_barrier_t; | |
3156 | typedef struct { | |
3157 | int __pshared; | |
3158 | } pthread_barrierattr_t; | |
3159 | typedef unsigned long int pthread_t; | |
3160 | typedef struct __STDIO_FILE_STRUCT FILE; | |
3161 | typedef struct __STDIO_FILE_STRUCT __FILE; | |
3162 | struct timespec | |
3163 | { | |
3164 | __time_t tv_sec; | |
3165 | long int tv_nsec; | |
3166 | }; | |
3167 | struct sched_param | |
3168 | { | |
3169 | int __sched_priority; | |
3170 | }; | |
3171 | extern "C" { | |
3172 | extern int clone (int (*__fn) (void *__arg), void *__child_stack, | |
3173 | int __flags, void *__arg, ...) throw (); | |
3174 | } | |
3175 | typedef unsigned long int __cpu_mask; | |
3176 | typedef struct | |
3177 | { | |
3178 | __cpu_mask __bits[1024 / (8 * sizeof (__cpu_mask))]; | |
3179 | } cpu_set_t; | |
3180 | extern "C" { | |
3181 | extern int sched_setparam (__pid_t __pid, __const struct sched_param *__param) | |
3182 | throw (); | |
3183 | extern int sched_getparam (__pid_t __pid, struct sched_param *__param) throw (); | |
3184 | extern int sched_setscheduler (__pid_t __pid, int __policy, | |
3185 | __const struct sched_param *__param) throw (); | |
3186 | extern int sched_getscheduler (__pid_t __pid) throw (); | |
3187 | extern int sched_yield (void) throw (); | |
3188 | extern int sched_get_priority_max (int __algorithm) throw (); | |
3189 | extern int sched_get_priority_min (int __algorithm) throw (); | |
3190 | extern int sched_rr_get_interval (__pid_t __pid, struct timespec *__t) throw (); | |
3191 | extern int sched_setaffinity (__pid_t __pid, size_t __cpusetsize, | |
3192 | __const cpu_set_t *__cpuset) throw (); | |
3193 | extern int sched_getaffinity (__pid_t __pid, size_t __cpusetsize, | |
3194 | cpu_set_t *__cpuset) throw (); | |
3195 | } | |
3196 | extern "C" { | |
3197 | typedef __clock_t clock_t; | |
3198 | typedef __time_t time_t; | |
3199 | typedef __clockid_t clockid_t; | |
3200 | typedef __timer_t timer_t; | |
3201 | struct tm | |
3202 | { | |
3203 | int tm_sec; | |
3204 | int tm_min; | |
3205 | int tm_hour; | |
3206 | int tm_mday; | |
3207 | int tm_mon; | |
3208 | int tm_year; | |
3209 | int tm_wday; | |
3210 | int tm_yday; | |
3211 | int tm_isdst; | |
3212 | long int tm_gmtoff; | |
3213 | __const char *tm_zone; | |
3214 | }; | |
3215 | struct itimerspec | |
3216 | { | |
3217 | struct timespec it_interval; | |
3218 | struct timespec it_value; | |
3219 | }; | |
3220 | struct sigevent; | |
3221 | typedef __pid_t pid_t; | |
3222 | extern clock_t clock (void) throw (); | |
3223 | extern time_t time (time_t *__timer) throw (); | |
3224 | extern double difftime (time_t __time1, time_t __time0) | |
3225 | throw () __attribute__ ((__const__)); | |
3226 | extern time_t mktime (struct tm *__tp) throw (); | |
3227 | extern size_t strftime (char *__restrict __s, size_t __maxsize, | |
3228 | __const char *__restrict __format, | |
3229 | __const struct tm *__restrict __tp) throw (); | |
3230 | extern char *strptime (__const char *__restrict __s, | |
3231 | __const char *__restrict __fmt, struct tm *__tp) | |
3232 | throw (); | |
3233 | extern struct tm *gmtime (__const time_t *__timer) throw (); | |
3234 | extern struct tm *localtime (__const time_t *__timer) throw (); | |
3235 | extern struct tm *gmtime_r (__const time_t *__restrict __timer, | |
3236 | struct tm *__restrict __tp) throw (); | |
3237 | extern struct tm *localtime_r (__const time_t *__restrict __timer, | |
3238 | struct tm *__restrict __tp) throw (); | |
3239 | extern char *asctime (__const struct tm *__tp) throw (); | |
3240 | extern char *ctime (__const time_t *__timer) throw (); | |
3241 | extern char *asctime_r (__const struct tm *__restrict __tp, | |
3242 | char *__restrict __buf) throw (); | |
3243 | extern char *ctime_r (__const time_t *__restrict __timer, | |
3244 | char *__restrict __buf) throw (); | |
3245 | extern char *tzname[2]; | |
3246 | extern void tzset (void) throw (); | |
3247 | extern int daylight; | |
3248 | extern long int timezone; | |
3249 | extern int stime (__const time_t *__when) throw (); | |
3250 | extern time_t timegm (struct tm *__tp) throw (); | |
3251 | extern time_t timelocal (struct tm *__tp) throw (); | |
3252 | extern int dysize (int __year) throw () __attribute__ ((__const__)); | |
3253 | extern int nanosleep (__const struct timespec *__requested_time, | |
3254 | struct timespec *__remaining); | |
3255 | extern int clock_getres (clockid_t __clock_id, struct timespec *__res) throw (); | |
3256 | extern int clock_gettime (clockid_t __clock_id, struct timespec *__tp) throw (); | |
3257 | extern int clock_settime (clockid_t __clock_id, __const struct timespec *__tp) | |
3258 | throw (); | |
3259 | extern int timer_create (clockid_t __clock_id, | |
3260 | struct sigevent *__restrict __evp, | |
3261 | timer_t *__restrict __timerid) throw (); | |
3262 | extern int timer_delete (timer_t __timerid) throw (); | |
3263 | extern int timer_settime (timer_t __timerid, int __flags, | |
3264 | __const struct itimerspec *__restrict __value, | |
3265 | struct itimerspec *__restrict __ovalue) throw (); | |
3266 | extern int timer_gettime (timer_t __timerid, struct itimerspec *__value) | |
3267 | throw (); | |
3268 | extern int timer_getoverrun (timer_t __timerid) throw (); | |
3269 | } | |
3270 | extern "C" { | |
3271 | typedef int __sig_atomic_t; | |
3272 | typedef struct | |
3273 | { | |
3274 | unsigned long int __val[(1024 / (8 * sizeof (unsigned long int)))]; | |
3275 | } __sigset_t; | |
3276 | typedef __sigset_t sigset_t; | |
3277 | } | |
3278 | extern "C" { | |
3279 | enum | |
3280 | { | |
3281 | PTHREAD_CREATE_JOINABLE, | |
3282 | PTHREAD_CREATE_DETACHED | |
3283 | }; | |
3284 | enum | |
3285 | { | |
3286 | PTHREAD_INHERIT_SCHED, | |
3287 | PTHREAD_EXPLICIT_SCHED | |
3288 | }; | |
3289 | enum | |
3290 | { | |
3291 | PTHREAD_SCOPE_SYSTEM, | |
3292 | PTHREAD_SCOPE_PROCESS | |
3293 | }; | |
3294 | enum | |
3295 | { | |
3296 | PTHREAD_MUTEX_ADAPTIVE_NP, | |
3297 | PTHREAD_MUTEX_RECURSIVE_NP, | |
3298 | PTHREAD_MUTEX_ERRORCHECK_NP, | |
3299 | PTHREAD_MUTEX_TIMED_NP | |
3300 | , | |
3301 | PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_ADAPTIVE_NP, | |
3302 | PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP, | |
3303 | PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP, | |
3304 | PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL | |
3305 | , PTHREAD_MUTEX_FAST_NP = PTHREAD_MUTEX_ADAPTIVE_NP | |
3306 | }; | |
3307 | enum | |
3308 | { | |
3309 | PTHREAD_PROCESS_PRIVATE, | |
3310 | PTHREAD_PROCESS_SHARED | |
3311 | }; | |
3312 | enum | |
3313 | { | |
3314 | PTHREAD_RWLOCK_PREFER_READER_NP, | |
3315 | PTHREAD_RWLOCK_PREFER_WRITER_NP, | |
3316 | PTHREAD_RWLOCK_PREFER_WRITER_NONRECURSIVE_NP, | |
3317 | PTHREAD_RWLOCK_DEFAULT_NP = PTHREAD_RWLOCK_PREFER_WRITER_NP | |
3318 | }; | |
3319 | struct _pthread_cleanup_buffer | |
3320 | { | |
3321 | void (*__routine) (void *); | |
3322 | void *__arg; | |
3323 | int __canceltype; | |
3324 | struct _pthread_cleanup_buffer *__prev; | |
3325 | }; | |
3326 | enum | |
3327 | { | |
3328 | PTHREAD_CANCEL_ENABLE, | |
3329 | PTHREAD_CANCEL_DISABLE | |
3330 | }; | |
3331 | enum | |
3332 | { | |
3333 | PTHREAD_CANCEL_DEFERRED, | |
3334 | PTHREAD_CANCEL_ASYNCHRONOUS | |
3335 | }; | |
3336 | extern int pthread_create (pthread_t *__restrict __threadp, | |
3337 | __const pthread_attr_t *__restrict __attr, | |
3338 | void *(*__start_routine) (void *), | |
3339 | void *__restrict __arg) throw (); | |
3340 | extern pthread_t pthread_self (void) throw (); | |
3341 | extern int pthread_equal (pthread_t __thread1, pthread_t __thread2) throw (); | |
3342 | extern void pthread_exit (void *__retval) __attribute__ ((__noreturn__)); | |
3343 | extern int pthread_join (pthread_t __th, void **__thread_return); | |
3344 | extern int pthread_detach (pthread_t __th) throw (); | |
3345 | extern int pthread_attr_init (pthread_attr_t *__attr) throw (); | |
3346 | extern int pthread_attr_destroy (pthread_attr_t *__attr) throw (); | |
3347 | extern int pthread_attr_setdetachstate (pthread_attr_t *__attr, | |
3348 | int __detachstate) throw (); | |
3349 | extern int pthread_attr_getdetachstate (__const pthread_attr_t *__attr, | |
3350 | int *__detachstate) throw (); | |
3351 | extern int pthread_attr_setschedparam (pthread_attr_t *__restrict __attr, | |
3352 | __const struct sched_param *__restrict | |
3353 | __param) throw (); | |
3354 | extern int pthread_attr_getschedparam (__const pthread_attr_t *__restrict | |
3355 | __attr, | |
3356 | struct sched_param *__restrict __param) | |
3357 | throw (); | |
3358 | extern int pthread_attr_setschedpolicy (pthread_attr_t *__attr, int __policy) | |
3359 | throw (); | |
3360 | extern int pthread_attr_getschedpolicy (__const pthread_attr_t *__restrict | |
3361 | __attr, int *__restrict __policy) | |
3362 | throw (); | |
3363 | extern int pthread_attr_setinheritsched (pthread_attr_t *__attr, | |
3364 | int __inherit) throw (); | |
3365 | extern int pthread_attr_getinheritsched (__const pthread_attr_t *__restrict | |
3366 | __attr, int *__restrict __inherit) | |
3367 | throw (); | |
3368 | extern int pthread_attr_setscope (pthread_attr_t *__attr, int __scope) | |
3369 | throw (); | |
3370 | extern int pthread_attr_getscope (__const pthread_attr_t *__restrict __attr, | |
3371 | int *__restrict __scope) throw (); | |
3372 | extern int pthread_attr_setguardsize (pthread_attr_t *__attr, | |
3373 | size_t __guardsize) throw (); | |
3374 | extern int pthread_attr_getguardsize (__const pthread_attr_t *__restrict | |
3375 | __attr, size_t *__restrict __guardsize) | |
3376 | throw (); | |
3377 | extern int pthread_attr_setstackaddr (pthread_attr_t *__attr, | |
3378 | void *__stackaddr) throw (); | |
3379 | extern int pthread_attr_getstackaddr (__const pthread_attr_t *__restrict | |
3380 | __attr, void **__restrict __stackaddr) | |
3381 | throw (); | |
3382 | extern int pthread_attr_setstack (pthread_attr_t *__attr, void *__stackaddr, | |
3383 | size_t __stacksize) throw (); | |
3384 | extern int pthread_attr_getstack (__const pthread_attr_t *__restrict __attr, | |
3385 | void **__restrict __stackaddr, | |
3386 | size_t *__restrict __stacksize) throw (); | |
3387 | extern int pthread_attr_setstacksize (pthread_attr_t *__attr, | |
3388 | size_t __stacksize) throw (); | |
3389 | extern int pthread_attr_getstacksize (__const pthread_attr_t *__restrict | |
3390 | __attr, size_t *__restrict __stacksize) | |
3391 | throw (); | |
3392 | extern int pthread_setschedparam (pthread_t __target_thread, int __policy, | |
3393 | __const struct sched_param *__param) | |
3394 | throw (); | |
3395 | extern int pthread_getschedparam (pthread_t __target_thread, | |
3396 | int *__restrict __policy, | |
3397 | struct sched_param *__restrict __param) | |
3398 | throw (); | |
3399 | extern int pthread_getconcurrency (void) throw (); | |
3400 | extern int pthread_setconcurrency (int __level) throw (); | |
3401 | extern int pthread_mutex_init (pthread_mutex_t *__restrict __mutex, | |
3402 | __const pthread_mutexattr_t *__restrict | |
3403 | __mutex_attr) throw (); | |
3404 | extern int pthread_mutex_destroy (pthread_mutex_t *__mutex) throw (); | |
3405 | extern int pthread_mutex_trylock (pthread_mutex_t *__mutex) throw (); | |
3406 | extern int pthread_mutex_lock (pthread_mutex_t *__mutex) throw (); | |
3407 | extern int pthread_mutex_timedlock (pthread_mutex_t *__restrict __mutex, | |
3408 | __const struct timespec *__restrict | |
3409 | __abstime) throw (); | |
3410 | extern int pthread_mutex_unlock (pthread_mutex_t *__mutex) throw (); | |
3411 | extern int pthread_mutexattr_init (pthread_mutexattr_t *__attr) throw (); | |
3412 | extern int pthread_mutexattr_destroy (pthread_mutexattr_t *__attr) throw (); | |
3413 | extern int pthread_mutexattr_getpshared (__const pthread_mutexattr_t * | |
3414 | __restrict __attr, | |
3415 | int *__restrict __pshared) throw (); | |
3416 | extern int pthread_mutexattr_setpshared (pthread_mutexattr_t *__attr, | |
3417 | int __pshared) throw (); | |
3418 | extern int pthread_mutexattr_settype (pthread_mutexattr_t *__attr, int __kind) | |
3419 | throw (); | |
3420 | extern int pthread_mutexattr_gettype (__const pthread_mutexattr_t *__restrict | |
3421 | __attr, int *__restrict __kind) throw (); | |
3422 | extern int pthread_cond_init (pthread_cond_t *__restrict __cond, | |
3423 | __const pthread_condattr_t *__restrict | |
3424 | __cond_attr) throw (); | |
3425 | extern int pthread_cond_destroy (pthread_cond_t *__cond) throw (); | |
3426 | extern int pthread_cond_signal (pthread_cond_t *__cond) throw (); | |
3427 | extern int pthread_cond_broadcast (pthread_cond_t *__cond) throw (); | |
3428 | extern int pthread_cond_wait (pthread_cond_t *__restrict __cond, | |
3429 | pthread_mutex_t *__restrict __mutex); | |
3430 | extern int pthread_cond_timedwait (pthread_cond_t *__restrict __cond, | |
3431 | pthread_mutex_t *__restrict __mutex, | |
3432 | __const struct timespec *__restrict | |
3433 | __abstime); | |
3434 | extern int pthread_condattr_init (pthread_condattr_t *__attr) throw (); | |
3435 | extern int pthread_condattr_destroy (pthread_condattr_t *__attr) throw (); | |
3436 | extern int pthread_condattr_getpshared (__const pthread_condattr_t * | |
3437 | __restrict __attr, | |
3438 | int *__restrict __pshared) throw (); | |
3439 | extern int pthread_condattr_setpshared (pthread_condattr_t *__attr, | |
3440 | int __pshared) throw (); | |
3441 | extern int pthread_rwlock_init (pthread_rwlock_t *__restrict __rwlock, | |
3442 | __const pthread_rwlockattr_t *__restrict | |
3443 | __attr) throw (); | |
3444 | extern int pthread_rwlock_destroy (pthread_rwlock_t *__rwlock) throw (); | |
3445 | extern int pthread_rwlock_rdlock (pthread_rwlock_t *__rwlock) throw (); | |
3446 | extern int pthread_rwlock_tryrdlock (pthread_rwlock_t *__rwlock) throw (); | |
3447 | extern int pthread_rwlock_timedrdlock (pthread_rwlock_t *__restrict __rwlock, | |
3448 | __const struct timespec *__restrict | |
3449 | __abstime) throw (); | |
3450 | extern int pthread_rwlock_wrlock (pthread_rwlock_t *__rwlock) throw (); | |
3451 | extern int pthread_rwlock_trywrlock (pthread_rwlock_t *__rwlock) throw (); | |
3452 | extern int pthread_rwlock_timedwrlock (pthread_rwlock_t *__restrict __rwlock, | |
3453 | __const struct timespec *__restrict | |
3454 | __abstime) throw (); | |
3455 | extern int pthread_rwlock_unlock (pthread_rwlock_t *__rwlock) throw (); | |
3456 | extern int pthread_rwlockattr_init (pthread_rwlockattr_t *__attr) throw (); | |
3457 | extern int pthread_rwlockattr_destroy (pthread_rwlockattr_t *__attr) throw (); | |
3458 | extern int pthread_rwlockattr_getpshared (__const pthread_rwlockattr_t * | |
3459 | __restrict __attr, | |
3460 | int *__restrict __pshared) throw (); | |
3461 | extern int pthread_rwlockattr_setpshared (pthread_rwlockattr_t *__attr, | |
3462 | int __pshared) throw (); | |
3463 | extern int pthread_rwlockattr_getkind_np (__const pthread_rwlockattr_t *__attr, | |
3464 | int *__pref) throw (); | |
3465 | extern int pthread_rwlockattr_setkind_np (pthread_rwlockattr_t *__attr, | |
3466 | int __pref) throw (); | |
3467 | extern int pthread_key_create (pthread_key_t *__key, | |
3468 | void (*__destr_function) (void *)) throw (); | |
3469 | extern int pthread_key_delete (pthread_key_t __key) throw (); | |
3470 | extern int pthread_setspecific (pthread_key_t __key, | |
3471 | __const void *__pointer) throw (); | |
3472 | extern void *pthread_getspecific (pthread_key_t __key) throw (); | |
3473 | extern int pthread_once (pthread_once_t *__once_control, | |
3474 | void (*__init_routine) (void)); | |
3475 | extern int pthread_setcancelstate (int __state, int *__oldstate); | |
3476 | extern int pthread_setcanceltype (int __type, int *__oldtype); | |
3477 | extern int pthread_cancel (pthread_t __cancelthread); | |
3478 | extern void pthread_testcancel (void); | |
3479 | extern void _pthread_cleanup_push (struct _pthread_cleanup_buffer *__buffer, | |
3480 | void (*__routine) (void *), | |
3481 | void *__arg) throw (); | |
3482 | extern void _pthread_cleanup_pop (struct _pthread_cleanup_buffer *__buffer, | |
3483 | int __execute) throw (); | |
3484 | extern void _pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer, | |
3485 | void (*__routine) (void *), | |
3486 | void *__arg) throw (); | |
3487 | extern void __pthread_cleanup_push_defer (struct _pthread_cleanup_buffer *__buffer, | |
3488 | void (*__routine) (void *), | |
3489 | void *__arg) throw (); | |
3490 | extern void _pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer, | |
3491 | int __execute) throw (); | |
3492 | extern void __pthread_cleanup_pop_restore (struct _pthread_cleanup_buffer *__buffer, | |
3493 | int __execute) throw (); | |
3494 | extern int pthread_sigmask (int __how, | |
3495 | __const __sigset_t *__restrict __newmask, | |
3496 | __sigset_t *__restrict __oldmask)throw (); | |
3497 | extern int pthread_kill (pthread_t __threadid, int __signo) throw (); | |
3498 | extern int pthread_atfork (void (*__prepare) (void), | |
3499 | void (*__parent) (void), | |
3500 | void (*__child) (void)) throw (); | |
3501 | extern void pthread_kill_other_threads_np (void) throw (); | |
3502 | } | |
3503 | typedef struct { | |
3504 | __off_t __pos; | |
3505 | } __STDIO_fpos_t; | |
3506 | typedef struct { | |
3507 | __off64_t __pos; | |
3508 | } __STDIO_fpos64_t; | |
3509 | typedef __off64_t __offmax_t; | |
3510 | struct __STDIO_FILE_STRUCT { | |
3511 | unsigned short __modeflags; | |
3512 | unsigned char __ungot[2]; | |
3513 | int __filedes; | |
3514 | unsigned char *__bufstart; | |
3515 | unsigned char *__bufend; | |
3516 | unsigned char *__bufpos; | |
3517 | unsigned char *__bufread; | |
3518 | unsigned char *__bufgetc_u; | |
3519 | unsigned char *__bufputc_u; | |
3520 | struct __STDIO_FILE_STRUCT *__nextopen; | |
3521 | int __user_locking; | |
3522 | pthread_mutex_t __lock; | |
3523 | }; | |
3524 | extern int __fgetc_unlocked(FILE *__stream); | |
3525 | extern int __fputc_unlocked(int __c, FILE *__stream); | |
3526 | extern FILE *__stdin; | |
3527 | extern FILE *__stdout; | |
3528 | typedef __builtin_va_list __gnuc_va_list; | |
3529 | typedef __STDIO_fpos_t fpos_t; | |
3530 | typedef __STDIO_fpos64_t fpos64_t; | |
3531 | extern FILE *stdin; | |
3532 | extern FILE *stdout; | |
3533 | extern FILE *stderr; | |
3534 | extern int remove (__const char *__filename) throw (); | |
3535 | extern int rename (__const char *__old, __const char *__new) throw (); | |
3536 | extern FILE *tmpfile (void) ; | |
3537 | extern FILE *tmpfile64 (void) ; | |
3538 | extern char *tmpnam (char *__s) throw () ; | |
3539 | extern char *tmpnam_r (char *__s) throw () ; | |
3540 | extern char *tempnam (__const char *__dir, __const char *__pfx) | |
3541 | throw () __attribute__ ((__malloc__)) ; | |
3542 | extern int fclose (FILE *__stream); | |
3543 | extern int fflush (FILE *__stream); | |
3544 | extern int fflush_unlocked (FILE *__stream); | |
3545 | extern int fcloseall (void); | |
3546 | extern FILE *fopen (__const char *__restrict __filename, | |
3547 | __const char *__restrict __modes) ; | |
3548 | extern FILE *freopen (__const char *__restrict __filename, | |
3549 | __const char *__restrict __modes, | |
3550 | FILE *__restrict __stream) ; | |
3551 | extern FILE *fopen64 (__const char *__restrict __filename, | |
3552 | __const char *__restrict __modes) ; | |
3553 | extern FILE *freopen64 (__const char *__restrict __filename, | |
3554 | __const char *__restrict __modes, | |
3555 | FILE *__restrict __stream) ; | |
3556 | extern FILE *fdopen (int __fd, __const char *__modes) throw () ; | |
3557 | extern void setbuf (FILE *__restrict __stream, char *__restrict __buf) throw (); | |
3558 | extern int setvbuf (FILE *__restrict __stream, char *__restrict __buf, | |
3559 | int __modes, size_t __n) throw (); | |
3560 | extern void setbuffer (FILE *__restrict __stream, char *__restrict __buf, | |
3561 | size_t __size) throw (); | |
3562 | extern void setlinebuf (FILE *__stream) throw (); | |
3563 | extern int fprintf (FILE *__restrict __stream, | |
3564 | __const char *__restrict __format, ...); | |
3565 | extern int printf (__const char *__restrict __format, ...); | |
3566 | extern int sprintf (char *__restrict __s, | |
3567 | __const char *__restrict __format, ...) throw (); | |
3568 | extern int vfprintf (FILE *__restrict __s, __const char *__restrict __format, | |
3569 | __gnuc_va_list __arg); | |
3570 | extern int vprintf (__const char *__restrict __format, __gnuc_va_list __arg); | |
3571 | extern int vsprintf (char *__restrict __s, __const char *__restrict __format, | |
3572 | __gnuc_va_list __arg) throw (); | |
3573 | extern int snprintf (char *__restrict __s, size_t __maxlen, | |
3574 | __const char *__restrict __format, ...) | |
3575 | throw () __attribute__ ((__format__ (__printf__, 3, 4))); | |
3576 | extern int vsnprintf (char *__restrict __s, size_t __maxlen, | |
3577 | __const char *__restrict __format, __gnuc_va_list __arg) | |
3578 | throw () __attribute__ ((__format__ (__printf__, 3, 0))); | |
3579 | extern int vasprintf (char **__restrict __ptr, __const char *__restrict __f, | |
3580 | __gnuc_va_list __arg) | |
3581 | throw () __attribute__ ((__format__ (__printf__, 2, 0))) ; | |
3582 | extern int asprintf (char **__restrict __ptr, | |
3583 | __const char *__restrict __fmt, ...) | |
3584 | throw () __attribute__ ((__format__ (__printf__, 2, 3))) ; | |
3585 | extern int vdprintf (int __fd, __const char *__restrict __fmt, | |
3586 | __gnuc_va_list __arg) | |
3587 | __attribute__ ((__format__ (__printf__, 2, 0))); | |
3588 | extern int dprintf (int __fd, __const char *__restrict __fmt, ...) | |
3589 | __attribute__ ((__format__ (__printf__, 2, 3))); | |
3590 | extern int fscanf (FILE *__restrict __stream, | |
3591 | __const char *__restrict __format, ...) ; | |
3592 | extern int scanf (__const char *__restrict __format, ...) ; | |
3593 | extern int sscanf (__const char *__restrict __s, | |
3594 | __const char *__restrict __format, ...) throw (); | |
3595 | extern int vfscanf (FILE *__restrict __s, __const char *__restrict __format, | |
3596 | __gnuc_va_list __arg) | |
3597 | __attribute__ ((__format__ (__scanf__, 2, 0))) ; | |
3598 | extern int vscanf (__const char *__restrict __format, __gnuc_va_list __arg) | |
3599 | __attribute__ ((__format__ (__scanf__, 1, 0))) ; | |
3600 | extern int vsscanf (__const char *__restrict __s, | |
3601 | __const char *__restrict __format, __gnuc_va_list __arg) | |
3602 | throw () __attribute__ ((__format__ (__scanf__, 2, 0))); | |
3603 | extern int fgetc (FILE *__stream); | |
3604 | extern int getc (FILE *__stream); | |
3605 | extern int getchar (void); | |
3606 | extern int getc_unlocked (FILE *__stream); | |
3607 | extern int getchar_unlocked (void); | |
3608 | extern int fgetc_unlocked (FILE *__stream); | |
3609 | extern int fputc (int __c, FILE *__stream); | |
3610 | extern int putc (int __c, FILE *__stream); | |
3611 | extern int putchar (int __c); | |
3612 | extern int fputc_unlocked (int __c, FILE *__stream); | |
3613 | extern int putc_unlocked (int __c, FILE *__stream); | |
3614 | extern int putchar_unlocked (int __c); | |
3615 | extern int getw (FILE *__stream); | |
3616 | extern int putw (int __w, FILE *__stream); | |
3617 | extern char *fgets (char *__restrict __s, int __n, FILE *__restrict __stream) | |
3618 | ; | |
3619 | extern char *gets (char *__s) ; | |
3620 | extern char *fgets_unlocked (char *__restrict __s, int __n, | |
3621 | FILE *__restrict __stream) ; | |
3622 | extern __ssize_t getdelim (char **__restrict __lineptr, | |
3623 | size_t *__restrict __n, int __delimiter, | |
3624 | FILE *__restrict __stream) ; | |
3625 | extern __ssize_t getline (char **__restrict __lineptr, | |
3626 | size_t *__restrict __n, | |
3627 | FILE *__restrict __stream) ; | |
3628 | extern int fputs (__const char *__restrict __s, FILE *__restrict __stream); | |
3629 | extern int puts (__const char *__s); | |
3630 | extern int ungetc (int __c, FILE *__stream); | |
3631 | extern size_t fread (void *__restrict __ptr, size_t __size, | |
3632 | size_t __n, FILE *__restrict __stream) ; | |
3633 | extern size_t fwrite (__const void *__restrict __ptr, size_t __size, | |
3634 | size_t __n, FILE *__restrict __s) ; | |
3635 | extern int fputs_unlocked (__const char *__restrict __s, | |
3636 | FILE *__restrict __stream); | |
3637 | extern size_t fread_unlocked (void *__restrict __ptr, size_t __size, | |
3638 | size_t __n, FILE *__restrict __stream) ; | |
3639 | extern size_t fwrite_unlocked (__const void *__restrict __ptr, size_t __size, | |
3640 | size_t __n, FILE *__restrict __stream) ; | |
3641 | extern int fseek (FILE *__stream, long int __off, int __whence); | |
3642 | extern long int ftell (FILE *__stream) ; | |
3643 | extern void rewind (FILE *__stream); | |
3644 | extern int fseeko (FILE *__stream, __off_t __off, int __whence); | |
3645 | extern __off_t ftello (FILE *__stream) ; | |
3646 | extern int fgetpos (FILE *__restrict __stream, fpos_t *__restrict __pos); | |
3647 | extern int fsetpos (FILE *__stream, __const fpos_t *__pos); | |
3648 | extern int fseeko64 (FILE *__stream, __off64_t __off, int __whence); | |
3649 | extern __off64_t ftello64 (FILE *__stream) ; | |
3650 | extern int fgetpos64 (FILE *__restrict __stream, fpos64_t *__restrict __pos); | |
3651 | extern int fsetpos64 (FILE *__stream, __const fpos64_t *__pos); | |
3652 | extern void clearerr (FILE *__stream) throw (); | |
3653 | extern int feof (FILE *__stream) throw () ; | |
3654 | extern int ferror (FILE *__stream) throw () ; | |
3655 | extern void clearerr_unlocked (FILE *__stream) throw (); | |
3656 | extern int feof_unlocked (FILE *__stream) throw () ; | |
3657 | extern int ferror_unlocked (FILE *__stream) throw () ; | |
3658 | extern void perror (__const char *__s); | |
3659 | extern int fileno (FILE *__stream) throw () ; | |
3660 | extern int fileno_unlocked (FILE *__stream) throw () ; | |
3661 | extern FILE *popen (__const char *__command, __const char *__modes) ; | |
3662 | extern int pclose (FILE *__stream); | |
3663 | extern char *ctermid (char *__s) throw (); | |
3664 | extern char *cuserid (char *__s); | |
3665 | extern void flockfile (FILE *__stream) throw (); | |
3666 | extern int ftrylockfile (FILE *__stream) throw () ; | |
3667 | extern void funlockfile (FILE *__stream) throw (); | |
3668 | } | |
3669 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
3670 | using ::FILE; | |
3671 | using ::fpos_t; | |
3672 | using ::clearerr; | |
3673 | using ::fclose; | |
3674 | using ::feof; | |
3675 | using ::ferror; | |
3676 | using ::fflush; | |
3677 | using ::fgetc; | |
3678 | using ::fgetpos; | |
3679 | using ::fgets; | |
3680 | using ::fopen; | |
3681 | using ::fprintf; | |
3682 | using ::fputc; | |
3683 | using ::fputs; | |
3684 | using ::fread; | |
3685 | using ::freopen; | |
3686 | using ::fscanf; | |
3687 | using ::fseek; | |
3688 | using ::fsetpos; | |
3689 | using ::ftell; | |
3690 | using ::fwrite; | |
3691 | using ::getc; | |
3692 | using ::getchar; | |
3693 | using ::gets; | |
3694 | using ::perror; | |
3695 | using ::printf; | |
3696 | using ::putc; | |
3697 | using ::putchar; | |
3698 | using ::puts; | |
3699 | using ::remove; | |
3700 | using ::rename; | |
3701 | using ::rewind; | |
3702 | using ::scanf; | |
3703 | using ::setbuf; | |
3704 | using ::setvbuf; | |
3705 | using ::sprintf; | |
3706 | using ::sscanf; | |
3707 | using ::tmpfile; | |
3708 | using ::tmpnam; | |
3709 | using ::ungetc; | |
3710 | using ::vfprintf; | |
3711 | using ::vprintf; | |
3712 | using ::vsprintf; | |
3713 | } | |
3714 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
3715 | template<typename _CharT> | |
3716 | struct _Char_types | |
3717 | { | |
3718 | typedef unsigned long int_type; | |
3719 | typedef std::streampos pos_type; | |
3720 | typedef std::streamoff off_type; | |
3721 | typedef std::mbstate_t state_type; | |
3722 | }; | |
3723 | template<typename _CharT> | |
3724 | struct char_traits | |
3725 | { | |
3726 | typedef _CharT char_type; | |
3727 | typedef typename _Char_types<_CharT>::int_type int_type; | |
3728 | typedef typename _Char_types<_CharT>::pos_type pos_type; | |
3729 | typedef typename _Char_types<_CharT>::off_type off_type; | |
3730 | typedef typename _Char_types<_CharT>::state_type state_type; | |
3731 | static void | |
3732 | assign(char_type& __c1, const char_type& __c2) | |
3733 | { __c1 = __c2; } | |
3734 | static bool | |
3735 | eq(const char_type& __c1, const char_type& __c2) | |
3736 | { return __c1 == __c2; } | |
3737 | static bool | |
3738 | lt(const char_type& __c1, const char_type& __c2) | |
3739 | { return __c1 < __c2; } | |
3740 | static int | |
3741 | compare(const char_type* __s1, const char_type* __s2, std::size_t __n); | |
3742 | static std::size_t | |
3743 | length(const char_type* __s); | |
3744 | static const char_type* | |
3745 | find(const char_type* __s, std::size_t __n, const char_type& __a); | |
3746 | static char_type* | |
3747 | move(char_type* __s1, const char_type* __s2, std::size_t __n); | |
3748 | static char_type* | |
3749 | copy(char_type* __s1, const char_type* __s2, std::size_t __n); | |
3750 | static char_type* | |
3751 | assign(char_type* __s, std::size_t __n, char_type __a); | |
3752 | static char_type | |
3753 | to_char_type(const int_type& __c) | |
3754 | { return static_cast<char_type>(__c); } | |
3755 | static int_type | |
3756 | to_int_type(const char_type& __c) | |
3757 | { return static_cast<int_type>(__c); } | |
3758 | static bool | |
3759 | eq_int_type(const int_type& __c1, const int_type& __c2) | |
3760 | { return __c1 == __c2; } | |
3761 | static int_type | |
3762 | eof() | |
3763 | { return static_cast<int_type>((-1)); } | |
3764 | static int_type | |
3765 | not_eof(const int_type& __c) | |
3766 | { return !eq_int_type(__c, eof()) ? __c : to_int_type(char_type()); } | |
3767 | }; | |
3768 | template<typename _CharT> | |
3769 | int | |
3770 | char_traits<_CharT>:: | |
3771 | compare(const char_type* __s1, const char_type* __s2, std::size_t __n) | |
3772 | { | |
3773 | for (std::size_t __i = 0; __i < __n; ++__i) | |
3774 | if (lt(__s1[__i], __s2[__i])) | |
3775 | return -1; | |
3776 | else if (lt(__s2[__i], __s1[__i])) | |
3777 | return 1; | |
3778 | return 0; | |
3779 | } | |
3780 | template<typename _CharT> | |
3781 | std::size_t | |
3782 | char_traits<_CharT>:: | |
3783 | length(const char_type* __p) | |
3784 | { | |
3785 | std::size_t __i = 0; | |
3786 | while (!eq(__p[__i], char_type())) | |
3787 | ++__i; | |
3788 | return __i; | |
3789 | } | |
3790 | template<typename _CharT> | |
3791 | const typename char_traits<_CharT>::char_type* | |
3792 | char_traits<_CharT>:: | |
3793 | find(const char_type* __s, std::size_t __n, const char_type& __a) | |
3794 | { | |
3795 | for (std::size_t __i = 0; __i < __n; ++__i) | |
3796 | if (eq(__s[__i], __a)) | |
3797 | return __s + __i; | |
3798 | return 0; | |
3799 | } | |
3800 | template<typename _CharT> | |
3801 | typename char_traits<_CharT>::char_type* | |
3802 | char_traits<_CharT>:: | |
3803 | move(char_type* __s1, const char_type* __s2, std::size_t __n) | |
3804 | { | |
3805 | return static_cast<_CharT*>(__builtin_memmove(__s1, __s2, | |
3806 | __n * sizeof(char_type))); | |
3807 | } | |
3808 | template<typename _CharT> | |
3809 | typename char_traits<_CharT>::char_type* | |
3810 | char_traits<_CharT>:: | |
3811 | copy(char_type* __s1, const char_type* __s2, std::size_t __n) | |
3812 | { | |
3813 | std::copy(__s2, __s2 + __n, __s1); | |
3814 | return __s1; | |
3815 | } | |
3816 | template<typename _CharT> | |
3817 | typename char_traits<_CharT>::char_type* | |
3818 | char_traits<_CharT>:: | |
3819 | assign(char_type* __s, std::size_t __n, char_type __a) | |
3820 | { | |
3821 | std::fill_n(__s, __n, __a); | |
3822 | return __s; | |
3823 | } | |
3824 | } | |
3825 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
3826 | template<class _CharT> | |
3827 | struct char_traits : public __gnu_cxx::char_traits<_CharT> | |
3828 | { }; | |
3829 | template<> | |
3830 | struct char_traits<char> | |
3831 | { | |
3832 | typedef char char_type; | |
3833 | typedef int int_type; | |
3834 | typedef streampos pos_type; | |
3835 | typedef streamoff off_type; | |
3836 | typedef mbstate_t state_type; | |
3837 | static void | |
3838 | assign(char_type& __c1, const char_type& __c2) | |
3839 | { __c1 = __c2; } | |
3840 | static bool | |
3841 | eq(const char_type& __c1, const char_type& __c2) | |
3842 | { return __c1 == __c2; } | |
3843 | static bool | |
3844 | lt(const char_type& __c1, const char_type& __c2) | |
3845 | { return __c1 < __c2; } | |
3846 | static int | |
3847 | compare(const char_type* __s1, const char_type* __s2, size_t __n) | |
3848 | { return __builtin_memcmp(__s1, __s2, __n); } | |
3849 | static size_t | |
3850 | length(const char_type* __s) | |
3851 | { return __builtin_strlen(__s); } | |
3852 | static const char_type* | |
3853 | find(const char_type* __s, size_t __n, const char_type& __a) | |
3854 | { return static_cast<const char_type*>(__builtin_memchr(__s, __a, __n)); } | |
3855 | static char_type* | |
3856 | move(char_type* __s1, const char_type* __s2, size_t __n) | |
3857 | { return static_cast<char_type*>(__builtin_memmove(__s1, __s2, __n)); } | |
3858 | static char_type* | |
3859 | copy(char_type* __s1, const char_type* __s2, size_t __n) | |
3860 | { return static_cast<char_type*>(__builtin_memcpy(__s1, __s2, __n)); } | |
3861 | static char_type* | |
3862 | assign(char_type* __s, size_t __n, char_type __a) | |
3863 | { return static_cast<char_type*>(__builtin_memset(__s, __a, __n)); } | |
3864 | static char_type | |
3865 | to_char_type(const int_type& __c) | |
3866 | { return static_cast<char_type>(__c); } | |
3867 | static int_type | |
3868 | to_int_type(const char_type& __c) | |
3869 | { return static_cast<int_type>(static_cast<unsigned char>(__c)); } | |
3870 | static bool | |
3871 | eq_int_type(const int_type& __c1, const int_type& __c2) | |
3872 | { return __c1 == __c2; } | |
3873 | static int_type | |
3874 | eof() { return static_cast<int_type>((-1)); } | |
3875 | static int_type | |
3876 | not_eof(const int_type& __c) | |
3877 | { return (__c == eof()) ? 0 : __c; } | |
3878 | }; | |
3879 | } | |
3880 | extern "C" { | |
3881 | struct lconv | |
3882 | { | |
3883 | char *decimal_point; | |
3884 | char *thousands_sep; | |
3885 | char *grouping; | |
3886 | char *int_curr_symbol; | |
3887 | char *currency_symbol; | |
3888 | char *mon_decimal_point; | |
3889 | char *mon_thousands_sep; | |
3890 | char *mon_grouping; | |
3891 | char *positive_sign; | |
3892 | char *negative_sign; | |
3893 | char int_frac_digits; | |
3894 | char frac_digits; | |
3895 | char p_cs_precedes; | |
3896 | char p_sep_by_space; | |
3897 | char n_cs_precedes; | |
3898 | char n_sep_by_space; | |
3899 | char p_sign_posn; | |
3900 | char n_sign_posn; | |
3901 | char int_p_cs_precedes; | |
3902 | char int_p_sep_by_space; | |
3903 | char int_n_cs_precedes; | |
3904 | char int_n_sep_by_space; | |
3905 | char int_p_sign_posn; | |
3906 | char int_n_sign_posn; | |
3907 | }; | |
3908 | extern char *setlocale (int __category, __const char *__locale) throw (); | |
3909 | extern struct lconv *localeconv (void) throw (); | |
3910 | } | |
3911 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
3912 | using ::lconv; | |
3913 | using ::setlocale; | |
3914 | using ::localeconv; | |
3915 | } | |
3916 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
3917 | typedef int* __c_locale; | |
3918 | inline int | |
3919 | __convert_from_v(const __c_locale&, char* __out, | |
3920 | const int __size __attribute__((__unused__)), | |
3921 | const char* __fmt, ...) | |
3922 | { | |
3923 | char* __old = std::setlocale(1, __null); | |
3924 | char* __sav = __null; | |
3925 | if (__builtin_strcmp(__old, "C")) | |
3926 | { | |
3927 | const size_t __len = __builtin_strlen(__old) + 1; | |
3928 | __sav = new char[__len]; | |
3929 | __builtin_memcpy(__sav, __old, __len); | |
3930 | std::setlocale(1, "C"); | |
3931 | } | |
3932 | __builtin_va_list __args; | |
3933 | __builtin_va_start(__args, __fmt); | |
3934 | const int __ret = __builtin_vsprintf(__out, __fmt, __args); | |
3935 | __builtin_va_end(__args); | |
3936 | if (__sav) | |
3937 | { | |
3938 | std::setlocale(1, __sav); | |
3939 | delete [] __sav; | |
3940 | } | |
3941 | return __ret; | |
3942 | } | |
3943 | } | |
3944 | extern "C" { | |
3945 | enum | |
3946 | { | |
3947 | _ISupper = (1 << (0)), | |
3948 | _ISlower = (1 << (1)), | |
3949 | _ISalpha = (1 << (2)), | |
3950 | _ISdigit = (1 << (3)), | |
3951 | _ISxdigit = (1 << (4)), | |
3952 | _ISspace = (1 << (5)), | |
3953 | _ISprint = (1 << (6)), | |
3954 | _ISgraph = (1 << (7)), | |
3955 | _ISblank = (1 << (8)), | |
3956 | _IScntrl = (1 << (9)), | |
3957 | _ISpunct = (1 << (10)), | |
3958 | _ISalnum = (1 << (11)) | |
3959 | }; | |
3960 | typedef __uint16_t __ctype_mask_t; | |
3961 | typedef __int16_t __ctype_touplow_t; | |
3962 | extern const __ctype_mask_t *__C_ctype_b; | |
3963 | extern const __ctype_touplow_t *__C_ctype_toupper; | |
3964 | extern const __ctype_touplow_t *__C_ctype_tolower; | |
3965 | extern const __ctype_mask_t *__ctype_b; | |
3966 | extern const __ctype_touplow_t *__ctype_toupper; | |
3967 | extern const __ctype_touplow_t *__ctype_tolower; | |
3968 | extern int isalnum (int) throw (); | |
3969 | extern int isalpha (int) throw (); | |
3970 | extern int iscntrl (int) throw (); | |
3971 | extern int isdigit (int) throw (); | |
3972 | extern int islower (int) throw (); | |
3973 | extern int isgraph (int) throw (); | |
3974 | extern int isprint (int) throw (); | |
3975 | extern int ispunct (int) throw (); | |
3976 | extern int isspace (int) throw (); | |
3977 | extern int isupper (int) throw (); | |
3978 | extern int isxdigit (int) throw (); | |
3979 | extern int tolower (int __c) throw (); | |
3980 | extern int toupper (int __c) throw (); | |
3981 | extern int isblank (int) throw (); | |
3982 | extern int isctype (int __c, int __mask) throw (); | |
3983 | extern int isascii (int __c) throw (); | |
3984 | extern int toascii (int __c) throw (); | |
3985 | extern int _toupper (int) throw (); | |
3986 | extern int _tolower (int) throw (); | |
3987 | } | |
3988 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
3989 | using ::isalnum; | |
3990 | using ::isalpha; | |
3991 | using ::iscntrl; | |
3992 | using ::isdigit; | |
3993 | using ::isgraph; | |
3994 | using ::islower; | |
3995 | using ::isprint; | |
3996 | using ::ispunct; | |
3997 | using ::isspace; | |
3998 | using ::isupper; | |
3999 | using ::isxdigit; | |
4000 | using ::tolower; | |
4001 | using ::toupper; | |
4002 | } | |
4003 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
4004 | class locale; | |
4005 | template<typename _Facet> | |
4006 | bool | |
4007 | has_facet(const locale&) throw(); | |
4008 | template<typename _Facet> | |
4009 | const _Facet& | |
4010 | use_facet(const locale&); | |
4011 | template<typename _CharT> | |
4012 | bool | |
4013 | isspace(_CharT, const locale&); | |
4014 | template<typename _CharT> | |
4015 | bool | |
4016 | isprint(_CharT, const locale&); | |
4017 | template<typename _CharT> | |
4018 | bool | |
4019 | iscntrl(_CharT, const locale&); | |
4020 | template<typename _CharT> | |
4021 | bool | |
4022 | isupper(_CharT, const locale&); | |
4023 | template<typename _CharT> | |
4024 | bool | |
4025 | islower(_CharT, const locale&); | |
4026 | template<typename _CharT> | |
4027 | bool | |
4028 | isalpha(_CharT, const locale&); | |
4029 | template<typename _CharT> | |
4030 | bool | |
4031 | isdigit(_CharT, const locale&); | |
4032 | template<typename _CharT> | |
4033 | bool | |
4034 | ispunct(_CharT, const locale&); | |
4035 | template<typename _CharT> | |
4036 | bool | |
4037 | isxdigit(_CharT, const locale&); | |
4038 | template<typename _CharT> | |
4039 | bool | |
4040 | isalnum(_CharT, const locale&); | |
4041 | template<typename _CharT> | |
4042 | bool | |
4043 | isgraph(_CharT, const locale&); | |
4044 | template<typename _CharT> | |
4045 | _CharT | |
4046 | toupper(_CharT, const locale&); | |
4047 | template<typename _CharT> | |
4048 | _CharT | |
4049 | tolower(_CharT, const locale&); | |
4050 | class ctype_base; | |
4051 | template<typename _CharT> | |
4052 | class ctype; | |
4053 | template<> class ctype<char>; | |
4054 | template<typename _CharT> | |
4055 | class ctype_byname; | |
4056 | class codecvt_base; | |
4057 | template<typename _InternT, typename _ExternT, typename _StateT> | |
4058 | class codecvt; | |
4059 | template<> class codecvt<char, char, mbstate_t>; | |
4060 | template<typename _InternT, typename _ExternT, typename _StateT> | |
4061 | class codecvt_byname; | |
4062 | template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
4063 | class num_get; | |
4064 | template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
4065 | class num_put; | |
4066 | template<typename _CharT> class numpunct; | |
4067 | template<typename _CharT> class numpunct_byname; | |
4068 | template<typename _CharT> | |
4069 | class collate; | |
4070 | template<typename _CharT> class | |
4071 | collate_byname; | |
4072 | class time_base; | |
4073 | template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
4074 | class time_get; | |
4075 | template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
4076 | class time_get_byname; | |
4077 | template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
4078 | class time_put; | |
4079 | template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
4080 | class time_put_byname; | |
4081 | class money_base; | |
4082 | template<typename _CharT, typename _InIter = istreambuf_iterator<_CharT> > | |
4083 | class money_get; | |
4084 | template<typename _CharT, typename _OutIter = ostreambuf_iterator<_CharT> > | |
4085 | class money_put; | |
4086 | template<typename _CharT, bool _Intl = false> | |
4087 | class moneypunct; | |
4088 | template<typename _CharT, bool _Intl = false> | |
4089 | class moneypunct_byname; | |
4090 | class messages_base; | |
4091 | template<typename _CharT> | |
4092 | class messages; | |
4093 | template<typename _CharT> | |
4094 | class messages_byname; | |
4095 | } | |
4096 | extern "C" { | |
4097 | typedef __ssize_t ssize_t; | |
4098 | typedef __gid_t gid_t; | |
4099 | typedef __uid_t uid_t; | |
4100 | typedef __off_t off_t; | |
4101 | typedef __off64_t off64_t; | |
4102 | typedef __useconds_t useconds_t; | |
4103 | typedef __socklen_t socklen_t; | |
4104 | extern int access (__const char *__name, int __type) throw () __attribute__ ((__nonnull__ (1))); | |
4105 | extern __off_t lseek (int __fd, __off_t __offset, int __whence) throw (); | |
4106 | extern __off64_t lseek64 (int __fd, __off64_t __offset, int __whence) | |
4107 | throw (); | |
4108 | extern int close (int __fd); | |
4109 | extern ssize_t read (int __fd, void *__buf, size_t __nbytes) ; | |
4110 | extern ssize_t write (int __fd, __const void *__buf, size_t __n) ; | |
4111 | extern ssize_t pread (int __fd, void *__buf, size_t __nbytes, | |
4112 | __off_t __offset) ; | |
4113 | extern ssize_t pwrite (int __fd, __const void *__buf, size_t __n, | |
4114 | __off_t __offset) ; | |
4115 | extern ssize_t pread64 (int __fd, void *__buf, size_t __nbytes, | |
4116 | __off64_t __offset) ; | |
4117 | extern ssize_t pwrite64 (int __fd, __const void *__buf, size_t __n, | |
4118 | __off64_t __offset) ; | |
4119 | extern int pipe (int __pipedes[2]) throw () ; | |
4120 | extern unsigned int alarm (unsigned int __seconds) throw (); | |
4121 | extern unsigned int sleep (unsigned int __seconds); | |
4122 | extern __useconds_t ualarm (__useconds_t __value, __useconds_t __interval) | |
4123 | throw (); | |
4124 | extern int usleep (__useconds_t __useconds); | |
4125 | extern int pause (void); | |
4126 | extern int chown (__const char *__file, __uid_t __owner, __gid_t __group) | |
4127 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4128 | extern int fchown (int __fd, __uid_t __owner, __gid_t __group) throw () ; | |
4129 | extern int lchown (__const char *__file, __uid_t __owner, __gid_t __group) | |
4130 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4131 | extern int chdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) ; | |
4132 | extern int fchdir (int __fd) throw () ; | |
4133 | extern char *getcwd (char *__buf, size_t __size) throw () ; | |
4134 | extern char *get_current_dir_name (void) throw (); | |
4135 | extern int dup (int __fd) throw () ; | |
4136 | extern int dup2 (int __fd, int __fd2) throw (); | |
4137 | extern char **__environ; | |
4138 | extern char **environ; | |
4139 | extern int execve (__const char *__path, char *__const __argv[], | |
4140 | char *__const __envp[]) throw () __attribute__ ((__nonnull__ (1))); | |
4141 | extern int execv (__const char *__path, char *__const __argv[]) | |
4142 | throw () __attribute__ ((__nonnull__ (1))); | |
4143 | extern int execle (__const char *__path, __const char *__arg, ...) | |
4144 | throw () __attribute__ ((__nonnull__ (1))); | |
4145 | extern int execl (__const char *__path, __const char *__arg, ...) | |
4146 | throw () __attribute__ ((__nonnull__ (1))); | |
4147 | extern int execvp (__const char *__file, char *__const __argv[]) | |
4148 | throw () __attribute__ ((__nonnull__ (1))); | |
4149 | extern int execlp (__const char *__file, __const char *__arg, ...) | |
4150 | throw () __attribute__ ((__nonnull__ (1))); | |
4151 | extern int nice (int __inc) throw () ; | |
4152 | extern void _exit (int __status) __attribute__ ((__noreturn__)); | |
4153 | enum | |
4154 | { | |
4155 | _PC_LINK_MAX, | |
4156 | _PC_MAX_CANON, | |
4157 | _PC_MAX_INPUT, | |
4158 | _PC_NAME_MAX, | |
4159 | _PC_PATH_MAX, | |
4160 | _PC_PIPE_BUF, | |
4161 | _PC_CHOWN_RESTRICTED, | |
4162 | _PC_NO_TRUNC, | |
4163 | _PC_VDISABLE, | |
4164 | _PC_SYNC_IO, | |
4165 | _PC_ASYNC_IO, | |
4166 | _PC_PRIO_IO, | |
4167 | _PC_SOCK_MAXBUF, | |
4168 | _PC_FILESIZEBITS, | |
4169 | _PC_REC_INCR_XFER_SIZE, | |
4170 | _PC_REC_MAX_XFER_SIZE, | |
4171 | _PC_REC_MIN_XFER_SIZE, | |
4172 | _PC_REC_XFER_ALIGN, | |
4173 | _PC_ALLOC_SIZE_MIN, | |
4174 | _PC_SYMLINK_MAX, | |
4175 | _PC_2_SYMLINKS | |
4176 | }; | |
4177 | enum | |
4178 | { | |
4179 | _SC_ARG_MAX, | |
4180 | _SC_CHILD_MAX, | |
4181 | _SC_CLK_TCK, | |
4182 | _SC_NGROUPS_MAX, | |
4183 | _SC_OPEN_MAX, | |
4184 | _SC_STREAM_MAX, | |
4185 | _SC_TZNAME_MAX, | |
4186 | _SC_JOB_CONTROL, | |
4187 | _SC_SAVED_IDS, | |
4188 | _SC_REALTIME_SIGNALS, | |
4189 | _SC_PRIORITY_SCHEDULING, | |
4190 | _SC_TIMERS, | |
4191 | _SC_ASYNCHRONOUS_IO, | |
4192 | _SC_PRIORITIZED_IO, | |
4193 | _SC_SYNCHRONIZED_IO, | |
4194 | _SC_FSYNC, | |
4195 | _SC_MAPPED_FILES, | |
4196 | _SC_MEMLOCK, | |
4197 | _SC_MEMLOCK_RANGE, | |
4198 | _SC_MEMORY_PROTECTION, | |
4199 | _SC_MESSAGE_PASSING, | |
4200 | _SC_SEMAPHORES, | |
4201 | _SC_SHARED_MEMORY_OBJECTS, | |
4202 | _SC_AIO_LISTIO_MAX, | |
4203 | _SC_AIO_MAX, | |
4204 | _SC_AIO_PRIO_DELTA_MAX, | |
4205 | _SC_DELAYTIMER_MAX, | |
4206 | _SC_MQ_OPEN_MAX, | |
4207 | _SC_MQ_PRIO_MAX, | |
4208 | _SC_VERSION, | |
4209 | _SC_PAGESIZE, | |
4210 | _SC_RTSIG_MAX, | |
4211 | _SC_SEM_NSEMS_MAX, | |
4212 | _SC_SEM_VALUE_MAX, | |
4213 | _SC_SIGQUEUE_MAX, | |
4214 | _SC_TIMER_MAX, | |
4215 | _SC_BC_BASE_MAX, | |
4216 | _SC_BC_DIM_MAX, | |
4217 | _SC_BC_SCALE_MAX, | |
4218 | _SC_BC_STRING_MAX, | |
4219 | _SC_COLL_WEIGHTS_MAX, | |
4220 | _SC_EQUIV_CLASS_MAX, | |
4221 | _SC_EXPR_NEST_MAX, | |
4222 | _SC_LINE_MAX, | |
4223 | _SC_RE_DUP_MAX, | |
4224 | _SC_CHARCLASS_NAME_MAX, | |
4225 | _SC_2_VERSION, | |
4226 | _SC_2_C_BIND, | |
4227 | _SC_2_C_DEV, | |
4228 | _SC_2_FORT_DEV, | |
4229 | _SC_2_FORT_RUN, | |
4230 | _SC_2_SW_DEV, | |
4231 | _SC_2_LOCALEDEF, | |
4232 | _SC_PII, | |
4233 | _SC_PII_XTI, | |
4234 | _SC_PII_SOCKET, | |
4235 | _SC_PII_INTERNET, | |
4236 | _SC_PII_OSI, | |
4237 | _SC_POLL, | |
4238 | _SC_SELECT, | |
4239 | _SC_UIO_MAXIOV, | |
4240 | _SC_IOV_MAX = _SC_UIO_MAXIOV, | |
4241 | _SC_PII_INTERNET_STREAM, | |
4242 | _SC_PII_INTERNET_DGRAM, | |
4243 | _SC_PII_OSI_COTS, | |
4244 | _SC_PII_OSI_CLTS, | |
4245 | _SC_PII_OSI_M, | |
4246 | _SC_T_IOV_MAX, | |
4247 | _SC_THREADS, | |
4248 | _SC_THREAD_SAFE_FUNCTIONS, | |
4249 | _SC_GETGR_R_SIZE_MAX, | |
4250 | _SC_GETPW_R_SIZE_MAX, | |
4251 | _SC_LOGIN_NAME_MAX, | |
4252 | _SC_TTY_NAME_MAX, | |
4253 | _SC_THREAD_DESTRUCTOR_ITERATIONS, | |
4254 | _SC_THREAD_KEYS_MAX, | |
4255 | _SC_THREAD_STACK_MIN, | |
4256 | _SC_THREAD_THREADS_MAX, | |
4257 | _SC_THREAD_ATTR_STACKADDR, | |
4258 | _SC_THREAD_ATTR_STACKSIZE, | |
4259 | _SC_THREAD_PRIORITY_SCHEDULING, | |
4260 | _SC_THREAD_PRIO_INHERIT, | |
4261 | _SC_THREAD_PRIO_PROTECT, | |
4262 | _SC_THREAD_PROCESS_SHARED, | |
4263 | _SC_NPROCESSORS_CONF, | |
4264 | _SC_NPROCESSORS_ONLN, | |
4265 | _SC_PHYS_PAGES, | |
4266 | _SC_AVPHYS_PAGES, | |
4267 | _SC_ATEXIT_MAX, | |
4268 | _SC_PASS_MAX, | |
4269 | _SC_XOPEN_VERSION, | |
4270 | _SC_XOPEN_XCU_VERSION, | |
4271 | _SC_XOPEN_UNIX, | |
4272 | _SC_XOPEN_CRYPT, | |
4273 | _SC_XOPEN_ENH_I18N, | |
4274 | _SC_XOPEN_SHM, | |
4275 | _SC_2_CHAR_TERM, | |
4276 | _SC_2_C_VERSION, | |
4277 | _SC_2_UPE, | |
4278 | _SC_XOPEN_XPG2, | |
4279 | _SC_XOPEN_XPG3, | |
4280 | _SC_XOPEN_XPG4, | |
4281 | _SC_CHAR_BIT, | |
4282 | _SC_CHAR_MAX, | |
4283 | _SC_CHAR_MIN, | |
4284 | _SC_INT_MAX, | |
4285 | _SC_INT_MIN, | |
4286 | _SC_LONG_BIT, | |
4287 | _SC_WORD_BIT, | |
4288 | _SC_MB_LEN_MAX, | |
4289 | _SC_NZERO, | |
4290 | _SC_SSIZE_MAX, | |
4291 | _SC_SCHAR_MAX, | |
4292 | _SC_SCHAR_MIN, | |
4293 | _SC_SHRT_MAX, | |
4294 | _SC_SHRT_MIN, | |
4295 | _SC_UCHAR_MAX, | |
4296 | _SC_UINT_MAX, | |
4297 | _SC_ULONG_MAX, | |
4298 | _SC_USHRT_MAX, | |
4299 | _SC_NL_ARGMAX, | |
4300 | _SC_NL_LANGMAX, | |
4301 | _SC_NL_MSGMAX, | |
4302 | _SC_NL_NMAX, | |
4303 | _SC_NL_SETMAX, | |
4304 | _SC_NL_TEXTMAX, | |
4305 | _SC_XBS5_ILP32_OFF32, | |
4306 | _SC_XBS5_ILP32_OFFBIG, | |
4307 | _SC_XBS5_LP64_OFF64, | |
4308 | _SC_XBS5_LPBIG_OFFBIG, | |
4309 | _SC_XOPEN_LEGACY, | |
4310 | _SC_XOPEN_REALTIME, | |
4311 | _SC_XOPEN_REALTIME_THREADS, | |
4312 | _SC_ADVISORY_INFO, | |
4313 | _SC_BARRIERS, | |
4314 | _SC_BASE, | |
4315 | _SC_C_LANG_SUPPORT, | |
4316 | _SC_C_LANG_SUPPORT_R, | |
4317 | _SC_CLOCK_SELECTION, | |
4318 | _SC_CPUTIME, | |
4319 | _SC_THREAD_CPUTIME, | |
4320 | _SC_DEVICE_IO, | |
4321 | _SC_DEVICE_SPECIFIC, | |
4322 | _SC_DEVICE_SPECIFIC_R, | |
4323 | _SC_FD_MGMT, | |
4324 | _SC_FIFO, | |
4325 | _SC_PIPE, | |
4326 | _SC_FILE_ATTRIBUTES, | |
4327 | _SC_FILE_LOCKING, | |
4328 | _SC_FILE_SYSTEM, | |
4329 | _SC_MONOTONIC_CLOCK, | |
4330 | _SC_MULTI_PROCESS, | |
4331 | _SC_SINGLE_PROCESS, | |
4332 | _SC_NETWORKING, | |
4333 | _SC_READER_WRITER_LOCKS, | |
4334 | _SC_SPIN_LOCKS, | |
4335 | _SC_REGEXP, | |
4336 | _SC_REGEX_VERSION, | |
4337 | _SC_SHELL, | |
4338 | _SC_SIGNALS, | |
4339 | _SC_SPAWN, | |
4340 | _SC_SPORADIC_SERVER, | |
4341 | _SC_THREAD_SPORADIC_SERVER, | |
4342 | _SC_SYSTEM_DATABASE, | |
4343 | _SC_SYSTEM_DATABASE_R, | |
4344 | _SC_TIMEOUTS, | |
4345 | _SC_TYPED_MEMORY_OBJECTS, | |
4346 | _SC_USER_GROUPS, | |
4347 | _SC_USER_GROUPS_R, | |
4348 | _SC_2_PBS, | |
4349 | _SC_2_PBS_ACCOUNTING, | |
4350 | _SC_2_PBS_LOCATE, | |
4351 | _SC_2_PBS_MESSAGE, | |
4352 | _SC_2_PBS_TRACK, | |
4353 | _SC_SYMLOOP_MAX, | |
4354 | _SC_STREAMS, | |
4355 | _SC_2_PBS_CHECKPOINT, | |
4356 | _SC_V6_ILP32_OFF32, | |
4357 | _SC_V6_ILP32_OFFBIG, | |
4358 | _SC_V6_LP64_OFF64, | |
4359 | _SC_V6_LPBIG_OFFBIG, | |
4360 | _SC_HOST_NAME_MAX, | |
4361 | _SC_TRACE, | |
4362 | _SC_TRACE_EVENT_FILTER, | |
4363 | _SC_TRACE_INHERIT, | |
4364 | _SC_TRACE_LOG, | |
4365 | _SC_LEVEL1_ICACHE_SIZE, | |
4366 | _SC_LEVEL1_ICACHE_ASSOC, | |
4367 | _SC_LEVEL1_ICACHE_LINESIZE, | |
4368 | _SC_LEVEL1_DCACHE_SIZE, | |
4369 | _SC_LEVEL1_DCACHE_ASSOC, | |
4370 | _SC_LEVEL1_DCACHE_LINESIZE, | |
4371 | _SC_LEVEL2_CACHE_SIZE, | |
4372 | _SC_LEVEL2_CACHE_ASSOC, | |
4373 | _SC_LEVEL2_CACHE_LINESIZE, | |
4374 | _SC_LEVEL3_CACHE_SIZE, | |
4375 | _SC_LEVEL3_CACHE_ASSOC, | |
4376 | _SC_LEVEL3_CACHE_LINESIZE, | |
4377 | _SC_LEVEL4_CACHE_SIZE, | |
4378 | _SC_LEVEL4_CACHE_ASSOC, | |
4379 | _SC_LEVEL4_CACHE_LINESIZE, | |
4380 | _SC_IPV6 = _SC_LEVEL1_ICACHE_SIZE + 50, | |
4381 | _SC_RAW_SOCKETS | |
4382 | }; | |
4383 | enum | |
4384 | { | |
4385 | _CS_PATH, | |
4386 | _CS_V6_WIDTH_RESTRICTED_ENVS, | |
4387 | _CS_LFS_CFLAGS = 1000, | |
4388 | _CS_LFS_LDFLAGS, | |
4389 | _CS_LFS_LIBS, | |
4390 | _CS_LFS_LINTFLAGS, | |
4391 | _CS_LFS64_CFLAGS, | |
4392 | _CS_LFS64_LDFLAGS, | |
4393 | _CS_LFS64_LIBS, | |
4394 | _CS_LFS64_LINTFLAGS, | |
4395 | _CS_XBS5_ILP32_OFF32_CFLAGS = 1100, | |
4396 | _CS_XBS5_ILP32_OFF32_LDFLAGS, | |
4397 | _CS_XBS5_ILP32_OFF32_LIBS, | |
4398 | _CS_XBS5_ILP32_OFF32_LINTFLAGS, | |
4399 | _CS_XBS5_ILP32_OFFBIG_CFLAGS, | |
4400 | _CS_XBS5_ILP32_OFFBIG_LDFLAGS, | |
4401 | _CS_XBS5_ILP32_OFFBIG_LIBS, | |
4402 | _CS_XBS5_ILP32_OFFBIG_LINTFLAGS, | |
4403 | _CS_XBS5_LP64_OFF64_CFLAGS, | |
4404 | _CS_XBS5_LP64_OFF64_LDFLAGS, | |
4405 | _CS_XBS5_LP64_OFF64_LIBS, | |
4406 | _CS_XBS5_LP64_OFF64_LINTFLAGS, | |
4407 | _CS_XBS5_LPBIG_OFFBIG_CFLAGS, | |
4408 | _CS_XBS5_LPBIG_OFFBIG_LDFLAGS, | |
4409 | _CS_XBS5_LPBIG_OFFBIG_LIBS, | |
4410 | _CS_XBS5_LPBIG_OFFBIG_LINTFLAGS, | |
4411 | _CS_POSIX_V6_ILP32_OFF32_CFLAGS, | |
4412 | _CS_POSIX_V6_ILP32_OFF32_LDFLAGS, | |
4413 | _CS_POSIX_V6_ILP32_OFF32_LIBS, | |
4414 | _CS_POSIX_V6_ILP32_OFF32_LINTFLAGS, | |
4415 | _CS_POSIX_V6_ILP32_OFFBIG_CFLAGS, | |
4416 | _CS_POSIX_V6_ILP32_OFFBIG_LDFLAGS, | |
4417 | _CS_POSIX_V6_ILP32_OFFBIG_LIBS, | |
4418 | _CS_POSIX_V6_ILP32_OFFBIG_LINTFLAGS, | |
4419 | _CS_POSIX_V6_LP64_OFF64_CFLAGS, | |
4420 | _CS_POSIX_V6_LP64_OFF64_LDFLAGS, | |
4421 | _CS_POSIX_V6_LP64_OFF64_LIBS, | |
4422 | _CS_POSIX_V6_LP64_OFF64_LINTFLAGS, | |
4423 | _CS_POSIX_V6_LPBIG_OFFBIG_CFLAGS, | |
4424 | _CS_POSIX_V6_LPBIG_OFFBIG_LDFLAGS, | |
4425 | _CS_POSIX_V6_LPBIG_OFFBIG_LIBS, | |
4426 | _CS_POSIX_V6_LPBIG_OFFBIG_LINTFLAGS | |
4427 | }; | |
4428 | extern long int pathconf (__const char *__path, int __name) | |
4429 | throw () __attribute__ ((__nonnull__ (1))); | |
4430 | extern long int fpathconf (int __fd, int __name) throw (); | |
4431 | extern long int sysconf (int __name) throw (); | |
4432 | extern size_t confstr (int __name, char *__buf, size_t __len) throw (); | |
4433 | extern __pid_t getpid (void) throw (); | |
4434 | extern __pid_t getppid (void) throw (); | |
4435 | extern __pid_t getpgrp (void) throw (); | |
4436 | extern __pid_t __getpgid (__pid_t __pid) throw (); | |
4437 | extern __pid_t getpgid (__pid_t __pid) throw (); | |
4438 | extern int setpgid (__pid_t __pid, __pid_t __pgid) throw (); | |
4439 | extern int setpgrp (void) throw (); | |
4440 | extern __pid_t setsid (void) throw (); | |
4441 | extern __pid_t getsid (__pid_t __pid) throw (); | |
4442 | extern __uid_t getuid (void) throw (); | |
4443 | extern __uid_t geteuid (void) throw (); | |
4444 | extern __gid_t getgid (void) throw (); | |
4445 | extern __gid_t getegid (void) throw (); | |
4446 | extern int getgroups (int __size, __gid_t __list[]) throw () ; | |
4447 | extern int setuid (__uid_t __uid) throw (); | |
4448 | extern int setreuid (__uid_t __ruid, __uid_t __euid) throw (); | |
4449 | extern int seteuid (__uid_t __uid) throw (); | |
4450 | extern int setgid (__gid_t __gid) throw (); | |
4451 | extern int setregid (__gid_t __rgid, __gid_t __egid) throw (); | |
4452 | extern int setegid (__gid_t __gid) throw (); | |
4453 | extern int getresuid (__uid_t *__ruid, __uid_t *__euid, __uid_t *__suid) | |
4454 | throw (); | |
4455 | extern int getresgid (__gid_t *__rgid, __gid_t *__egid, __gid_t *__sgid) | |
4456 | throw (); | |
4457 | extern int setresuid (__uid_t __ruid, __uid_t __euid, __uid_t __suid) | |
4458 | throw (); | |
4459 | extern int setresgid (__gid_t __rgid, __gid_t __egid, __gid_t __sgid) | |
4460 | throw (); | |
4461 | extern __pid_t vfork (void) throw (); | |
4462 | extern char *ttyname (int __fd) throw (); | |
4463 | extern int ttyname_r (int __fd, char *__buf, size_t __buflen) | |
4464 | throw () __attribute__ ((__nonnull__ (2))) ; | |
4465 | extern int isatty (int __fd) throw (); | |
4466 | extern int link (__const char *__from, __const char *__to) | |
4467 | throw () __attribute__ ((__nonnull__ (1, 2))) ; | |
4468 | extern int symlink (__const char *__from, __const char *__to) | |
4469 | throw () __attribute__ ((__nonnull__ (1, 2))) ; | |
4470 | extern ssize_t readlink (__const char *__restrict __path, | |
4471 | char *__restrict __buf, size_t __len) | |
4472 | throw () __attribute__ ((__nonnull__ (1, 2))) ; | |
4473 | extern int unlink (__const char *__name) throw () __attribute__ ((__nonnull__ (1))); | |
4474 | extern int rmdir (__const char *__path) throw () __attribute__ ((__nonnull__ (1))); | |
4475 | extern __pid_t tcgetpgrp (int __fd) throw (); | |
4476 | extern int tcsetpgrp (int __fd, __pid_t __pgrp_id) throw (); | |
4477 | extern char *getlogin (void); | |
4478 | extern int getlogin_r (char *__name, size_t __name_len) __attribute__ ((__nonnull__ (1))); | |
4479 | extern "C" { | |
4480 | extern char *optarg; | |
4481 | extern int optind; | |
4482 | extern int opterr; | |
4483 | extern int optopt; | |
4484 | extern int getopt (int ___argc, char *const *___argv, const char *__shortopts) | |
4485 | throw (); | |
4486 | } | |
4487 | extern int gethostname (char *__name, size_t __len) throw () __attribute__ ((__nonnull__ (1))); | |
4488 | extern int sethostname (__const char *__name, size_t __len) | |
4489 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4490 | extern int sethostid (long int __id) throw () ; | |
4491 | extern int getdomainname (char *__name, size_t __len) | |
4492 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4493 | extern int setdomainname (__const char *__name, size_t __len) | |
4494 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4495 | extern int vhangup (void) throw (); | |
4496 | extern int acct (__const char *__name) throw (); | |
4497 | extern char *getusershell (void) throw (); | |
4498 | extern void endusershell (void) throw (); | |
4499 | extern void setusershell (void) throw (); | |
4500 | extern int daemon (int __nochdir, int __noclose) throw () ; | |
4501 | extern int chroot (__const char *__path) throw () __attribute__ ((__nonnull__ (1))) ; | |
4502 | extern char *getpass (__const char *__prompt) __attribute__ ((__nonnull__ (1))); | |
4503 | extern int fsync (int __fd); | |
4504 | extern long int gethostid (void); | |
4505 | extern void sync (void) throw (); | |
4506 | extern int getpagesize (void) throw () __attribute__ ((__const__)); | |
4507 | extern int getdtablesize (void) throw (); | |
4508 | extern int truncate (__const char *__file, __off_t __length) | |
4509 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4510 | extern int truncate64 (__const char *__file, __off64_t __length) | |
4511 | throw () __attribute__ ((__nonnull__ (1))) ; | |
4512 | extern int ftruncate (int __fd, __off_t __length) throw () ; | |
4513 | extern int ftruncate64 (int __fd, __off64_t __length) throw () ; | |
4514 | extern int brk (void *__addr) throw () ; | |
4515 | extern void *sbrk (intptr_t __delta) throw (); | |
4516 | extern long int syscall (long int __sysno, ...) throw (); | |
4517 | extern int lockf (int __fd, int __cmd, __off_t __len) ; | |
4518 | extern int lockf64 (int __fd, int __cmd, __off64_t __len) ; | |
4519 | extern int fdatasync (int __fildes) throw (); | |
4520 | extern char *crypt (__const char *__key, __const char *__salt) | |
4521 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
4522 | extern void encrypt (char *__block, int __edflag) throw () __attribute__ ((__nonnull__ (1))); | |
4523 | extern void swab (__const void *__restrict __from, void *__restrict __to, | |
4524 | ssize_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); | |
4525 | extern char *ctermid (char *__s) throw (); | |
4526 | } | |
4527 | typedef pthread_key_t __gthread_key_t; | |
4528 | typedef pthread_once_t __gthread_once_t; | |
4529 | typedef pthread_mutex_t __gthread_mutex_t; | |
4530 | typedef pthread_mutex_t __gthread_recursive_mutex_t; | |
4531 | typedef pthread_cond_t __gthread_cond_t; | |
4532 | static __typeof(pthread_once) __gthrw_pthread_once __attribute__ ((__weakref__("pthread_once"))); | |
4533 | static __typeof(pthread_getspecific) __gthrw_pthread_getspecific __attribute__ ((__weakref__("pthread_getspecific"))); | |
4534 | static __typeof(pthread_setspecific) __gthrw_pthread_setspecific __attribute__ ((__weakref__("pthread_setspecific"))); | |
4535 | static __typeof(pthread_create) __gthrw_pthread_create __attribute__ ((__weakref__("pthread_create"))); | |
4536 | static __typeof(pthread_cancel) __gthrw_pthread_cancel __attribute__ ((__weakref__("pthread_cancel"))); | |
4537 | static __typeof(pthread_mutex_lock) __gthrw_pthread_mutex_lock __attribute__ ((__weakref__("pthread_mutex_lock"))); | |
4538 | static __typeof(pthread_mutex_trylock) __gthrw_pthread_mutex_trylock __attribute__ ((__weakref__("pthread_mutex_trylock"))); | |
4539 | static __typeof(pthread_mutex_unlock) __gthrw_pthread_mutex_unlock __attribute__ ((__weakref__("pthread_mutex_unlock"))); | |
4540 | static __typeof(pthread_mutex_init) __gthrw_pthread_mutex_init __attribute__ ((__weakref__("pthread_mutex_init"))); | |
4541 | static __typeof(pthread_cond_broadcast) __gthrw_pthread_cond_broadcast __attribute__ ((__weakref__("pthread_cond_broadcast"))); | |
4542 | static __typeof(pthread_cond_wait) __gthrw_pthread_cond_wait __attribute__ ((__weakref__("pthread_cond_wait"))); | |
4543 | static __typeof(pthread_key_create) __gthrw_pthread_key_create __attribute__ ((__weakref__("pthread_key_create"))); | |
4544 | static __typeof(pthread_key_delete) __gthrw_pthread_key_delete __attribute__ ((__weakref__("pthread_key_delete"))); | |
4545 | static __typeof(pthread_mutexattr_init) __gthrw_pthread_mutexattr_init __attribute__ ((__weakref__("pthread_mutexattr_init"))); | |
4546 | static __typeof(pthread_mutexattr_settype) __gthrw_pthread_mutexattr_settype __attribute__ ((__weakref__("pthread_mutexattr_settype"))); | |
4547 | static __typeof(pthread_mutexattr_destroy) __gthrw_pthread_mutexattr_destroy __attribute__ ((__weakref__("pthread_mutexattr_destroy"))); | |
4548 | static inline int | |
4549 | __gthread_active_p (void) | |
4550 | { | |
4551 | static void *const __gthread_active_ptr | |
4552 | = __extension__ (void *) &__gthrw_pthread_cancel; | |
4553 | return __gthread_active_ptr != 0; | |
4554 | } | |
4555 | static inline int | |
4556 | __gthread_once (__gthread_once_t *once, void (*func) (void)) | |
4557 | { | |
4558 | if (__gthread_active_p ()) | |
4559 | return __gthrw_pthread_once (once, func); | |
4560 | else | |
4561 | return -1; | |
4562 | } | |
4563 | static inline int | |
4564 | __gthread_key_create (__gthread_key_t *key, void (*dtor) (void *)) | |
4565 | { | |
4566 | return __gthrw_pthread_key_create (key, dtor); | |
4567 | } | |
4568 | static inline int | |
4569 | __gthread_key_delete (__gthread_key_t key) | |
4570 | { | |
4571 | return __gthrw_pthread_key_delete (key); | |
4572 | } | |
4573 | static inline void * | |
4574 | __gthread_getspecific (__gthread_key_t key) | |
4575 | { | |
4576 | return __gthrw_pthread_getspecific (key); | |
4577 | } | |
4578 | static inline int | |
4579 | __gthread_setspecific (__gthread_key_t key, const void *ptr) | |
4580 | { | |
4581 | return __gthrw_pthread_setspecific (key, ptr); | |
4582 | } | |
4583 | static inline int | |
4584 | __gthread_mutex_lock (__gthread_mutex_t *mutex) | |
4585 | { | |
4586 | if (__gthread_active_p ()) | |
4587 | return __gthrw_pthread_mutex_lock (mutex); | |
4588 | else | |
4589 | return 0; | |
4590 | } | |
4591 | static inline int | |
4592 | __gthread_mutex_trylock (__gthread_mutex_t *mutex) | |
4593 | { | |
4594 | if (__gthread_active_p ()) | |
4595 | return __gthrw_pthread_mutex_trylock (mutex); | |
4596 | else | |
4597 | return 0; | |
4598 | } | |
4599 | static inline int | |
4600 | __gthread_mutex_unlock (__gthread_mutex_t *mutex) | |
4601 | { | |
4602 | if (__gthread_active_p ()) | |
4603 | return __gthrw_pthread_mutex_unlock (mutex); | |
4604 | else | |
4605 | return 0; | |
4606 | } | |
4607 | static inline int | |
4608 | __gthread_recursive_mutex_lock (__gthread_recursive_mutex_t *mutex) | |
4609 | { | |
4610 | return __gthread_mutex_lock (mutex); | |
4611 | } | |
4612 | static inline int | |
4613 | __gthread_recursive_mutex_trylock (__gthread_recursive_mutex_t *mutex) | |
4614 | { | |
4615 | return __gthread_mutex_trylock (mutex); | |
4616 | } | |
4617 | static inline int | |
4618 | __gthread_recursive_mutex_unlock (__gthread_recursive_mutex_t *mutex) | |
4619 | { | |
4620 | return __gthread_mutex_unlock (mutex); | |
4621 | } | |
4622 | static inline int | |
4623 | __gthread_cond_broadcast (__gthread_cond_t *cond) | |
4624 | { | |
4625 | return __gthrw_pthread_cond_broadcast (cond); | |
4626 | } | |
4627 | static inline int | |
4628 | __gthread_cond_wait (__gthread_cond_t *cond, __gthread_mutex_t *mutex) | |
4629 | { | |
4630 | return __gthrw_pthread_cond_wait (cond, mutex); | |
4631 | } | |
4632 | static inline int | |
4633 | __gthread_cond_wait_recursive (__gthread_cond_t *cond, | |
4634 | __gthread_recursive_mutex_t *mutex) | |
4635 | { | |
4636 | return __gthread_cond_wait (cond, mutex); | |
4637 | } | |
4638 | typedef int _Atomic_word; | |
4639 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
4640 | static inline _Atomic_word | |
4641 | __exchange_and_add(volatile _Atomic_word* __mem, int __val) | |
4642 | { return __sync_fetch_and_add(__mem, __val); } | |
4643 | static inline void | |
4644 | __atomic_add(volatile _Atomic_word* __mem, int __val) | |
4645 | { __sync_fetch_and_add(__mem, __val); } | |
4646 | static inline _Atomic_word | |
4647 | __exchange_and_add_single(_Atomic_word* __mem, int __val) | |
4648 | { | |
4649 | _Atomic_word __result = *__mem; | |
4650 | *__mem += __val; | |
4651 | return __result; | |
4652 | } | |
4653 | static inline void | |
4654 | __atomic_add_single(_Atomic_word* __mem, int __val) | |
4655 | { *__mem += __val; } | |
4656 | static inline _Atomic_word | |
4657 | __attribute__ ((__unused__)) | |
4658 | __exchange_and_add_dispatch(_Atomic_word* __mem, int __val) | |
4659 | { | |
4660 | if (__gthread_active_p()) | |
4661 | return __exchange_and_add(__mem, __val); | |
4662 | else | |
4663 | return __exchange_and_add_single(__mem, __val); | |
4664 | } | |
4665 | static inline void | |
4666 | __attribute__ ((__unused__)) | |
4667 | __atomic_add_dispatch(_Atomic_word* __mem, int __val) | |
4668 | { | |
4669 | if (__gthread_active_p()) | |
4670 | __atomic_add(__mem, __val); | |
4671 | else | |
4672 | __atomic_add_single(__mem, __val); | |
4673 | } | |
4674 | } | |
4675 | extern "C++" { | |
4676 | namespace std | |
4677 | { | |
4678 | class bad_alloc : public exception | |
4679 | { | |
4680 | public: | |
4681 | bad_alloc() throw() { } | |
4682 | virtual ~bad_alloc() throw(); | |
4683 | virtual const char* what() const throw(); | |
4684 | }; | |
4685 | struct nothrow_t { }; | |
4686 | extern const nothrow_t nothrow; | |
4687 | typedef void (*new_handler)(); | |
4688 | new_handler set_new_handler(new_handler) throw(); | |
4689 | } | |
4690 | void* operator new(std::size_t) throw (std::bad_alloc); | |
4691 | void* operator new[](std::size_t) throw (std::bad_alloc); | |
4692 | void operator delete(void*) throw(); | |
4693 | void operator delete[](void*) throw(); | |
4694 | void* operator new(std::size_t, const std::nothrow_t&) throw(); | |
4695 | void* operator new[](std::size_t, const std::nothrow_t&) throw(); | |
4696 | void operator delete(void*, const std::nothrow_t&) throw(); | |
4697 | void operator delete[](void*, const std::nothrow_t&) throw(); | |
4698 | inline void* operator new(std::size_t, void* __p) throw() { return __p; } | |
4699 | inline void* operator new[](std::size_t, void* __p) throw() { return __p; } | |
4700 | inline void operator delete (void*, void*) throw() { } | |
4701 | inline void operator delete[](void*, void*) throw() { } | |
4702 | } | |
4703 | namespace __gnu_cxx __attribute__ ((__visibility__ ("default"))) { | |
4704 | using std::size_t; | |
4705 | using std::ptrdiff_t; | |
4706 | template<typename _Tp> | |
4707 | class new_allocator | |
4708 | { | |
4709 | public: | |
4710 | typedef size_t size_type; | |
4711 | typedef ptrdiff_t difference_type; | |
4712 | typedef _Tp* pointer; | |
4713 | typedef const _Tp* const_pointer; | |
4714 | typedef _Tp& reference; | |
4715 | typedef const _Tp& const_reference; | |
4716 | typedef _Tp value_type; | |
4717 | template<typename _Tp1> | |
4718 | struct rebind | |
4719 | { typedef new_allocator<_Tp1> other; }; | |
4720 | new_allocator() throw() { } | |
4721 | new_allocator(const new_allocator&) throw() { } | |
4722 | template<typename _Tp1> | |
4723 | new_allocator(const new_allocator<_Tp1>&) throw() { } | |
4724 | ~new_allocator() throw() { } | |
4725 | pointer | |
4726 | address(reference __x) const { return &__x; } | |
4727 | const_pointer | |
4728 | address(const_reference __x) const { return &__x; } | |
4729 | pointer | |
4730 | allocate(size_type __n, const void* = 0) | |
4731 | { | |
4732 | if (__builtin_expect(__n > this->max_size(), false)) | |
4733 | std::__throw_bad_alloc(); | |
4734 | return static_cast<_Tp*>(::operator new(__n * sizeof(_Tp))); | |
4735 | } | |
4736 | void | |
4737 | deallocate(pointer __p, size_type) | |
4738 | { ::operator delete(__p); } | |
4739 | size_type | |
4740 | max_size() const throw() | |
4741 | { return size_t(-1) / sizeof(_Tp); } | |
4742 | void | |
4743 | construct(pointer __p, const _Tp& __val) | |
4744 | { ::new((void *)__p) _Tp(__val); } | |
4745 | void | |
4746 | destroy(pointer __p) { __p->~_Tp(); } | |
4747 | }; | |
4748 | template<typename _Tp> | |
4749 | inline bool | |
4750 | operator==(const new_allocator<_Tp>&, const new_allocator<_Tp>&) | |
4751 | { return true; } | |
4752 | template<typename _Tp> | |
4753 | inline bool | |
4754 | operator!=(const new_allocator<_Tp>&, const new_allocator<_Tp>&) | |
4755 | { return false; } | |
4756 | } | |
4757 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
4758 | template<typename _Tp> | |
4759 | class allocator; | |
4760 | template<> | |
4761 | class allocator<void> | |
4762 | { | |
4763 | public: | |
4764 | typedef size_t size_type; | |
4765 | typedef ptrdiff_t difference_type; | |
4766 | typedef void* pointer; | |
4767 | typedef const void* const_pointer; | |
4768 | typedef void value_type; | |
4769 | template<typename _Tp1> | |
4770 | struct rebind | |
4771 | { typedef allocator<_Tp1> other; }; | |
4772 | }; | |
4773 | template<typename _Tp> | |
4774 | class allocator: public __gnu_cxx::new_allocator<_Tp> | |
4775 | { | |
4776 | public: | |
4777 | typedef size_t size_type; | |
4778 | typedef ptrdiff_t difference_type; | |
4779 | typedef _Tp* pointer; | |
4780 | typedef const _Tp* const_pointer; | |
4781 | typedef _Tp& reference; | |
4782 | typedef const _Tp& const_reference; | |
4783 | typedef _Tp value_type; | |
4784 | template<typename _Tp1> | |
4785 | struct rebind | |
4786 | { typedef allocator<_Tp1> other; }; | |
4787 | allocator() throw() { } | |
4788 | allocator(const allocator& __a) throw() | |
4789 | : __gnu_cxx::new_allocator<_Tp>(__a) { } | |
4790 | template<typename _Tp1> | |
4791 | allocator(const allocator<_Tp1>&) throw() { } | |
4792 | ~allocator() throw() { } | |
4793 | }; | |
4794 | template<typename _T1, typename _T2> | |
4795 | inline bool | |
4796 | operator==(const allocator<_T1>&, const allocator<_T2>&) | |
4797 | { return true; } | |
4798 | template<typename _Tp> | |
4799 | inline bool | |
4800 | operator==(const allocator<_Tp>&, const allocator<_Tp>&) | |
4801 | { return true; } | |
4802 | template<typename _T1, typename _T2> | |
4803 | inline bool | |
4804 | operator!=(const allocator<_T1>&, const allocator<_T2>&) | |
4805 | { return false; } | |
4806 | template<typename _Tp> | |
4807 | inline bool | |
4808 | operator!=(const allocator<_Tp>&, const allocator<_Tp>&) | |
4809 | { return false; } | |
4810 | extern template class allocator<char>; | |
4811 | extern template class allocator<wchar_t>; | |
4812 | template<typename _Alloc, bool = __is_empty(_Alloc)> | |
4813 | struct __alloc_swap | |
4814 | { static void _S_do_it(_Alloc&, _Alloc&) { } }; | |
4815 | template<typename _Alloc> | |
4816 | struct __alloc_swap<_Alloc, false> | |
4817 | { | |
4818 | static void | |
4819 | _S_do_it(_Alloc& __one, _Alloc& __two) | |
4820 | { | |
4821 | if (__one != __two) | |
4822 | swap(__one, __two); | |
4823 | } | |
4824 | }; | |
4825 | template<typename _Alloc, bool = __is_empty(_Alloc)> | |
4826 | struct __alloc_neq | |
4827 | { | |
4828 | static bool | |
4829 | _S_do_it(const _Alloc&, const _Alloc&) | |
4830 | { return false; } | |
4831 | }; | |
4832 | template<typename _Alloc> | |
4833 | struct __alloc_neq<_Alloc, false> | |
4834 | { | |
4835 | static bool | |
4836 | _S_do_it(const _Alloc& __one, const _Alloc& __two) | |
4837 | { return __one != __two; } | |
4838 | }; | |
4839 | } | |
4840 | namespace __cxxabiv1 | |
4841 | { | |
4842 | class __forced_unwind | |
4843 | { | |
4844 | virtual ~__forced_unwind() throw(); | |
4845 | virtual void __pure_dummy() = 0; | |
4846 | }; | |
4847 | } | |
4848 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
4849 | template<typename _CharT, typename _Traits> | |
4850 | inline void | |
4851 | __ostream_write(basic_ostream<_CharT, _Traits>& __out, | |
4852 | const _CharT* __s, streamsize __n) | |
4853 | { | |
4854 | typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
4855 | typedef typename __ostream_type::ios_base __ios_base; | |
4856 | const streamsize __put = __out.rdbuf()->sputn(__s, __n); | |
4857 | if (__put != __n) | |
4858 | __out.setstate(__ios_base::badbit); | |
4859 | } | |
4860 | template<typename _CharT, typename _Traits> | |
4861 | inline void | |
4862 | __ostream_fill(basic_ostream<_CharT, _Traits>& __out, streamsize __n) | |
4863 | { | |
4864 | typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
4865 | typedef typename __ostream_type::ios_base __ios_base; | |
4866 | const _CharT __c = __out.fill(); | |
4867 | for (; __n > 0; --__n) | |
4868 | { | |
4869 | const typename _Traits::int_type __put = __out.rdbuf()->sputc(__c); | |
4870 | if (_Traits::eq_int_type(__put, _Traits::eof())) | |
4871 | { | |
4872 | __out.setstate(__ios_base::badbit); | |
4873 | break; | |
4874 | } | |
4875 | } | |
4876 | } | |
4877 | template<typename _CharT, typename _Traits> | |
4878 | basic_ostream<_CharT, _Traits>& | |
4879 | __ostream_insert(basic_ostream<_CharT, _Traits>& __out, | |
4880 | const _CharT* __s, streamsize __n) | |
4881 | { | |
4882 | typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
4883 | typedef typename __ostream_type::ios_base __ios_base; | |
4884 | typename __ostream_type::sentry __cerb(__out); | |
4885 | if (__cerb) | |
4886 | { | |
4887 | try | |
4888 | { | |
4889 | const streamsize __w = __out.width(); | |
4890 | if (__w > __n) | |
4891 | { | |
4892 | const bool __left = ((__out.flags() | |
4893 | & __ios_base::adjustfield) | |
4894 | == __ios_base::left); | |
4895 | if (!__left) | |
4896 | __ostream_fill(__out, __w - __n); | |
4897 | if (__out.good()) | |
4898 | __ostream_write(__out, __s, __n); | |
4899 | if (__left && __out.good()) | |
4900 | __ostream_fill(__out, __w - __n); | |
4901 | } | |
4902 | else | |
4903 | __ostream_write(__out, __s, __n); | |
4904 | __out.width(0); | |
4905 | } | |
4906 | catch(__cxxabiv1::__forced_unwind&) | |
4907 | { | |
4908 | __out._M_setstate(__ios_base::badbit); | |
4909 | throw; | |
4910 | } | |
4911 | catch(...) | |
4912 | { __out._M_setstate(__ios_base::badbit); } | |
4913 | } | |
4914 | return __out; | |
4915 | } | |
4916 | extern template ostream& __ostream_insert(ostream&, const char*, streamsize); | |
4917 | } | |
4918 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
4919 | template<typename _Arg, typename _Result> | |
4920 | struct unary_function | |
4921 | { | |
4922 | typedef _Arg argument_type; | |
4923 | typedef _Result result_type; | |
4924 | }; | |
4925 | template<typename _Arg1, typename _Arg2, typename _Result> | |
4926 | struct binary_function | |
4927 | { | |
4928 | typedef _Arg1 first_argument_type; | |
4929 | typedef _Arg2 second_argument_type; | |
4930 | typedef _Result result_type; | |
4931 | }; | |
4932 | template<typename _Tp> | |
4933 | struct plus : public binary_function<_Tp, _Tp, _Tp> | |
4934 | { | |
4935 | _Tp | |
4936 | operator()(const _Tp& __x, const _Tp& __y) const | |
4937 | { return __x + __y; } | |
4938 | }; | |
4939 | template<typename _Tp> | |
4940 | struct minus : public binary_function<_Tp, _Tp, _Tp> | |
4941 | { | |
4942 | _Tp | |
4943 | operator()(const _Tp& __x, const _Tp& __y) const | |
4944 | { return __x - __y; } | |
4945 | }; | |
4946 | template<typename _Tp> | |
4947 | struct multiplies : public binary_function<_Tp, _Tp, _Tp> | |
4948 | { | |
4949 | _Tp | |
4950 | operator()(const _Tp& __x, const _Tp& __y) const | |
4951 | { return __x * __y; } | |
4952 | }; | |
4953 | template<typename _Tp> | |
4954 | struct divides : public binary_function<_Tp, _Tp, _Tp> | |
4955 | { | |
4956 | _Tp | |
4957 | operator()(const _Tp& __x, const _Tp& __y) const | |
4958 | { return __x / __y; } | |
4959 | }; | |
4960 | template<typename _Tp> | |
4961 | struct modulus : public binary_function<_Tp, _Tp, _Tp> | |
4962 | { | |
4963 | _Tp | |
4964 | operator()(const _Tp& __x, const _Tp& __y) const | |
4965 | { return __x % __y; } | |
4966 | }; | |
4967 | template<typename _Tp> | |
4968 | struct negate : public unary_function<_Tp, _Tp> | |
4969 | { | |
4970 | _Tp | |
4971 | operator()(const _Tp& __x) const | |
4972 | { return -__x; } | |
4973 | }; | |
4974 | template<typename _Tp> | |
4975 | struct equal_to : public binary_function<_Tp, _Tp, bool> | |
4976 | { | |
4977 | bool | |
4978 | operator()(const _Tp& __x, const _Tp& __y) const | |
4979 | { return __x == __y; } | |
4980 | }; | |
4981 | template<typename _Tp> | |
4982 | struct not_equal_to : public binary_function<_Tp, _Tp, bool> | |
4983 | { | |
4984 | bool | |
4985 | operator()(const _Tp& __x, const _Tp& __y) const | |
4986 | { return __x != __y; } | |
4987 | }; | |
4988 | template<typename _Tp> | |
4989 | struct greater : public binary_function<_Tp, _Tp, bool> | |
4990 | { | |
4991 | bool | |
4992 | operator()(const _Tp& __x, const _Tp& __y) const | |
4993 | { return __x > __y; } | |
4994 | }; | |
4995 | template<typename _Tp> | |
4996 | struct less : public binary_function<_Tp, _Tp, bool> | |
4997 | { | |
4998 | bool | |
4999 | operator()(const _Tp& __x, const _Tp& __y) const | |
5000 | { return __x < __y; } | |
5001 | }; | |
5002 | template<typename _Tp> | |
5003 | struct greater_equal : public binary_function<_Tp, _Tp, bool> | |
5004 | { | |
5005 | bool | |
5006 | operator()(const _Tp& __x, const _Tp& __y) const | |
5007 | { return __x >= __y; } | |
5008 | }; | |
5009 | template<typename _Tp> | |
5010 | struct less_equal : public binary_function<_Tp, _Tp, bool> | |
5011 | { | |
5012 | bool | |
5013 | operator()(const _Tp& __x, const _Tp& __y) const | |
5014 | { return __x <= __y; } | |
5015 | }; | |
5016 | template<typename _Tp> | |
5017 | struct logical_and : public binary_function<_Tp, _Tp, bool> | |
5018 | { | |
5019 | bool | |
5020 | operator()(const _Tp& __x, const _Tp& __y) const | |
5021 | { return __x && __y; } | |
5022 | }; | |
5023 | template<typename _Tp> | |
5024 | struct logical_or : public binary_function<_Tp, _Tp, bool> | |
5025 | { | |
5026 | bool | |
5027 | operator()(const _Tp& __x, const _Tp& __y) const | |
5028 | { return __x || __y; } | |
5029 | }; | |
5030 | template<typename _Tp> | |
5031 | struct logical_not : public unary_function<_Tp, bool> | |
5032 | { | |
5033 | bool | |
5034 | operator()(const _Tp& __x) const | |
5035 | { return !__x; } | |
5036 | }; | |
5037 | template<typename _Tp> | |
5038 | struct bit_and : public binary_function<_Tp, _Tp, _Tp> | |
5039 | { | |
5040 | _Tp | |
5041 | operator()(const _Tp& __x, const _Tp& __y) const | |
5042 | { return __x & __y; } | |
5043 | }; | |
5044 | template<typename _Tp> | |
5045 | struct bit_or : public binary_function<_Tp, _Tp, _Tp> | |
5046 | { | |
5047 | _Tp | |
5048 | operator()(const _Tp& __x, const _Tp& __y) const | |
5049 | { return __x | __y; } | |
5050 | }; | |
5051 | template<typename _Tp> | |
5052 | struct bit_xor : public binary_function<_Tp, _Tp, _Tp> | |
5053 | { | |
5054 | _Tp | |
5055 | operator()(const _Tp& __x, const _Tp& __y) const | |
5056 | { return __x ^ __y; } | |
5057 | }; | |
5058 | template<typename _Predicate> | |
5059 | class unary_negate | |
5060 | : public unary_function<typename _Predicate::argument_type, bool> | |
5061 | { | |
5062 | protected: | |
5063 | _Predicate _M_pred; | |
5064 | public: | |
5065 | explicit | |
5066 | unary_negate(const _Predicate& __x) : _M_pred(__x) { } | |
5067 | bool | |
5068 | operator()(const typename _Predicate::argument_type& __x) const | |
5069 | { return !_M_pred(__x); } | |
5070 | }; | |
5071 | template<typename _Predicate> | |
5072 | inline unary_negate<_Predicate> | |
5073 | not1(const _Predicate& __pred) | |
5074 | { return unary_negate<_Predicate>(__pred); } | |
5075 | template<typename _Predicate> | |
5076 | class binary_negate | |
5077 | : public binary_function<typename _Predicate::first_argument_type, | |
5078 | typename _Predicate::second_argument_type, bool> | |
5079 | { | |
5080 | protected: | |
5081 | _Predicate _M_pred; | |
5082 | public: | |
5083 | explicit | |
5084 | binary_negate(const _Predicate& __x) : _M_pred(__x) { } | |
5085 | bool | |
5086 | operator()(const typename _Predicate::first_argument_type& __x, | |
5087 | const typename _Predicate::second_argument_type& __y) const | |
5088 | { return !_M_pred(__x, __y); } | |
5089 | }; | |
5090 | template<typename _Predicate> | |
5091 | inline binary_negate<_Predicate> | |
5092 | not2(const _Predicate& __pred) | |
5093 | { return binary_negate<_Predicate>(__pred); } | |
5094 | template<typename _Arg, typename _Result> | |
5095 | class pointer_to_unary_function : public unary_function<_Arg, _Result> | |
5096 | { | |
5097 | protected: | |
5098 | _Result (*_M_ptr)(_Arg); | |
5099 | public: | |
5100 | pointer_to_unary_function() { } | |
5101 | explicit | |
5102 | pointer_to_unary_function(_Result (*__x)(_Arg)) | |
5103 | : _M_ptr(__x) { } | |
5104 | _Result | |
5105 | operator()(_Arg __x) const | |
5106 | { return _M_ptr(__x); } | |
5107 | }; | |
5108 | template<typename _Arg, typename _Result> | |
5109 | inline pointer_to_unary_function<_Arg, _Result> | |
5110 | ptr_fun(_Result (*__x)(_Arg)) | |
5111 | { return pointer_to_unary_function<_Arg, _Result>(__x); } | |
5112 | template<typename _Arg1, typename _Arg2, typename _Result> | |
5113 | class pointer_to_binary_function | |
5114 | : public binary_function<_Arg1, _Arg2, _Result> | |
5115 | { | |
5116 | protected: | |
5117 | _Result (*_M_ptr)(_Arg1, _Arg2); | |
5118 | public: | |
5119 | pointer_to_binary_function() { } | |
5120 | explicit | |
5121 | pointer_to_binary_function(_Result (*__x)(_Arg1, _Arg2)) | |
5122 | : _M_ptr(__x) { } | |
5123 | _Result | |
5124 | operator()(_Arg1 __x, _Arg2 __y) const | |
5125 | { return _M_ptr(__x, __y); } | |
5126 | }; | |
5127 | template<typename _Arg1, typename _Arg2, typename _Result> | |
5128 | inline pointer_to_binary_function<_Arg1, _Arg2, _Result> | |
5129 | ptr_fun(_Result (*__x)(_Arg1, _Arg2)) | |
5130 | { return pointer_to_binary_function<_Arg1, _Arg2, _Result>(__x); } | |
5131 | template<typename _Tp> | |
5132 | struct _Identity : public unary_function<_Tp,_Tp> | |
5133 | { | |
5134 | _Tp& | |
5135 | operator()(_Tp& __x) const | |
5136 | { return __x; } | |
5137 | const _Tp& | |
5138 | operator()(const _Tp& __x) const | |
5139 | { return __x; } | |
5140 | }; | |
5141 | template<typename _Pair> | |
5142 | struct _Select1st : public unary_function<_Pair, | |
5143 | typename _Pair::first_type> | |
5144 | { | |
5145 | typename _Pair::first_type& | |
5146 | operator()(_Pair& __x) const | |
5147 | { return __x.first; } | |
5148 | const typename _Pair::first_type& | |
5149 | operator()(const _Pair& __x) const | |
5150 | { return __x.first; } | |
5151 | }; | |
5152 | template<typename _Pair> | |
5153 | struct _Select2nd : public unary_function<_Pair, | |
5154 | typename _Pair::second_type> | |
5155 | { | |
5156 | typename _Pair::second_type& | |
5157 | operator()(_Pair& __x) const | |
5158 | { return __x.second; } | |
5159 | const typename _Pair::second_type& | |
5160 | operator()(const _Pair& __x) const | |
5161 | { return __x.second; } | |
5162 | }; | |
5163 | template<typename _Ret, typename _Tp> | |
5164 | class mem_fun_t : public unary_function<_Tp*, _Ret> | |
5165 | { | |
5166 | public: | |
5167 | explicit | |
5168 | mem_fun_t(_Ret (_Tp::*__pf)()) | |
5169 | : _M_f(__pf) { } | |
5170 | _Ret | |
5171 | operator()(_Tp* __p) const | |
5172 | { return (__p->*_M_f)(); } | |
5173 | private: | |
5174 | _Ret (_Tp::*_M_f)(); | |
5175 | }; | |
5176 | template<typename _Ret, typename _Tp> | |
5177 | class const_mem_fun_t : public unary_function<const _Tp*, _Ret> | |
5178 | { | |
5179 | public: | |
5180 | explicit | |
5181 | const_mem_fun_t(_Ret (_Tp::*__pf)() const) | |
5182 | : _M_f(__pf) { } | |
5183 | _Ret | |
5184 | operator()(const _Tp* __p) const | |
5185 | { return (__p->*_M_f)(); } | |
5186 | private: | |
5187 | _Ret (_Tp::*_M_f)() const; | |
5188 | }; | |
5189 | template<typename _Ret, typename _Tp> | |
5190 | class mem_fun_ref_t : public unary_function<_Tp, _Ret> | |
5191 | { | |
5192 | public: | |
5193 | explicit | |
5194 | mem_fun_ref_t(_Ret (_Tp::*__pf)()) | |
5195 | : _M_f(__pf) { } | |
5196 | _Ret | |
5197 | operator()(_Tp& __r) const | |
5198 | { return (__r.*_M_f)(); } | |
5199 | private: | |
5200 | _Ret (_Tp::*_M_f)(); | |
5201 | }; | |
5202 | template<typename _Ret, typename _Tp> | |
5203 | class const_mem_fun_ref_t : public unary_function<_Tp, _Ret> | |
5204 | { | |
5205 | public: | |
5206 | explicit | |
5207 | const_mem_fun_ref_t(_Ret (_Tp::*__pf)() const) | |
5208 | : _M_f(__pf) { } | |
5209 | _Ret | |
5210 | operator()(const _Tp& __r) const | |
5211 | { return (__r.*_M_f)(); } | |
5212 | private: | |
5213 | _Ret (_Tp::*_M_f)() const; | |
5214 | }; | |
5215 | template<typename _Ret, typename _Tp, typename _Arg> | |
5216 | class mem_fun1_t : public binary_function<_Tp*, _Arg, _Ret> | |
5217 | { | |
5218 | public: | |
5219 | explicit | |
5220 | mem_fun1_t(_Ret (_Tp::*__pf)(_Arg)) | |
5221 | : _M_f(__pf) { } | |
5222 | _Ret | |
5223 | operator()(_Tp* __p, _Arg __x) const | |
5224 | { return (__p->*_M_f)(__x); } | |
5225 | private: | |
5226 | _Ret (_Tp::*_M_f)(_Arg); | |
5227 | }; | |
5228 | template<typename _Ret, typename _Tp, typename _Arg> | |
5229 | class const_mem_fun1_t : public binary_function<const _Tp*, _Arg, _Ret> | |
5230 | { | |
5231 | public: | |
5232 | explicit | |
5233 | const_mem_fun1_t(_Ret (_Tp::*__pf)(_Arg) const) | |
5234 | : _M_f(__pf) { } | |
5235 | _Ret | |
5236 | operator()(const _Tp* __p, _Arg __x) const | |
5237 | { return (__p->*_M_f)(__x); } | |
5238 | private: | |
5239 | _Ret (_Tp::*_M_f)(_Arg) const; | |
5240 | }; | |
5241 | template<typename _Ret, typename _Tp, typename _Arg> | |
5242 | class mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> | |
5243 | { | |
5244 | public: | |
5245 | explicit | |
5246 | mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg)) | |
5247 | : _M_f(__pf) { } | |
5248 | _Ret | |
5249 | operator()(_Tp& __r, _Arg __x) const | |
5250 | { return (__r.*_M_f)(__x); } | |
5251 | private: | |
5252 | _Ret (_Tp::*_M_f)(_Arg); | |
5253 | }; | |
5254 | template<typename _Ret, typename _Tp, typename _Arg> | |
5255 | class const_mem_fun1_ref_t : public binary_function<_Tp, _Arg, _Ret> | |
5256 | { | |
5257 | public: | |
5258 | explicit | |
5259 | const_mem_fun1_ref_t(_Ret (_Tp::*__pf)(_Arg) const) | |
5260 | : _M_f(__pf) { } | |
5261 | _Ret | |
5262 | operator()(const _Tp& __r, _Arg __x) const | |
5263 | { return (__r.*_M_f)(__x); } | |
5264 | private: | |
5265 | _Ret (_Tp::*_M_f)(_Arg) const; | |
5266 | }; | |
5267 | template<typename _Ret, typename _Tp> | |
5268 | inline mem_fun_t<_Ret, _Tp> | |
5269 | mem_fun(_Ret (_Tp::*__f)()) | |
5270 | { return mem_fun_t<_Ret, _Tp>(__f); } | |
5271 | template<typename _Ret, typename _Tp> | |
5272 | inline const_mem_fun_t<_Ret, _Tp> | |
5273 | mem_fun(_Ret (_Tp::*__f)() const) | |
5274 | { return const_mem_fun_t<_Ret, _Tp>(__f); } | |
5275 | template<typename _Ret, typename _Tp> | |
5276 | inline mem_fun_ref_t<_Ret, _Tp> | |
5277 | mem_fun_ref(_Ret (_Tp::*__f)()) | |
5278 | { return mem_fun_ref_t<_Ret, _Tp>(__f); } | |
5279 | template<typename _Ret, typename _Tp> | |
5280 | inline const_mem_fun_ref_t<_Ret, _Tp> | |
5281 | mem_fun_ref(_Ret (_Tp::*__f)() const) | |
5282 | { return const_mem_fun_ref_t<_Ret, _Tp>(__f); } | |
5283 | template<typename _Ret, typename _Tp, typename _Arg> | |
5284 | inline mem_fun1_t<_Ret, _Tp, _Arg> | |
5285 | mem_fun(_Ret (_Tp::*__f)(_Arg)) | |
5286 | { return mem_fun1_t<_Ret, _Tp, _Arg>(__f); } | |
5287 | template<typename _Ret, typename _Tp, typename _Arg> | |
5288 | inline const_mem_fun1_t<_Ret, _Tp, _Arg> | |
5289 | mem_fun(_Ret (_Tp::*__f)(_Arg) const) | |
5290 | { return const_mem_fun1_t<_Ret, _Tp, _Arg>(__f); } | |
5291 | template<typename _Ret, typename _Tp, typename _Arg> | |
5292 | inline mem_fun1_ref_t<_Ret, _Tp, _Arg> | |
5293 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg)) | |
5294 | { return mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } | |
5295 | template<typename _Ret, typename _Tp, typename _Arg> | |
5296 | inline const_mem_fun1_ref_t<_Ret, _Tp, _Arg> | |
5297 | mem_fun_ref(_Ret (_Tp::*__f)(_Arg) const) | |
5298 | { return const_mem_fun1_ref_t<_Ret, _Tp, _Arg>(__f); } | |
5299 | } | |
5300 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
5301 | template<typename _Operation> | |
5302 | class binder1st | |
5303 | : public unary_function<typename _Operation::second_argument_type, | |
5304 | typename _Operation::result_type> | |
5305 | { | |
5306 | protected: | |
5307 | _Operation op; | |
5308 | typename _Operation::first_argument_type value; | |
5309 | public: | |
5310 | binder1st(const _Operation& __x, | |
5311 | const typename _Operation::first_argument_type& __y) | |
5312 | : op(__x), value(__y) { } | |
5313 | typename _Operation::result_type | |
5314 | operator()(const typename _Operation::second_argument_type& __x) const | |
5315 | { return op(value, __x); } | |
5316 | typename _Operation::result_type | |
5317 | operator()(typename _Operation::second_argument_type& __x) const | |
5318 | { return op(value, __x); } | |
5319 | } ; | |
5320 | template<typename _Operation, typename _Tp> | |
5321 | inline binder1st<_Operation> | |
5322 | bind1st(const _Operation& __fn, const _Tp& __x) | |
5323 | { | |
5324 | typedef typename _Operation::first_argument_type _Arg1_type; | |
5325 | return binder1st<_Operation>(__fn, _Arg1_type(__x)); | |
5326 | } | |
5327 | template<typename _Operation> | |
5328 | class binder2nd | |
5329 | : public unary_function<typename _Operation::first_argument_type, | |
5330 | typename _Operation::result_type> | |
5331 | { | |
5332 | protected: | |
5333 | _Operation op; | |
5334 | typename _Operation::second_argument_type value; | |
5335 | public: | |
5336 | binder2nd(const _Operation& __x, | |
5337 | const typename _Operation::second_argument_type& __y) | |
5338 | : op(__x), value(__y) { } | |
5339 | typename _Operation::result_type | |
5340 | operator()(const typename _Operation::first_argument_type& __x) const | |
5341 | { return op(__x, value); } | |
5342 | typename _Operation::result_type | |
5343 | operator()(typename _Operation::first_argument_type& __x) const | |
5344 | { return op(__x, value); } | |
5345 | } ; | |
5346 | template<typename _Operation, typename _Tp> | |
5347 | inline binder2nd<_Operation> | |
5348 | bind2nd(const _Operation& __fn, const _Tp& __x) | |
5349 | { | |
5350 | typedef typename _Operation::second_argument_type _Arg2_type; | |
5351 | return binder2nd<_Operation>(__fn, _Arg2_type(__x)); | |
5352 | } | |
5353 | } | |
5354 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
5355 | template<typename _CharT, typename _Traits, typename _Alloc> | |
5356 | class basic_string | |
5357 | { | |
5358 | typedef typename _Alloc::template rebind<_CharT>::other _CharT_alloc_type; | |
5359 | public: | |
5360 | typedef _Traits traits_type; | |
5361 | typedef typename _Traits::char_type value_type; | |
5362 | typedef _Alloc allocator_type; | |
5363 | typedef typename _CharT_alloc_type::size_type size_type; | |
5364 | typedef typename _CharT_alloc_type::difference_type difference_type; | |
5365 | typedef typename _CharT_alloc_type::reference reference; | |
5366 | typedef typename _CharT_alloc_type::const_reference const_reference; | |
5367 | typedef typename _CharT_alloc_type::pointer pointer; | |
5368 | typedef typename _CharT_alloc_type::const_pointer const_pointer; | |
5369 | typedef __gnu_cxx::__normal_iterator<pointer, basic_string> iterator; | |
5370 | typedef __gnu_cxx::__normal_iterator<const_pointer, basic_string> | |
5371 | const_iterator; | |
5372 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
5373 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
5374 | private: | |
5375 | struct _Rep_base | |
5376 | { | |
5377 | size_type _M_length; | |
5378 | size_type _M_capacity; | |
5379 | _Atomic_word _M_refcount; | |
5380 | }; | |
5381 | struct _Rep : _Rep_base | |
5382 | { | |
5383 | typedef typename _Alloc::template rebind<char>::other _Raw_bytes_alloc; | |
5384 | static const size_type _S_max_size; | |
5385 | static const _CharT _S_terminal; | |
5386 | static size_type _S_empty_rep_storage[]; | |
5387 | static _Rep& | |
5388 | _S_empty_rep() | |
5389 | { | |
5390 | void* __p = reinterpret_cast<void*>(&_S_empty_rep_storage); | |
5391 | return *reinterpret_cast<_Rep*>(__p); | |
5392 | } | |
5393 | bool | |
5394 | _M_is_leaked() const | |
5395 | { return this->_M_refcount < 0; } | |
5396 | bool | |
5397 | _M_is_shared() const | |
5398 | { return this->_M_refcount > 0; } | |
5399 | void | |
5400 | _M_set_leaked() | |
5401 | { this->_M_refcount = -1; } | |
5402 | void | |
5403 | _M_set_sharable() | |
5404 | { this->_M_refcount = 0; } | |
5405 | void | |
5406 | _M_set_length_and_sharable(size_type __n) | |
5407 | { | |
5408 | this->_M_set_sharable(); | |
5409 | this->_M_length = __n; | |
5410 | traits_type::assign(this->_M_refdata()[__n], _S_terminal); | |
5411 | } | |
5412 | _CharT* | |
5413 | _M_refdata() throw() | |
5414 | { return reinterpret_cast<_CharT*>(this + 1); } | |
5415 | _CharT* | |
5416 | _M_grab(const _Alloc& __alloc1, const _Alloc& __alloc2) | |
5417 | { | |
5418 | return (!_M_is_leaked() && __alloc1 == __alloc2) | |
5419 | ? _M_refcopy() : _M_clone(__alloc1); | |
5420 | } | |
5421 | static _Rep* | |
5422 | _S_create(size_type, size_type, const _Alloc&); | |
5423 | void | |
5424 | _M_dispose(const _Alloc& __a) | |
5425 | { | |
5426 | if (__builtin_expect(this != &_S_empty_rep(), false)) | |
5427 | if (__gnu_cxx::__exchange_and_add_dispatch(&this->_M_refcount, | |
5428 | -1) <= 0) | |
5429 | _M_destroy(__a); | |
5430 | } | |
5431 | void | |
5432 | _M_destroy(const _Alloc&) throw(); | |
5433 | _CharT* | |
5434 | _M_refcopy() throw() | |
5435 | { | |
5436 | if (__builtin_expect(this != &_S_empty_rep(), false)) | |
5437 | __gnu_cxx::__atomic_add_dispatch(&this->_M_refcount, 1); | |
5438 | return _M_refdata(); | |
5439 | } | |
5440 | _CharT* | |
5441 | _M_clone(const _Alloc&, size_type __res = 0); | |
5442 | }; | |
5443 | struct _Alloc_hider : _Alloc | |
5444 | { | |
5445 | _Alloc_hider(_CharT* __dat, const _Alloc& __a) | |
5446 | : _Alloc(__a), _M_p(__dat) { } | |
5447 | _CharT* _M_p; | |
5448 | }; | |
5449 | public: | |
5450 | static const size_type npos = static_cast<size_type>(-1); | |
5451 | private: | |
5452 | mutable _Alloc_hider _M_dataplus; | |
5453 | _CharT* | |
5454 | _M_data() const | |
5455 | { return _M_dataplus._M_p; } | |
5456 | _CharT* | |
5457 | _M_data(_CharT* __p) | |
5458 | { return (_M_dataplus._M_p = __p); } | |
5459 | _Rep* | |
5460 | _M_rep() const | |
5461 | { return &((reinterpret_cast<_Rep*> (_M_data()))[-1]); } | |
5462 | iterator | |
5463 | _M_ibegin() const | |
5464 | { return iterator(_M_data()); } | |
5465 | iterator | |
5466 | _M_iend() const | |
5467 | { return iterator(_M_data() + this->size()); } | |
5468 | void | |
5469 | _M_leak() | |
5470 | { | |
5471 | if (!_M_rep()->_M_is_leaked()) | |
5472 | _M_leak_hard(); | |
5473 | } | |
5474 | size_type | |
5475 | _M_check(size_type __pos, const char* __s) const | |
5476 | { | |
5477 | if (__pos > this->size()) | |
5478 | __throw_out_of_range((__s)); | |
5479 | return __pos; | |
5480 | } | |
5481 | void | |
5482 | _M_check_length(size_type __n1, size_type __n2, const char* __s) const | |
5483 | { | |
5484 | if (this->max_size() - (this->size() - __n1) < __n2) | |
5485 | __throw_length_error((__s)); | |
5486 | } | |
5487 | size_type | |
5488 | _M_limit(size_type __pos, size_type __off) const | |
5489 | { | |
5490 | const bool __testoff = __off < this->size() - __pos; | |
5491 | return __testoff ? __off : this->size() - __pos; | |
5492 | } | |
5493 | bool | |
5494 | _M_disjunct(const _CharT* __s) const | |
5495 | { | |
5496 | return (less<const _CharT*>()(__s, _M_data()) | |
5497 | || less<const _CharT*>()(_M_data() + this->size(), __s)); | |
5498 | } | |
5499 | static void | |
5500 | _M_copy(_CharT* __d, const _CharT* __s, size_type __n) | |
5501 | { | |
5502 | if (__n == 1) | |
5503 | traits_type::assign(*__d, *__s); | |
5504 | else | |
5505 | traits_type::copy(__d, __s, __n); | |
5506 | } | |
5507 | static void | |
5508 | _M_move(_CharT* __d, const _CharT* __s, size_type __n) | |
5509 | { | |
5510 | if (__n == 1) | |
5511 | traits_type::assign(*__d, *__s); | |
5512 | else | |
5513 | traits_type::move(__d, __s, __n); | |
5514 | } | |
5515 | static void | |
5516 | _M_assign(_CharT* __d, size_type __n, _CharT __c) | |
5517 | { | |
5518 | if (__n == 1) | |
5519 | traits_type::assign(*__d, __c); | |
5520 | else | |
5521 | traits_type::assign(__d, __n, __c); | |
5522 | } | |
5523 | template<class _Iterator> | |
5524 | static void | |
5525 | _S_copy_chars(_CharT* __p, _Iterator __k1, _Iterator __k2) | |
5526 | { | |
5527 | for (; __k1 != __k2; ++__k1, ++__p) | |
5528 | traits_type::assign(*__p, *__k1); | |
5529 | } | |
5530 | static void | |
5531 | _S_copy_chars(_CharT* __p, iterator __k1, iterator __k2) | |
5532 | { _S_copy_chars(__p, __k1.base(), __k2.base()); } | |
5533 | static void | |
5534 | _S_copy_chars(_CharT* __p, const_iterator __k1, const_iterator __k2) | |
5535 | { _S_copy_chars(__p, __k1.base(), __k2.base()); } | |
5536 | static void | |
5537 | _S_copy_chars(_CharT* __p, _CharT* __k1, _CharT* __k2) | |
5538 | { _M_copy(__p, __k1, __k2 - __k1); } | |
5539 | static void | |
5540 | _S_copy_chars(_CharT* __p, const _CharT* __k1, const _CharT* __k2) | |
5541 | { _M_copy(__p, __k1, __k2 - __k1); } | |
5542 | static int | |
5543 | _S_compare(size_type __n1, size_type __n2) | |
5544 | { | |
5545 | const difference_type __d = difference_type(__n1 - __n2); | |
5546 | if (__d > __gnu_cxx::__numeric_traits<int>::__max) | |
5547 | return __gnu_cxx::__numeric_traits<int>::__max; | |
5548 | else if (__d < __gnu_cxx::__numeric_traits<int>::__min) | |
5549 | return __gnu_cxx::__numeric_traits<int>::__min; | |
5550 | else | |
5551 | return int(__d); | |
5552 | } | |
5553 | void | |
5554 | _M_mutate(size_type __pos, size_type __len1, size_type __len2); | |
5555 | void | |
5556 | _M_leak_hard(); | |
5557 | static _Rep& | |
5558 | _S_empty_rep() | |
5559 | { return _Rep::_S_empty_rep(); } | |
5560 | public: | |
5561 | inline | |
5562 | basic_string(); | |
5563 | explicit | |
5564 | basic_string(const _Alloc& __a); | |
5565 | basic_string(const basic_string& __str); | |
5566 | basic_string(const basic_string& __str, size_type __pos, | |
5567 | size_type __n = npos); | |
5568 | basic_string(const basic_string& __str, size_type __pos, | |
5569 | size_type __n, const _Alloc& __a); | |
5570 | basic_string(const _CharT* __s, size_type __n, | |
5571 | const _Alloc& __a = _Alloc()); | |
5572 | basic_string(const _CharT* __s, const _Alloc& __a = _Alloc()); | |
5573 | basic_string(size_type __n, _CharT __c, const _Alloc& __a = _Alloc()); | |
5574 | template<class _InputIterator> | |
5575 | basic_string(_InputIterator __beg, _InputIterator __end, | |
5576 | const _Alloc& __a = _Alloc()); | |
5577 | ~basic_string() | |
5578 | { _M_rep()->_M_dispose(this->get_allocator()); } | |
5579 | basic_string& | |
5580 | operator=(const basic_string& __str) | |
5581 | { return this->assign(__str); } | |
5582 | basic_string& | |
5583 | operator=(const _CharT* __s) | |
5584 | { return this->assign(__s); } | |
5585 | basic_string& | |
5586 | operator=(_CharT __c) | |
5587 | { | |
5588 | this->assign(1, __c); | |
5589 | return *this; | |
5590 | } | |
5591 | iterator | |
5592 | begin() | |
5593 | { | |
5594 | _M_leak(); | |
5595 | return iterator(_M_data()); | |
5596 | } | |
5597 | const_iterator | |
5598 | begin() const | |
5599 | { return const_iterator(_M_data()); } | |
5600 | iterator | |
5601 | end() | |
5602 | { | |
5603 | _M_leak(); | |
5604 | return iterator(_M_data() + this->size()); | |
5605 | } | |
5606 | const_iterator | |
5607 | end() const | |
5608 | { return const_iterator(_M_data() + this->size()); } | |
5609 | reverse_iterator | |
5610 | rbegin() | |
5611 | { return reverse_iterator(this->end()); } | |
5612 | const_reverse_iterator | |
5613 | rbegin() const | |
5614 | { return const_reverse_iterator(this->end()); } | |
5615 | reverse_iterator | |
5616 | rend() | |
5617 | { return reverse_iterator(this->begin()); } | |
5618 | const_reverse_iterator | |
5619 | rend() const | |
5620 | { return const_reverse_iterator(this->begin()); } | |
5621 | public: | |
5622 | size_type | |
5623 | size() const | |
5624 | { return _M_rep()->_M_length; } | |
5625 | size_type | |
5626 | length() const | |
5627 | { return _M_rep()->_M_length; } | |
5628 | size_type | |
5629 | max_size() const | |
5630 | { return _Rep::_S_max_size; } | |
5631 | void | |
5632 | resize(size_type __n, _CharT __c); | |
5633 | void | |
5634 | resize(size_type __n) | |
5635 | { this->resize(__n, _CharT()); } | |
5636 | size_type | |
5637 | capacity() const | |
5638 | { return _M_rep()->_M_capacity; } | |
5639 | void | |
5640 | reserve(size_type __res_arg = 0); | |
5641 | void | |
5642 | clear() | |
5643 | { _M_mutate(0, this->size(), 0); } | |
5644 | bool | |
5645 | empty() const | |
5646 | { return this->size() == 0; } | |
5647 | const_reference | |
5648 | operator[] (size_type __pos) const | |
5649 | { | |
5650 | ; | |
5651 | return _M_data()[__pos]; | |
5652 | } | |
5653 | reference | |
5654 | operator[](size_type __pos) | |
5655 | { | |
5656 | ; | |
5657 | ; | |
5658 | _M_leak(); | |
5659 | return _M_data()[__pos]; | |
5660 | } | |
5661 | const_reference | |
5662 | at(size_type __n) const | |
5663 | { | |
5664 | if (__n >= this->size()) | |
5665 | __throw_out_of_range(("basic_string::at")); | |
5666 | return _M_data()[__n]; | |
5667 | } | |
5668 | reference | |
5669 | at(size_type __n) | |
5670 | { | |
5671 | if (__n >= size()) | |
5672 | __throw_out_of_range(("basic_string::at")); | |
5673 | _M_leak(); | |
5674 | return _M_data()[__n]; | |
5675 | } | |
5676 | basic_string& | |
5677 | operator+=(const basic_string& __str) | |
5678 | { return this->append(__str); } | |
5679 | basic_string& | |
5680 | operator+=(const _CharT* __s) | |
5681 | { return this->append(__s); } | |
5682 | basic_string& | |
5683 | operator+=(_CharT __c) | |
5684 | { | |
5685 | this->push_back(__c); | |
5686 | return *this; | |
5687 | } | |
5688 | basic_string& | |
5689 | append(const basic_string& __str); | |
5690 | basic_string& | |
5691 | append(const basic_string& __str, size_type __pos, size_type __n); | |
5692 | basic_string& | |
5693 | append(const _CharT* __s, size_type __n); | |
5694 | basic_string& | |
5695 | append(const _CharT* __s) | |
5696 | { | |
5697 | ; | |
5698 | return this->append(__s, traits_type::length(__s)); | |
5699 | } | |
5700 | basic_string& | |
5701 | append(size_type __n, _CharT __c); | |
5702 | template<class _InputIterator> | |
5703 | basic_string& | |
5704 | append(_InputIterator __first, _InputIterator __last) | |
5705 | { return this->replace(_M_iend(), _M_iend(), __first, __last); } | |
5706 | void | |
5707 | push_back(_CharT __c) | |
5708 | { | |
5709 | const size_type __len = 1 + this->size(); | |
5710 | if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
5711 | this->reserve(__len); | |
5712 | traits_type::assign(_M_data()[this->size()], __c); | |
5713 | _M_rep()->_M_set_length_and_sharable(__len); | |
5714 | } | |
5715 | basic_string& | |
5716 | assign(const basic_string& __str); | |
5717 | basic_string& | |
5718 | assign(const basic_string& __str, size_type __pos, size_type __n) | |
5719 | { return this->assign(__str._M_data() | |
5720 | + __str._M_check(__pos, "basic_string::assign"), | |
5721 | __str._M_limit(__pos, __n)); } | |
5722 | basic_string& | |
5723 | assign(const _CharT* __s, size_type __n); | |
5724 | basic_string& | |
5725 | assign(const _CharT* __s) | |
5726 | { | |
5727 | ; | |
5728 | return this->assign(__s, traits_type::length(__s)); | |
5729 | } | |
5730 | basic_string& | |
5731 | assign(size_type __n, _CharT __c) | |
5732 | { return _M_replace_aux(size_type(0), this->size(), __n, __c); } | |
5733 | template<class _InputIterator> | |
5734 | basic_string& | |
5735 | assign(_InputIterator __first, _InputIterator __last) | |
5736 | { return this->replace(_M_ibegin(), _M_iend(), __first, __last); } | |
5737 | void | |
5738 | insert(iterator __p, size_type __n, _CharT __c) | |
5739 | { this->replace(__p, __p, __n, __c); } | |
5740 | template<class _InputIterator> | |
5741 | void | |
5742 | insert(iterator __p, _InputIterator __beg, _InputIterator __end) | |
5743 | { this->replace(__p, __p, __beg, __end); } | |
5744 | basic_string& | |
5745 | insert(size_type __pos1, const basic_string& __str) | |
5746 | { return this->insert(__pos1, __str, size_type(0), __str.size()); } | |
5747 | basic_string& | |
5748 | insert(size_type __pos1, const basic_string& __str, | |
5749 | size_type __pos2, size_type __n) | |
5750 | { return this->insert(__pos1, __str._M_data() | |
5751 | + __str._M_check(__pos2, "basic_string::insert"), | |
5752 | __str._M_limit(__pos2, __n)); } | |
5753 | basic_string& | |
5754 | insert(size_type __pos, const _CharT* __s, size_type __n); | |
5755 | basic_string& | |
5756 | insert(size_type __pos, const _CharT* __s) | |
5757 | { | |
5758 | ; | |
5759 | return this->insert(__pos, __s, traits_type::length(__s)); | |
5760 | } | |
5761 | basic_string& | |
5762 | insert(size_type __pos, size_type __n, _CharT __c) | |
5763 | { return _M_replace_aux(_M_check(__pos, "basic_string::insert"), | |
5764 | size_type(0), __n, __c); } | |
5765 | iterator | |
5766 | insert(iterator __p, _CharT __c) | |
5767 | { | |
5768 | ; | |
5769 | const size_type __pos = __p - _M_ibegin(); | |
5770 | _M_replace_aux(__pos, size_type(0), size_type(1), __c); | |
5771 | _M_rep()->_M_set_leaked(); | |
5772 | return iterator(_M_data() + __pos); | |
5773 | } | |
5774 | basic_string& | |
5775 | erase(size_type __pos = 0, size_type __n = npos) | |
5776 | { | |
5777 | _M_mutate(_M_check(__pos, "basic_string::erase"), | |
5778 | _M_limit(__pos, __n), size_type(0)); | |
5779 | return *this; | |
5780 | } | |
5781 | iterator | |
5782 | erase(iterator __position) | |
5783 | { | |
5784 | ; | |
5785 | const size_type __pos = __position - _M_ibegin(); | |
5786 | _M_mutate(__pos, size_type(1), size_type(0)); | |
5787 | _M_rep()->_M_set_leaked(); | |
5788 | return iterator(_M_data() + __pos); | |
5789 | } | |
5790 | iterator | |
5791 | erase(iterator __first, iterator __last) | |
5792 | { | |
5793 | ; | |
5794 | const size_type __pos = __first - _M_ibegin(); | |
5795 | _M_mutate(__pos, __last - __first, size_type(0)); | |
5796 | _M_rep()->_M_set_leaked(); | |
5797 | return iterator(_M_data() + __pos); | |
5798 | } | |
5799 | basic_string& | |
5800 | replace(size_type __pos, size_type __n, const basic_string& __str) | |
5801 | { return this->replace(__pos, __n, __str._M_data(), __str.size()); } | |
5802 | basic_string& | |
5803 | replace(size_type __pos1, size_type __n1, const basic_string& __str, | |
5804 | size_type __pos2, size_type __n2) | |
5805 | { return this->replace(__pos1, __n1, __str._M_data() | |
5806 | + __str._M_check(__pos2, "basic_string::replace"), | |
5807 | __str._M_limit(__pos2, __n2)); } | |
5808 | basic_string& | |
5809 | replace(size_type __pos, size_type __n1, const _CharT* __s, | |
5810 | size_type __n2); | |
5811 | basic_string& | |
5812 | replace(size_type __pos, size_type __n1, const _CharT* __s) | |
5813 | { | |
5814 | ; | |
5815 | return this->replace(__pos, __n1, __s, traits_type::length(__s)); | |
5816 | } | |
5817 | basic_string& | |
5818 | replace(size_type __pos, size_type __n1, size_type __n2, _CharT __c) | |
5819 | { return _M_replace_aux(_M_check(__pos, "basic_string::replace"), | |
5820 | _M_limit(__pos, __n1), __n2, __c); } | |
5821 | basic_string& | |
5822 | replace(iterator __i1, iterator __i2, const basic_string& __str) | |
5823 | { return this->replace(__i1, __i2, __str._M_data(), __str.size()); } | |
5824 | basic_string& | |
5825 | replace(iterator __i1, iterator __i2, const _CharT* __s, size_type __n) | |
5826 | { | |
5827 | ; | |
5828 | return this->replace(__i1 - _M_ibegin(), __i2 - __i1, __s, __n); | |
5829 | } | |
5830 | basic_string& | |
5831 | replace(iterator __i1, iterator __i2, const _CharT* __s) | |
5832 | { | |
5833 | ; | |
5834 | return this->replace(__i1, __i2, __s, traits_type::length(__s)); | |
5835 | } | |
5836 | basic_string& | |
5837 | replace(iterator __i1, iterator __i2, size_type __n, _CharT __c) | |
5838 | { | |
5839 | ; | |
5840 | return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __c); | |
5841 | } | |
5842 | template<class _InputIterator> | |
5843 | basic_string& | |
5844 | replace(iterator __i1, iterator __i2, | |
5845 | _InputIterator __k1, _InputIterator __k2) | |
5846 | { | |
5847 | ; | |
5848 | ; | |
5849 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
5850 | return _M_replace_dispatch(__i1, __i2, __k1, __k2, _Integral()); | |
5851 | } | |
5852 | basic_string& | |
5853 | replace(iterator __i1, iterator __i2, _CharT* __k1, _CharT* __k2) | |
5854 | { | |
5855 | ; | |
5856 | ; | |
5857 | return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
5858 | __k1, __k2 - __k1); | |
5859 | } | |
5860 | basic_string& | |
5861 | replace(iterator __i1, iterator __i2, | |
5862 | const _CharT* __k1, const _CharT* __k2) | |
5863 | { | |
5864 | ; | |
5865 | ; | |
5866 | return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
5867 | __k1, __k2 - __k1); | |
5868 | } | |
5869 | basic_string& | |
5870 | replace(iterator __i1, iterator __i2, iterator __k1, iterator __k2) | |
5871 | { | |
5872 | ; | |
5873 | ; | |
5874 | return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
5875 | __k1.base(), __k2 - __k1); | |
5876 | } | |
5877 | basic_string& | |
5878 | replace(iterator __i1, iterator __i2, | |
5879 | const_iterator __k1, const_iterator __k2) | |
5880 | { | |
5881 | ; | |
5882 | ; | |
5883 | return this->replace(__i1 - _M_ibegin(), __i2 - __i1, | |
5884 | __k1.base(), __k2 - __k1); | |
5885 | } | |
5886 | private: | |
5887 | template<class _Integer> | |
5888 | basic_string& | |
5889 | _M_replace_dispatch(iterator __i1, iterator __i2, _Integer __n, | |
5890 | _Integer __val, __true_type) | |
5891 | { return _M_replace_aux(__i1 - _M_ibegin(), __i2 - __i1, __n, __val); } | |
5892 | template<class _InputIterator> | |
5893 | basic_string& | |
5894 | _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, | |
5895 | _InputIterator __k2, __false_type); | |
5896 | basic_string& | |
5897 | _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, | |
5898 | _CharT __c); | |
5899 | basic_string& | |
5900 | _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, | |
5901 | size_type __n2); | |
5902 | template<class _InIterator> | |
5903 | static _CharT* | |
5904 | _S_construct_aux(_InIterator __beg, _InIterator __end, | |
5905 | const _Alloc& __a, __false_type) | |
5906 | { | |
5907 | typedef typename iterator_traits<_InIterator>::iterator_category _Tag; | |
5908 | return _S_construct(__beg, __end, __a, _Tag()); | |
5909 | } | |
5910 | template<class _Integer> | |
5911 | static _CharT* | |
5912 | _S_construct_aux(_Integer __beg, _Integer __end, | |
5913 | const _Alloc& __a, __true_type) | |
5914 | { return _S_construct(static_cast<size_type>(__beg), __end, __a); } | |
5915 | template<class _InIterator> | |
5916 | static _CharT* | |
5917 | _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a) | |
5918 | { | |
5919 | typedef typename std::__is_integer<_InIterator>::__type _Integral; | |
5920 | return _S_construct_aux(__beg, __end, __a, _Integral()); | |
5921 | } | |
5922 | template<class _InIterator> | |
5923 | static _CharT* | |
5924 | _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, | |
5925 | input_iterator_tag); | |
5926 | template<class _FwdIterator> | |
5927 | static _CharT* | |
5928 | _S_construct(_FwdIterator __beg, _FwdIterator __end, const _Alloc& __a, | |
5929 | forward_iterator_tag); | |
5930 | static _CharT* | |
5931 | _S_construct(size_type __req, _CharT __c, const _Alloc& __a); | |
5932 | public: | |
5933 | size_type | |
5934 | copy(_CharT* __s, size_type __n, size_type __pos = 0) const; | |
5935 | void | |
5936 | swap(basic_string& __s); | |
5937 | const _CharT* | |
5938 | c_str() const | |
5939 | { return _M_data(); } | |
5940 | const _CharT* | |
5941 | data() const | |
5942 | { return _M_data(); } | |
5943 | allocator_type | |
5944 | get_allocator() const | |
5945 | { return _M_dataplus; } | |
5946 | size_type | |
5947 | find(const _CharT* __s, size_type __pos, size_type __n) const; | |
5948 | size_type | |
5949 | find(const basic_string& __str, size_type __pos = 0) const | |
5950 | { return this->find(__str.data(), __pos, __str.size()); } | |
5951 | size_type | |
5952 | find(const _CharT* __s, size_type __pos = 0) const | |
5953 | { | |
5954 | ; | |
5955 | return this->find(__s, __pos, traits_type::length(__s)); | |
5956 | } | |
5957 | size_type | |
5958 | find(_CharT __c, size_type __pos = 0) const; | |
5959 | size_type | |
5960 | rfind(const basic_string& __str, size_type __pos = npos) const | |
5961 | { return this->rfind(__str.data(), __pos, __str.size()); } | |
5962 | size_type | |
5963 | rfind(const _CharT* __s, size_type __pos, size_type __n) const; | |
5964 | size_type | |
5965 | rfind(const _CharT* __s, size_type __pos = npos) const | |
5966 | { | |
5967 | ; | |
5968 | return this->rfind(__s, __pos, traits_type::length(__s)); | |
5969 | } | |
5970 | size_type | |
5971 | rfind(_CharT __c, size_type __pos = npos) const; | |
5972 | size_type | |
5973 | find_first_of(const basic_string& __str, size_type __pos = 0) const | |
5974 | { return this->find_first_of(__str.data(), __pos, __str.size()); } | |
5975 | size_type | |
5976 | find_first_of(const _CharT* __s, size_type __pos, size_type __n) const; | |
5977 | size_type | |
5978 | find_first_of(const _CharT* __s, size_type __pos = 0) const | |
5979 | { | |
5980 | ; | |
5981 | return this->find_first_of(__s, __pos, traits_type::length(__s)); | |
5982 | } | |
5983 | size_type | |
5984 | find_first_of(_CharT __c, size_type __pos = 0) const | |
5985 | { return this->find(__c, __pos); } | |
5986 | size_type | |
5987 | find_last_of(const basic_string& __str, size_type __pos = npos) const | |
5988 | { return this->find_last_of(__str.data(), __pos, __str.size()); } | |
5989 | size_type | |
5990 | find_last_of(const _CharT* __s, size_type __pos, size_type __n) const; | |
5991 | size_type | |
5992 | find_last_of(const _CharT* __s, size_type __pos = npos) const | |
5993 | { | |
5994 | ; | |
5995 | return this->find_last_of(__s, __pos, traits_type::length(__s)); | |
5996 | } | |
5997 | size_type | |
5998 | find_last_of(_CharT __c, size_type __pos = npos) const | |
5999 | { return this->rfind(__c, __pos); } | |
6000 | size_type | |
6001 | find_first_not_of(const basic_string& __str, size_type __pos = 0) const | |
6002 | { return this->find_first_not_of(__str.data(), __pos, __str.size()); } | |
6003 | size_type | |
6004 | find_first_not_of(const _CharT* __s, size_type __pos, | |
6005 | size_type __n) const; | |
6006 | size_type | |
6007 | find_first_not_of(const _CharT* __s, size_type __pos = 0) const | |
6008 | { | |
6009 | ; | |
6010 | return this->find_first_not_of(__s, __pos, traits_type::length(__s)); | |
6011 | } | |
6012 | size_type | |
6013 | find_first_not_of(_CharT __c, size_type __pos = 0) const; | |
6014 | size_type | |
6015 | find_last_not_of(const basic_string& __str, size_type __pos = npos) const | |
6016 | { return this->find_last_not_of(__str.data(), __pos, __str.size()); } | |
6017 | size_type | |
6018 | find_last_not_of(const _CharT* __s, size_type __pos, | |
6019 | size_type __n) const; | |
6020 | size_type | |
6021 | find_last_not_of(const _CharT* __s, size_type __pos = npos) const | |
6022 | { | |
6023 | ; | |
6024 | return this->find_last_not_of(__s, __pos, traits_type::length(__s)); | |
6025 | } | |
6026 | size_type | |
6027 | find_last_not_of(_CharT __c, size_type __pos = npos) const; | |
6028 | basic_string | |
6029 | substr(size_type __pos = 0, size_type __n = npos) const | |
6030 | { return basic_string(*this, | |
6031 | _M_check(__pos, "basic_string::substr"), __n); } | |
6032 | int | |
6033 | compare(const basic_string& __str) const | |
6034 | { | |
6035 | const size_type __size = this->size(); | |
6036 | const size_type __osize = __str.size(); | |
6037 | const size_type __len = std::min(__size, __osize); | |
6038 | int __r = traits_type::compare(_M_data(), __str.data(), __len); | |
6039 | if (!__r) | |
6040 | __r = _S_compare(__size, __osize); | |
6041 | return __r; | |
6042 | } | |
6043 | int | |
6044 | compare(size_type __pos, size_type __n, const basic_string& __str) const; | |
6045 | int | |
6046 | compare(size_type __pos1, size_type __n1, const basic_string& __str, | |
6047 | size_type __pos2, size_type __n2) const; | |
6048 | int | |
6049 | compare(const _CharT* __s) const; | |
6050 | int | |
6051 | compare(size_type __pos, size_type __n1, const _CharT* __s) const; | |
6052 | int | |
6053 | compare(size_type __pos, size_type __n1, const _CharT* __s, | |
6054 | size_type __n2) const; | |
6055 | }; | |
6056 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6057 | inline basic_string<_CharT, _Traits, _Alloc>:: | |
6058 | basic_string() | |
6059 | : _M_dataplus(_S_empty_rep()._M_refdata(), _Alloc()) { } | |
6060 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6061 | basic_string<_CharT, _Traits, _Alloc> | |
6062 | operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6063 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6064 | { | |
6065 | basic_string<_CharT, _Traits, _Alloc> __str(__lhs); | |
6066 | __str.append(__rhs); | |
6067 | return __str; | |
6068 | } | |
6069 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6070 | basic_string<_CharT,_Traits,_Alloc> | |
6071 | operator+(const _CharT* __lhs, | |
6072 | const basic_string<_CharT,_Traits,_Alloc>& __rhs); | |
6073 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6074 | basic_string<_CharT,_Traits,_Alloc> | |
6075 | operator+(_CharT __lhs, const basic_string<_CharT,_Traits,_Alloc>& __rhs); | |
6076 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6077 | inline basic_string<_CharT, _Traits, _Alloc> | |
6078 | operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6079 | const _CharT* __rhs) | |
6080 | { | |
6081 | basic_string<_CharT, _Traits, _Alloc> __str(__lhs); | |
6082 | __str.append(__rhs); | |
6083 | return __str; | |
6084 | } | |
6085 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6086 | inline basic_string<_CharT, _Traits, _Alloc> | |
6087 | operator+(const basic_string<_CharT, _Traits, _Alloc>& __lhs, _CharT __rhs) | |
6088 | { | |
6089 | typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
6090 | typedef typename __string_type::size_type __size_type; | |
6091 | __string_type __str(__lhs); | |
6092 | __str.append(__size_type(1), __rhs); | |
6093 | return __str; | |
6094 | } | |
6095 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6096 | inline bool | |
6097 | operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6098 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6099 | { return __lhs.compare(__rhs) == 0; } | |
6100 | template<typename _CharT> | |
6101 | inline | |
6102 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, bool>::__type | |
6103 | operator==(const basic_string<_CharT>& __lhs, | |
6104 | const basic_string<_CharT>& __rhs) | |
6105 | { return (__lhs.size() == __rhs.size() | |
6106 | && !std::char_traits<_CharT>::compare(__lhs.data(), __rhs.data(), | |
6107 | __lhs.size())); } | |
6108 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6109 | inline bool | |
6110 | operator==(const _CharT* __lhs, | |
6111 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6112 | { return __rhs.compare(__lhs) == 0; } | |
6113 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6114 | inline bool | |
6115 | operator==(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6116 | const _CharT* __rhs) | |
6117 | { return __lhs.compare(__rhs) == 0; } | |
6118 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6119 | inline bool | |
6120 | operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6121 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6122 | { return !(__lhs == __rhs); } | |
6123 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6124 | inline bool | |
6125 | operator!=(const _CharT* __lhs, | |
6126 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6127 | { return !(__lhs == __rhs); } | |
6128 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6129 | inline bool | |
6130 | operator!=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6131 | const _CharT* __rhs) | |
6132 | { return !(__lhs == __rhs); } | |
6133 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6134 | inline bool | |
6135 | operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6136 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6137 | { return __lhs.compare(__rhs) < 0; } | |
6138 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6139 | inline bool | |
6140 | operator<(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6141 | const _CharT* __rhs) | |
6142 | { return __lhs.compare(__rhs) < 0; } | |
6143 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6144 | inline bool | |
6145 | operator<(const _CharT* __lhs, | |
6146 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6147 | { return __rhs.compare(__lhs) > 0; } | |
6148 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6149 | inline bool | |
6150 | operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6151 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6152 | { return __lhs.compare(__rhs) > 0; } | |
6153 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6154 | inline bool | |
6155 | operator>(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6156 | const _CharT* __rhs) | |
6157 | { return __lhs.compare(__rhs) > 0; } | |
6158 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6159 | inline bool | |
6160 | operator>(const _CharT* __lhs, | |
6161 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6162 | { return __rhs.compare(__lhs) < 0; } | |
6163 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6164 | inline bool | |
6165 | operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6166 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6167 | { return __lhs.compare(__rhs) <= 0; } | |
6168 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6169 | inline bool | |
6170 | operator<=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6171 | const _CharT* __rhs) | |
6172 | { return __lhs.compare(__rhs) <= 0; } | |
6173 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6174 | inline bool | |
6175 | operator<=(const _CharT* __lhs, | |
6176 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6177 | { return __rhs.compare(__lhs) >= 0; } | |
6178 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6179 | inline bool | |
6180 | operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6181 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6182 | { return __lhs.compare(__rhs) >= 0; } | |
6183 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6184 | inline bool | |
6185 | operator>=(const basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6186 | const _CharT* __rhs) | |
6187 | { return __lhs.compare(__rhs) >= 0; } | |
6188 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6189 | inline bool | |
6190 | operator>=(const _CharT* __lhs, | |
6191 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6192 | { return __rhs.compare(__lhs) <= 0; } | |
6193 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6194 | inline void | |
6195 | swap(basic_string<_CharT, _Traits, _Alloc>& __lhs, | |
6196 | basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6197 | { __lhs.swap(__rhs); } | |
6198 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6199 | basic_istream<_CharT, _Traits>& | |
6200 | operator>>(basic_istream<_CharT, _Traits>& __is, | |
6201 | basic_string<_CharT, _Traits, _Alloc>& __str); | |
6202 | template<> | |
6203 | basic_istream<char>& | |
6204 | operator>>(basic_istream<char>& __is, basic_string<char>& __str); | |
6205 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6206 | inline basic_ostream<_CharT, _Traits>& | |
6207 | operator<<(basic_ostream<_CharT, _Traits>& __os, | |
6208 | const basic_string<_CharT, _Traits, _Alloc>& __str) | |
6209 | { | |
6210 | return __ostream_insert(__os, __str.data(), __str.size()); | |
6211 | } | |
6212 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6213 | basic_istream<_CharT, _Traits>& | |
6214 | getline(basic_istream<_CharT, _Traits>& __is, | |
6215 | basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim); | |
6216 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6217 | inline basic_istream<_CharT, _Traits>& | |
6218 | getline(basic_istream<_CharT, _Traits>& __is, | |
6219 | basic_string<_CharT, _Traits, _Alloc>& __str) | |
6220 | { return getline(__is, __str, __is.widen('\n')); } | |
6221 | template<> | |
6222 | basic_istream<char>& | |
6223 | getline(basic_istream<char>& __in, basic_string<char>& __str, | |
6224 | char __delim); | |
6225 | } | |
6226 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
6227 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6228 | const typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6229 | basic_string<_CharT, _Traits, _Alloc>:: | |
6230 | _Rep::_S_max_size = (((npos - sizeof(_Rep_base))/sizeof(_CharT)) - 1) / 4; | |
6231 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6232 | const _CharT | |
6233 | basic_string<_CharT, _Traits, _Alloc>:: | |
6234 | _Rep::_S_terminal = _CharT(); | |
6235 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6236 | const typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6237 | basic_string<_CharT, _Traits, _Alloc>::npos; | |
6238 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6239 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6240 | basic_string<_CharT, _Traits, _Alloc>::_Rep::_S_empty_rep_storage[ | |
6241 | (sizeof(_Rep_base) + sizeof(_CharT) + sizeof(size_type) - 1) / | |
6242 | sizeof(size_type)]; | |
6243 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6244 | template<typename _InIterator> | |
6245 | _CharT* | |
6246 | basic_string<_CharT, _Traits, _Alloc>:: | |
6247 | _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, | |
6248 | input_iterator_tag) | |
6249 | { | |
6250 | if (__beg == __end && __a == _Alloc()) | |
6251 | return _S_empty_rep()._M_refdata(); | |
6252 | _CharT __buf[128]; | |
6253 | size_type __len = 0; | |
6254 | while (__beg != __end && __len < sizeof(__buf) / sizeof(_CharT)) | |
6255 | { | |
6256 | __buf[__len++] = *__beg; | |
6257 | ++__beg; | |
6258 | } | |
6259 | _Rep* __r = _Rep::_S_create(__len, size_type(0), __a); | |
6260 | _M_copy(__r->_M_refdata(), __buf, __len); | |
6261 | try | |
6262 | { | |
6263 | while (__beg != __end) | |
6264 | { | |
6265 | if (__len == __r->_M_capacity) | |
6266 | { | |
6267 | _Rep* __another = _Rep::_S_create(__len + 1, __len, __a); | |
6268 | _M_copy(__another->_M_refdata(), __r->_M_refdata(), __len); | |
6269 | __r->_M_destroy(__a); | |
6270 | __r = __another; | |
6271 | } | |
6272 | __r->_M_refdata()[__len++] = *__beg; | |
6273 | ++__beg; | |
6274 | } | |
6275 | } | |
6276 | catch(...) | |
6277 | { | |
6278 | __r->_M_destroy(__a); | |
6279 | throw; | |
6280 | } | |
6281 | __r->_M_set_length_and_sharable(__len); | |
6282 | return __r->_M_refdata(); | |
6283 | } | |
6284 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6285 | template <typename _InIterator> | |
6286 | _CharT* | |
6287 | basic_string<_CharT, _Traits, _Alloc>:: | |
6288 | _S_construct(_InIterator __beg, _InIterator __end, const _Alloc& __a, | |
6289 | forward_iterator_tag) | |
6290 | { | |
6291 | if (__beg == __end && __a == _Alloc()) | |
6292 | return _S_empty_rep()._M_refdata(); | |
6293 | if (__builtin_expect(__gnu_cxx::__is_null_pointer(__beg) | |
6294 | && __beg != __end, 0)) | |
6295 | __throw_logic_error(("basic_string::_S_construct NULL not valid")); | |
6296 | const size_type __dnew = static_cast<size_type>(std::distance(__beg, | |
6297 | __end)); | |
6298 | _Rep* __r = _Rep::_S_create(__dnew, size_type(0), __a); | |
6299 | try | |
6300 | { _S_copy_chars(__r->_M_refdata(), __beg, __end); } | |
6301 | catch(...) | |
6302 | { | |
6303 | __r->_M_destroy(__a); | |
6304 | throw; | |
6305 | } | |
6306 | __r->_M_set_length_and_sharable(__dnew); | |
6307 | return __r->_M_refdata(); | |
6308 | } | |
6309 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6310 | _CharT* | |
6311 | basic_string<_CharT, _Traits, _Alloc>:: | |
6312 | _S_construct(size_type __n, _CharT __c, const _Alloc& __a) | |
6313 | { | |
6314 | if (__n == 0 && __a == _Alloc()) | |
6315 | return _S_empty_rep()._M_refdata(); | |
6316 | _Rep* __r = _Rep::_S_create(__n, size_type(0), __a); | |
6317 | if (__n) | |
6318 | _M_assign(__r->_M_refdata(), __n, __c); | |
6319 | __r->_M_set_length_and_sharable(__n); | |
6320 | return __r->_M_refdata(); | |
6321 | } | |
6322 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6323 | basic_string<_CharT, _Traits, _Alloc>:: | |
6324 | basic_string(const basic_string& __str) | |
6325 | : _M_dataplus(__str._M_rep()->_M_grab(_Alloc(__str.get_allocator()), | |
6326 | __str.get_allocator()), | |
6327 | __str.get_allocator()) | |
6328 | { } | |
6329 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6330 | basic_string<_CharT, _Traits, _Alloc>:: | |
6331 | basic_string(const _Alloc& __a) | |
6332 | : _M_dataplus(_S_construct(size_type(), _CharT(), __a), __a) | |
6333 | { } | |
6334 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6335 | basic_string<_CharT, _Traits, _Alloc>:: | |
6336 | basic_string(const basic_string& __str, size_type __pos, size_type __n) | |
6337 | : _M_dataplus(_S_construct(__str._M_data() | |
6338 | + __str._M_check(__pos, | |
6339 | "basic_string::basic_string"), | |
6340 | __str._M_data() + __str._M_limit(__pos, __n) | |
6341 | + __pos, _Alloc()), _Alloc()) | |
6342 | { } | |
6343 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6344 | basic_string<_CharT, _Traits, _Alloc>:: | |
6345 | basic_string(const basic_string& __str, size_type __pos, | |
6346 | size_type __n, const _Alloc& __a) | |
6347 | : _M_dataplus(_S_construct(__str._M_data() | |
6348 | + __str._M_check(__pos, | |
6349 | "basic_string::basic_string"), | |
6350 | __str._M_data() + __str._M_limit(__pos, __n) | |
6351 | + __pos, __a), __a) | |
6352 | { } | |
6353 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6354 | basic_string<_CharT, _Traits, _Alloc>:: | |
6355 | basic_string(const _CharT* __s, size_type __n, const _Alloc& __a) | |
6356 | : _M_dataplus(_S_construct(__s, __s + __n, __a), __a) | |
6357 | { } | |
6358 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6359 | basic_string<_CharT, _Traits, _Alloc>:: | |
6360 | basic_string(const _CharT* __s, const _Alloc& __a) | |
6361 | : _M_dataplus(_S_construct(__s, __s ? __s + traits_type::length(__s) : | |
6362 | __s + npos, __a), __a) | |
6363 | { } | |
6364 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6365 | basic_string<_CharT, _Traits, _Alloc>:: | |
6366 | basic_string(size_type __n, _CharT __c, const _Alloc& __a) | |
6367 | : _M_dataplus(_S_construct(__n, __c, __a), __a) | |
6368 | { } | |
6369 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6370 | template<typename _InputIterator> | |
6371 | basic_string<_CharT, _Traits, _Alloc>:: | |
6372 | basic_string(_InputIterator __beg, _InputIterator __end, const _Alloc& __a) | |
6373 | : _M_dataplus(_S_construct(__beg, __end, __a), __a) | |
6374 | { } | |
6375 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6376 | basic_string<_CharT, _Traits, _Alloc>& | |
6377 | basic_string<_CharT, _Traits, _Alloc>:: | |
6378 | assign(const basic_string& __str) | |
6379 | { | |
6380 | if (_M_rep() != __str._M_rep()) | |
6381 | { | |
6382 | const allocator_type __a = this->get_allocator(); | |
6383 | _CharT* __tmp = __str._M_rep()->_M_grab(__a, __str.get_allocator()); | |
6384 | _M_rep()->_M_dispose(__a); | |
6385 | _M_data(__tmp); | |
6386 | } | |
6387 | return *this; | |
6388 | } | |
6389 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6390 | basic_string<_CharT, _Traits, _Alloc>& | |
6391 | basic_string<_CharT, _Traits, _Alloc>:: | |
6392 | assign(const _CharT* __s, size_type __n) | |
6393 | { | |
6394 | ; | |
6395 | _M_check_length(this->size(), __n, "basic_string::assign"); | |
6396 | if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) | |
6397 | return _M_replace_safe(size_type(0), this->size(), __s, __n); | |
6398 | else | |
6399 | { | |
6400 | const size_type __pos = __s - _M_data(); | |
6401 | if (__pos >= __n) | |
6402 | _M_copy(_M_data(), __s, __n); | |
6403 | else if (__pos) | |
6404 | _M_move(_M_data(), __s, __n); | |
6405 | _M_rep()->_M_set_length_and_sharable(__n); | |
6406 | return *this; | |
6407 | } | |
6408 | } | |
6409 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6410 | basic_string<_CharT, _Traits, _Alloc>& | |
6411 | basic_string<_CharT, _Traits, _Alloc>:: | |
6412 | append(size_type __n, _CharT __c) | |
6413 | { | |
6414 | if (__n) | |
6415 | { | |
6416 | _M_check_length(size_type(0), __n, "basic_string::append"); | |
6417 | const size_type __len = __n + this->size(); | |
6418 | if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
6419 | this->reserve(__len); | |
6420 | _M_assign(_M_data() + this->size(), __n, __c); | |
6421 | _M_rep()->_M_set_length_and_sharable(__len); | |
6422 | } | |
6423 | return *this; | |
6424 | } | |
6425 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6426 | basic_string<_CharT, _Traits, _Alloc>& | |
6427 | basic_string<_CharT, _Traits, _Alloc>:: | |
6428 | append(const _CharT* __s, size_type __n) | |
6429 | { | |
6430 | ; | |
6431 | if (__n) | |
6432 | { | |
6433 | _M_check_length(size_type(0), __n, "basic_string::append"); | |
6434 | const size_type __len = __n + this->size(); | |
6435 | if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
6436 | { | |
6437 | if (_M_disjunct(__s)) | |
6438 | this->reserve(__len); | |
6439 | else | |
6440 | { | |
6441 | const size_type __off = __s - _M_data(); | |
6442 | this->reserve(__len); | |
6443 | __s = _M_data() + __off; | |
6444 | } | |
6445 | } | |
6446 | _M_copy(_M_data() + this->size(), __s, __n); | |
6447 | _M_rep()->_M_set_length_and_sharable(__len); | |
6448 | } | |
6449 | return *this; | |
6450 | } | |
6451 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6452 | basic_string<_CharT, _Traits, _Alloc>& | |
6453 | basic_string<_CharT, _Traits, _Alloc>:: | |
6454 | append(const basic_string& __str) | |
6455 | { | |
6456 | const size_type __size = __str.size(); | |
6457 | if (__size) | |
6458 | { | |
6459 | const size_type __len = __size + this->size(); | |
6460 | if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
6461 | this->reserve(__len); | |
6462 | _M_copy(_M_data() + this->size(), __str._M_data(), __size); | |
6463 | _M_rep()->_M_set_length_and_sharable(__len); | |
6464 | } | |
6465 | return *this; | |
6466 | } | |
6467 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6468 | basic_string<_CharT, _Traits, _Alloc>& | |
6469 | basic_string<_CharT, _Traits, _Alloc>:: | |
6470 | append(const basic_string& __str, size_type __pos, size_type __n) | |
6471 | { | |
6472 | __str._M_check(__pos, "basic_string::append"); | |
6473 | __n = __str._M_limit(__pos, __n); | |
6474 | if (__n) | |
6475 | { | |
6476 | const size_type __len = __n + this->size(); | |
6477 | if (__len > this->capacity() || _M_rep()->_M_is_shared()) | |
6478 | this->reserve(__len); | |
6479 | _M_copy(_M_data() + this->size(), __str._M_data() + __pos, __n); | |
6480 | _M_rep()->_M_set_length_and_sharable(__len); | |
6481 | } | |
6482 | return *this; | |
6483 | } | |
6484 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6485 | basic_string<_CharT, _Traits, _Alloc>& | |
6486 | basic_string<_CharT, _Traits, _Alloc>:: | |
6487 | insert(size_type __pos, const _CharT* __s, size_type __n) | |
6488 | { | |
6489 | ; | |
6490 | _M_check(__pos, "basic_string::insert"); | |
6491 | _M_check_length(size_type(0), __n, "basic_string::insert"); | |
6492 | if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) | |
6493 | return _M_replace_safe(__pos, size_type(0), __s, __n); | |
6494 | else | |
6495 | { | |
6496 | const size_type __off = __s - _M_data(); | |
6497 | _M_mutate(__pos, 0, __n); | |
6498 | __s = _M_data() + __off; | |
6499 | _CharT* __p = _M_data() + __pos; | |
6500 | if (__s + __n <= __p) | |
6501 | _M_copy(__p, __s, __n); | |
6502 | else if (__s >= __p) | |
6503 | _M_copy(__p, __s + __n, __n); | |
6504 | else | |
6505 | { | |
6506 | const size_type __nleft = __p - __s; | |
6507 | _M_copy(__p, __s, __nleft); | |
6508 | _M_copy(__p + __nleft, __p + __n, __n - __nleft); | |
6509 | } | |
6510 | return *this; | |
6511 | } | |
6512 | } | |
6513 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6514 | basic_string<_CharT, _Traits, _Alloc>& | |
6515 | basic_string<_CharT, _Traits, _Alloc>:: | |
6516 | replace(size_type __pos, size_type __n1, const _CharT* __s, | |
6517 | size_type __n2) | |
6518 | { | |
6519 | ; | |
6520 | _M_check(__pos, "basic_string::replace"); | |
6521 | __n1 = _M_limit(__pos, __n1); | |
6522 | _M_check_length(__n1, __n2, "basic_string::replace"); | |
6523 | bool __left; | |
6524 | if (_M_disjunct(__s) || _M_rep()->_M_is_shared()) | |
6525 | return _M_replace_safe(__pos, __n1, __s, __n2); | |
6526 | else if ((__left = __s + __n2 <= _M_data() + __pos) | |
6527 | || _M_data() + __pos + __n1 <= __s) | |
6528 | { | |
6529 | size_type __off = __s - _M_data(); | |
6530 | __left ? __off : (__off += __n2 - __n1); | |
6531 | _M_mutate(__pos, __n1, __n2); | |
6532 | _M_copy(_M_data() + __pos, _M_data() + __off, __n2); | |
6533 | return *this; | |
6534 | } | |
6535 | else | |
6536 | { | |
6537 | const basic_string __tmp(__s, __n2); | |
6538 | return _M_replace_safe(__pos, __n1, __tmp._M_data(), __n2); | |
6539 | } | |
6540 | } | |
6541 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6542 | void | |
6543 | basic_string<_CharT, _Traits, _Alloc>::_Rep:: | |
6544 | _M_destroy(const _Alloc& __a) throw () | |
6545 | { | |
6546 | const size_type __size = sizeof(_Rep_base) + | |
6547 | (this->_M_capacity + 1) * sizeof(_CharT); | |
6548 | _Raw_bytes_alloc(__a).deallocate(reinterpret_cast<char*>(this), __size); | |
6549 | } | |
6550 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6551 | void | |
6552 | basic_string<_CharT, _Traits, _Alloc>:: | |
6553 | _M_leak_hard() | |
6554 | { | |
6555 | if (_M_rep() == &_S_empty_rep()) | |
6556 | return; | |
6557 | if (_M_rep()->_M_is_shared()) | |
6558 | _M_mutate(0, 0, 0); | |
6559 | _M_rep()->_M_set_leaked(); | |
6560 | } | |
6561 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6562 | void | |
6563 | basic_string<_CharT, _Traits, _Alloc>:: | |
6564 | _M_mutate(size_type __pos, size_type __len1, size_type __len2) | |
6565 | { | |
6566 | const size_type __old_size = this->size(); | |
6567 | const size_type __new_size = __old_size + __len2 - __len1; | |
6568 | const size_type __how_much = __old_size - __pos - __len1; | |
6569 | if (__new_size > this->capacity() || _M_rep()->_M_is_shared()) | |
6570 | { | |
6571 | const allocator_type __a = get_allocator(); | |
6572 | _Rep* __r = _Rep::_S_create(__new_size, this->capacity(), __a); | |
6573 | if (__pos) | |
6574 | _M_copy(__r->_M_refdata(), _M_data(), __pos); | |
6575 | if (__how_much) | |
6576 | _M_copy(__r->_M_refdata() + __pos + __len2, | |
6577 | _M_data() + __pos + __len1, __how_much); | |
6578 | _M_rep()->_M_dispose(__a); | |
6579 | _M_data(__r->_M_refdata()); | |
6580 | } | |
6581 | else if (__how_much && __len1 != __len2) | |
6582 | { | |
6583 | _M_move(_M_data() + __pos + __len2, | |
6584 | _M_data() + __pos + __len1, __how_much); | |
6585 | } | |
6586 | _M_rep()->_M_set_length_and_sharable(__new_size); | |
6587 | } | |
6588 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6589 | void | |
6590 | basic_string<_CharT, _Traits, _Alloc>:: | |
6591 | reserve(size_type __res) | |
6592 | { | |
6593 | if (__res != this->capacity() || _M_rep()->_M_is_shared()) | |
6594 | { | |
6595 | if (__res < this->size()) | |
6596 | __res = this->size(); | |
6597 | const allocator_type __a = get_allocator(); | |
6598 | _CharT* __tmp = _M_rep()->_M_clone(__a, __res - this->size()); | |
6599 | _M_rep()->_M_dispose(__a); | |
6600 | _M_data(__tmp); | |
6601 | } | |
6602 | } | |
6603 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6604 | void | |
6605 | basic_string<_CharT, _Traits, _Alloc>:: | |
6606 | swap(basic_string& __s) | |
6607 | { | |
6608 | if (_M_rep()->_M_is_leaked()) | |
6609 | _M_rep()->_M_set_sharable(); | |
6610 | if (__s._M_rep()->_M_is_leaked()) | |
6611 | __s._M_rep()->_M_set_sharable(); | |
6612 | if (this->get_allocator() == __s.get_allocator()) | |
6613 | { | |
6614 | _CharT* __tmp = _M_data(); | |
6615 | _M_data(__s._M_data()); | |
6616 | __s._M_data(__tmp); | |
6617 | } | |
6618 | else | |
6619 | { | |
6620 | const basic_string __tmp1(_M_ibegin(), _M_iend(), | |
6621 | __s.get_allocator()); | |
6622 | const basic_string __tmp2(__s._M_ibegin(), __s._M_iend(), | |
6623 | this->get_allocator()); | |
6624 | *this = __tmp2; | |
6625 | __s = __tmp1; | |
6626 | } | |
6627 | } | |
6628 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6629 | typename basic_string<_CharT, _Traits, _Alloc>::_Rep* | |
6630 | basic_string<_CharT, _Traits, _Alloc>::_Rep:: | |
6631 | _S_create(size_type __capacity, size_type __old_capacity, | |
6632 | const _Alloc& __alloc) | |
6633 | { | |
6634 | if (__capacity > _S_max_size) | |
6635 | __throw_length_error(("basic_string::_S_create")); | |
6636 | const size_type __pagesize = 4096; | |
6637 | const size_type __malloc_header_size = 4 * sizeof(void*); | |
6638 | if (__capacity > __old_capacity && __capacity < 2 * __old_capacity) | |
6639 | __capacity = 2 * __old_capacity; | |
6640 | size_type __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); | |
6641 | const size_type __adj_size = __size + __malloc_header_size; | |
6642 | if (__adj_size > __pagesize && __capacity > __old_capacity) | |
6643 | { | |
6644 | const size_type __extra = __pagesize - __adj_size % __pagesize; | |
6645 | __capacity += __extra / sizeof(_CharT); | |
6646 | if (__capacity > _S_max_size) | |
6647 | __capacity = _S_max_size; | |
6648 | __size = (__capacity + 1) * sizeof(_CharT) + sizeof(_Rep); | |
6649 | } | |
6650 | void* __place = _Raw_bytes_alloc(__alloc).allocate(__size); | |
6651 | _Rep *__p = new (__place) _Rep; | |
6652 | __p->_M_capacity = __capacity; | |
6653 | __p->_M_set_sharable(); | |
6654 | return __p; | |
6655 | } | |
6656 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6657 | _CharT* | |
6658 | basic_string<_CharT, _Traits, _Alloc>::_Rep:: | |
6659 | _M_clone(const _Alloc& __alloc, size_type __res) | |
6660 | { | |
6661 | const size_type __requested_cap = this->_M_length + __res; | |
6662 | _Rep* __r = _Rep::_S_create(__requested_cap, this->_M_capacity, | |
6663 | __alloc); | |
6664 | if (this->_M_length) | |
6665 | _M_copy(__r->_M_refdata(), _M_refdata(), this->_M_length); | |
6666 | __r->_M_set_length_and_sharable(this->_M_length); | |
6667 | return __r->_M_refdata(); | |
6668 | } | |
6669 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6670 | void | |
6671 | basic_string<_CharT, _Traits, _Alloc>:: | |
6672 | resize(size_type __n, _CharT __c) | |
6673 | { | |
6674 | const size_type __size = this->size(); | |
6675 | _M_check_length(__size, __n, "basic_string::resize"); | |
6676 | if (__size < __n) | |
6677 | this->append(__n - __size, __c); | |
6678 | else if (__n < __size) | |
6679 | this->erase(__n); | |
6680 | } | |
6681 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6682 | template<typename _InputIterator> | |
6683 | basic_string<_CharT, _Traits, _Alloc>& | |
6684 | basic_string<_CharT, _Traits, _Alloc>:: | |
6685 | _M_replace_dispatch(iterator __i1, iterator __i2, _InputIterator __k1, | |
6686 | _InputIterator __k2, __false_type) | |
6687 | { | |
6688 | const basic_string __s(__k1, __k2); | |
6689 | const size_type __n1 = __i2 - __i1; | |
6690 | _M_check_length(__n1, __s.size(), "basic_string::_M_replace_dispatch"); | |
6691 | return _M_replace_safe(__i1 - _M_ibegin(), __n1, __s._M_data(), | |
6692 | __s.size()); | |
6693 | } | |
6694 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6695 | basic_string<_CharT, _Traits, _Alloc>& | |
6696 | basic_string<_CharT, _Traits, _Alloc>:: | |
6697 | _M_replace_aux(size_type __pos1, size_type __n1, size_type __n2, | |
6698 | _CharT __c) | |
6699 | { | |
6700 | _M_check_length(__n1, __n2, "basic_string::_M_replace_aux"); | |
6701 | _M_mutate(__pos1, __n1, __n2); | |
6702 | if (__n2) | |
6703 | _M_assign(_M_data() + __pos1, __n2, __c); | |
6704 | return *this; | |
6705 | } | |
6706 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6707 | basic_string<_CharT, _Traits, _Alloc>& | |
6708 | basic_string<_CharT, _Traits, _Alloc>:: | |
6709 | _M_replace_safe(size_type __pos1, size_type __n1, const _CharT* __s, | |
6710 | size_type __n2) | |
6711 | { | |
6712 | _M_mutate(__pos1, __n1, __n2); | |
6713 | if (__n2) | |
6714 | _M_copy(_M_data() + __pos1, __s, __n2); | |
6715 | return *this; | |
6716 | } | |
6717 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6718 | basic_string<_CharT, _Traits, _Alloc> | |
6719 | operator+(const _CharT* __lhs, | |
6720 | const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6721 | { | |
6722 | ; | |
6723 | typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
6724 | typedef typename __string_type::size_type __size_type; | |
6725 | const __size_type __len = _Traits::length(__lhs); | |
6726 | __string_type __str; | |
6727 | __str.reserve(__len + __rhs.size()); | |
6728 | __str.append(__lhs, __len); | |
6729 | __str.append(__rhs); | |
6730 | return __str; | |
6731 | } | |
6732 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6733 | basic_string<_CharT, _Traits, _Alloc> | |
6734 | operator+(_CharT __lhs, const basic_string<_CharT, _Traits, _Alloc>& __rhs) | |
6735 | { | |
6736 | typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
6737 | typedef typename __string_type::size_type __size_type; | |
6738 | __string_type __str; | |
6739 | const __size_type __len = __rhs.size(); | |
6740 | __str.reserve(__len + 1); | |
6741 | __str.append(__size_type(1), __lhs); | |
6742 | __str.append(__rhs); | |
6743 | return __str; | |
6744 | } | |
6745 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6746 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6747 | basic_string<_CharT, _Traits, _Alloc>:: | |
6748 | copy(_CharT* __s, size_type __n, size_type __pos) const | |
6749 | { | |
6750 | _M_check(__pos, "basic_string::copy"); | |
6751 | __n = _M_limit(__pos, __n); | |
6752 | ; | |
6753 | if (__n) | |
6754 | _M_copy(__s, _M_data() + __pos, __n); | |
6755 | return __n; | |
6756 | } | |
6757 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6758 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6759 | basic_string<_CharT, _Traits, _Alloc>:: | |
6760 | find(const _CharT* __s, size_type __pos, size_type __n) const | |
6761 | { | |
6762 | ; | |
6763 | const size_type __size = this->size(); | |
6764 | const _CharT* __data = _M_data(); | |
6765 | if (__n == 0) | |
6766 | return __pos <= __size ? __pos : npos; | |
6767 | if (__n <= __size) | |
6768 | { | |
6769 | for (; __pos <= __size - __n; ++__pos) | |
6770 | if (traits_type::eq(__data[__pos], __s[0]) | |
6771 | && traits_type::compare(__data + __pos + 1, | |
6772 | __s + 1, __n - 1) == 0) | |
6773 | return __pos; | |
6774 | } | |
6775 | return npos; | |
6776 | } | |
6777 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6778 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6779 | basic_string<_CharT, _Traits, _Alloc>:: | |
6780 | find(_CharT __c, size_type __pos) const | |
6781 | { | |
6782 | size_type __ret = npos; | |
6783 | const size_type __size = this->size(); | |
6784 | if (__pos < __size) | |
6785 | { | |
6786 | const _CharT* __data = _M_data(); | |
6787 | const size_type __n = __size - __pos; | |
6788 | const _CharT* __p = traits_type::find(__data + __pos, __n, __c); | |
6789 | if (__p) | |
6790 | __ret = __p - __data; | |
6791 | } | |
6792 | return __ret; | |
6793 | } | |
6794 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6795 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6796 | basic_string<_CharT, _Traits, _Alloc>:: | |
6797 | rfind(const _CharT* __s, size_type __pos, size_type __n) const | |
6798 | { | |
6799 | ; | |
6800 | const size_type __size = this->size(); | |
6801 | if (__n <= __size) | |
6802 | { | |
6803 | __pos = std::min(size_type(__size - __n), __pos); | |
6804 | const _CharT* __data = _M_data(); | |
6805 | do | |
6806 | { | |
6807 | if (traits_type::compare(__data + __pos, __s, __n) == 0) | |
6808 | return __pos; | |
6809 | } | |
6810 | while (__pos-- > 0); | |
6811 | } | |
6812 | return npos; | |
6813 | } | |
6814 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6815 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6816 | basic_string<_CharT, _Traits, _Alloc>:: | |
6817 | rfind(_CharT __c, size_type __pos) const | |
6818 | { | |
6819 | size_type __size = this->size(); | |
6820 | if (__size) | |
6821 | { | |
6822 | if (--__size > __pos) | |
6823 | __size = __pos; | |
6824 | for (++__size; __size-- > 0; ) | |
6825 | if (traits_type::eq(_M_data()[__size], __c)) | |
6826 | return __size; | |
6827 | } | |
6828 | return npos; | |
6829 | } | |
6830 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6831 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6832 | basic_string<_CharT, _Traits, _Alloc>:: | |
6833 | find_first_of(const _CharT* __s, size_type __pos, size_type __n) const | |
6834 | { | |
6835 | ; | |
6836 | for (; __n && __pos < this->size(); ++__pos) | |
6837 | { | |
6838 | const _CharT* __p = traits_type::find(__s, __n, _M_data()[__pos]); | |
6839 | if (__p) | |
6840 | return __pos; | |
6841 | } | |
6842 | return npos; | |
6843 | } | |
6844 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6845 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6846 | basic_string<_CharT, _Traits, _Alloc>:: | |
6847 | find_last_of(const _CharT* __s, size_type __pos, size_type __n) const | |
6848 | { | |
6849 | ; | |
6850 | size_type __size = this->size(); | |
6851 | if (__size && __n) | |
6852 | { | |
6853 | if (--__size > __pos) | |
6854 | __size = __pos; | |
6855 | do | |
6856 | { | |
6857 | if (traits_type::find(__s, __n, _M_data()[__size])) | |
6858 | return __size; | |
6859 | } | |
6860 | while (__size-- != 0); | |
6861 | } | |
6862 | return npos; | |
6863 | } | |
6864 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6865 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6866 | basic_string<_CharT, _Traits, _Alloc>:: | |
6867 | find_first_not_of(const _CharT* __s, size_type __pos, size_type __n) const | |
6868 | { | |
6869 | ; | |
6870 | for (; __pos < this->size(); ++__pos) | |
6871 | if (!traits_type::find(__s, __n, _M_data()[__pos])) | |
6872 | return __pos; | |
6873 | return npos; | |
6874 | } | |
6875 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6876 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6877 | basic_string<_CharT, _Traits, _Alloc>:: | |
6878 | find_first_not_of(_CharT __c, size_type __pos) const | |
6879 | { | |
6880 | for (; __pos < this->size(); ++__pos) | |
6881 | if (!traits_type::eq(_M_data()[__pos], __c)) | |
6882 | return __pos; | |
6883 | return npos; | |
6884 | } | |
6885 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6886 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6887 | basic_string<_CharT, _Traits, _Alloc>:: | |
6888 | find_last_not_of(const _CharT* __s, size_type __pos, size_type __n) const | |
6889 | { | |
6890 | ; | |
6891 | size_type __size = this->size(); | |
6892 | if (__size) | |
6893 | { | |
6894 | if (--__size > __pos) | |
6895 | __size = __pos; | |
6896 | do | |
6897 | { | |
6898 | if (!traits_type::find(__s, __n, _M_data()[__size])) | |
6899 | return __size; | |
6900 | } | |
6901 | while (__size--); | |
6902 | } | |
6903 | return npos; | |
6904 | } | |
6905 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6906 | typename basic_string<_CharT, _Traits, _Alloc>::size_type | |
6907 | basic_string<_CharT, _Traits, _Alloc>:: | |
6908 | find_last_not_of(_CharT __c, size_type __pos) const | |
6909 | { | |
6910 | size_type __size = this->size(); | |
6911 | if (__size) | |
6912 | { | |
6913 | if (--__size > __pos) | |
6914 | __size = __pos; | |
6915 | do | |
6916 | { | |
6917 | if (!traits_type::eq(_M_data()[__size], __c)) | |
6918 | return __size; | |
6919 | } | |
6920 | while (__size--); | |
6921 | } | |
6922 | return npos; | |
6923 | } | |
6924 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6925 | int | |
6926 | basic_string<_CharT, _Traits, _Alloc>:: | |
6927 | compare(size_type __pos, size_type __n, const basic_string& __str) const | |
6928 | { | |
6929 | _M_check(__pos, "basic_string::compare"); | |
6930 | __n = _M_limit(__pos, __n); | |
6931 | const size_type __osize = __str.size(); | |
6932 | const size_type __len = std::min(__n, __osize); | |
6933 | int __r = traits_type::compare(_M_data() + __pos, __str.data(), __len); | |
6934 | if (!__r) | |
6935 | __r = _S_compare(__n, __osize); | |
6936 | return __r; | |
6937 | } | |
6938 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6939 | int | |
6940 | basic_string<_CharT, _Traits, _Alloc>:: | |
6941 | compare(size_type __pos1, size_type __n1, const basic_string& __str, | |
6942 | size_type __pos2, size_type __n2) const | |
6943 | { | |
6944 | _M_check(__pos1, "basic_string::compare"); | |
6945 | __str._M_check(__pos2, "basic_string::compare"); | |
6946 | __n1 = _M_limit(__pos1, __n1); | |
6947 | __n2 = __str._M_limit(__pos2, __n2); | |
6948 | const size_type __len = std::min(__n1, __n2); | |
6949 | int __r = traits_type::compare(_M_data() + __pos1, | |
6950 | __str.data() + __pos2, __len); | |
6951 | if (!__r) | |
6952 | __r = _S_compare(__n1, __n2); | |
6953 | return __r; | |
6954 | } | |
6955 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6956 | int | |
6957 | basic_string<_CharT, _Traits, _Alloc>:: | |
6958 | compare(const _CharT* __s) const | |
6959 | { | |
6960 | ; | |
6961 | const size_type __size = this->size(); | |
6962 | const size_type __osize = traits_type::length(__s); | |
6963 | const size_type __len = std::min(__size, __osize); | |
6964 | int __r = traits_type::compare(_M_data(), __s, __len); | |
6965 | if (!__r) | |
6966 | __r = _S_compare(__size, __osize); | |
6967 | return __r; | |
6968 | } | |
6969 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6970 | int | |
6971 | basic_string <_CharT, _Traits, _Alloc>:: | |
6972 | compare(size_type __pos, size_type __n1, const _CharT* __s) const | |
6973 | { | |
6974 | ; | |
6975 | _M_check(__pos, "basic_string::compare"); | |
6976 | __n1 = _M_limit(__pos, __n1); | |
6977 | const size_type __osize = traits_type::length(__s); | |
6978 | const size_type __len = std::min(__n1, __osize); | |
6979 | int __r = traits_type::compare(_M_data() + __pos, __s, __len); | |
6980 | if (!__r) | |
6981 | __r = _S_compare(__n1, __osize); | |
6982 | return __r; | |
6983 | } | |
6984 | template<typename _CharT, typename _Traits, typename _Alloc> | |
6985 | int | |
6986 | basic_string <_CharT, _Traits, _Alloc>:: | |
6987 | compare(size_type __pos, size_type __n1, const _CharT* __s, | |
6988 | size_type __n2) const | |
6989 | { | |
6990 | ; | |
6991 | _M_check(__pos, "basic_string::compare"); | |
6992 | __n1 = _M_limit(__pos, __n1); | |
6993 | const size_type __len = std::min(__n1, __n2); | |
6994 | int __r = traits_type::compare(_M_data() + __pos, __s, __len); | |
6995 | if (!__r) | |
6996 | __r = _S_compare(__n1, __n2); | |
6997 | return __r; | |
6998 | } | |
6999 | template<typename _CharT, typename _Traits, typename _Alloc> | |
7000 | basic_istream<_CharT, _Traits>& | |
7001 | operator>>(basic_istream<_CharT, _Traits>& __in, | |
7002 | basic_string<_CharT, _Traits, _Alloc>& __str) | |
7003 | { | |
7004 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
7005 | typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
7006 | typedef typename __istream_type::ios_base __ios_base; | |
7007 | typedef typename __istream_type::int_type __int_type; | |
7008 | typedef typename __string_type::size_type __size_type; | |
7009 | typedef ctype<_CharT> __ctype_type; | |
7010 | typedef typename __ctype_type::ctype_base __ctype_base; | |
7011 | __size_type __extracted = 0; | |
7012 | typename __ios_base::iostate __err = __ios_base::goodbit; | |
7013 | typename __istream_type::sentry __cerb(__in, false); | |
7014 | if (__cerb) | |
7015 | { | |
7016 | try | |
7017 | { | |
7018 | __str.erase(); | |
7019 | _CharT __buf[128]; | |
7020 | __size_type __len = 0; | |
7021 | const streamsize __w = __in.width(); | |
7022 | const __size_type __n = __w > 0 ? static_cast<__size_type>(__w) | |
7023 | : __str.max_size(); | |
7024 | const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); | |
7025 | const __int_type __eof = _Traits::eof(); | |
7026 | __int_type __c = __in.rdbuf()->sgetc(); | |
7027 | while (__extracted < __n | |
7028 | && !_Traits::eq_int_type(__c, __eof) | |
7029 | && !__ct.is(__ctype_base::space, | |
7030 | _Traits::to_char_type(__c))) | |
7031 | { | |
7032 | if (__len == sizeof(__buf) / sizeof(_CharT)) | |
7033 | { | |
7034 | __str.append(__buf, sizeof(__buf) / sizeof(_CharT)); | |
7035 | __len = 0; | |
7036 | } | |
7037 | __buf[__len++] = _Traits::to_char_type(__c); | |
7038 | ++__extracted; | |
7039 | __c = __in.rdbuf()->snextc(); | |
7040 | } | |
7041 | __str.append(__buf, __len); | |
7042 | if (_Traits::eq_int_type(__c, __eof)) | |
7043 | __err |= __ios_base::eofbit; | |
7044 | __in.width(0); | |
7045 | } | |
7046 | catch(__cxxabiv1::__forced_unwind&) | |
7047 | { | |
7048 | __in._M_setstate(__ios_base::badbit); | |
7049 | throw; | |
7050 | } | |
7051 | catch(...) | |
7052 | { | |
7053 | __in._M_setstate(__ios_base::badbit); | |
7054 | } | |
7055 | } | |
7056 | if (!__extracted) | |
7057 | __err |= __ios_base::failbit; | |
7058 | if (__err) | |
7059 | __in.setstate(__err); | |
7060 | return __in; | |
7061 | } | |
7062 | template<typename _CharT, typename _Traits, typename _Alloc> | |
7063 | basic_istream<_CharT, _Traits>& | |
7064 | getline(basic_istream<_CharT, _Traits>& __in, | |
7065 | basic_string<_CharT, _Traits, _Alloc>& __str, _CharT __delim) | |
7066 | { | |
7067 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
7068 | typedef basic_string<_CharT, _Traits, _Alloc> __string_type; | |
7069 | typedef typename __istream_type::ios_base __ios_base; | |
7070 | typedef typename __istream_type::int_type __int_type; | |
7071 | typedef typename __string_type::size_type __size_type; | |
7072 | __size_type __extracted = 0; | |
7073 | const __size_type __n = __str.max_size(); | |
7074 | typename __ios_base::iostate __err = __ios_base::goodbit; | |
7075 | typename __istream_type::sentry __cerb(__in, true); | |
7076 | if (__cerb) | |
7077 | { | |
7078 | try | |
7079 | { | |
7080 | __str.erase(); | |
7081 | const __int_type __idelim = _Traits::to_int_type(__delim); | |
7082 | const __int_type __eof = _Traits::eof(); | |
7083 | __int_type __c = __in.rdbuf()->sgetc(); | |
7084 | while (__extracted < __n | |
7085 | && !_Traits::eq_int_type(__c, __eof) | |
7086 | && !_Traits::eq_int_type(__c, __idelim)) | |
7087 | { | |
7088 | __str += _Traits::to_char_type(__c); | |
7089 | ++__extracted; | |
7090 | __c = __in.rdbuf()->snextc(); | |
7091 | } | |
7092 | if (_Traits::eq_int_type(__c, __eof)) | |
7093 | __err |= __ios_base::eofbit; | |
7094 | else if (_Traits::eq_int_type(__c, __idelim)) | |
7095 | { | |
7096 | ++__extracted; | |
7097 | __in.rdbuf()->sbumpc(); | |
7098 | } | |
7099 | else | |
7100 | __err |= __ios_base::failbit; | |
7101 | } | |
7102 | catch(__cxxabiv1::__forced_unwind&) | |
7103 | { | |
7104 | __in._M_setstate(__ios_base::badbit); | |
7105 | throw; | |
7106 | } | |
7107 | catch(...) | |
7108 | { | |
7109 | __in._M_setstate(__ios_base::badbit); | |
7110 | } | |
7111 | } | |
7112 | if (!__extracted) | |
7113 | __err |= __ios_base::failbit; | |
7114 | if (__err) | |
7115 | __in.setstate(__err); | |
7116 | return __in; | |
7117 | } | |
7118 | extern template class basic_string<char>; | |
7119 | extern template | |
7120 | basic_istream<char>& | |
7121 | operator>>(basic_istream<char>&, string&); | |
7122 | extern template | |
7123 | basic_ostream<char>& | |
7124 | operator<<(basic_ostream<char>&, const string&); | |
7125 | extern template | |
7126 | basic_istream<char>& | |
7127 | getline(basic_istream<char>&, string&, char); | |
7128 | extern template | |
7129 | basic_istream<char>& | |
7130 | getline(basic_istream<char>&, string&); | |
7131 | } | |
7132 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
7133 | class locale | |
7134 | { | |
7135 | public: | |
7136 | typedef int category; | |
7137 | class facet; | |
7138 | class id; | |
7139 | class _Impl; | |
7140 | friend class facet; | |
7141 | friend class _Impl; | |
7142 | template<typename _Facet> | |
7143 | friend bool | |
7144 | has_facet(const locale&) throw(); | |
7145 | template<typename _Facet> | |
7146 | friend const _Facet& | |
7147 | use_facet(const locale&); | |
7148 | template<typename _Cache> | |
7149 | friend struct __use_cache; | |
7150 | static const category none = 0; | |
7151 | static const category ctype = 1L << 0; | |
7152 | static const category numeric = 1L << 1; | |
7153 | static const category collate = 1L << 2; | |
7154 | static const category time = 1L << 3; | |
7155 | static const category monetary = 1L << 4; | |
7156 | static const category messages = 1L << 5; | |
7157 | static const category all = (ctype | numeric | collate | | |
7158 | time | monetary | messages); | |
7159 | locale() throw(); | |
7160 | locale(const locale& __other) throw(); | |
7161 | explicit | |
7162 | locale(const char* __s); | |
7163 | locale(const locale& __base, const char* __s, category __cat); | |
7164 | locale(const locale& __base, const locale& __add, category __cat); | |
7165 | template<typename _Facet> | |
7166 | locale(const locale& __other, _Facet* __f); | |
7167 | ~locale() throw(); | |
7168 | const locale& | |
7169 | operator=(const locale& __other) throw(); | |
7170 | template<typename _Facet> | |
7171 | locale | |
7172 | combine(const locale& __other) const; | |
7173 | string | |
7174 | name() const; | |
7175 | bool | |
7176 | operator==(const locale& __other) const throw (); | |
7177 | bool | |
7178 | operator!=(const locale& __other) const throw () | |
7179 | { return !(this->operator==(__other)); } | |
7180 | template<typename _Char, typename _Traits, typename _Alloc> | |
7181 | bool | |
7182 | operator()(const basic_string<_Char, _Traits, _Alloc>& __s1, | |
7183 | const basic_string<_Char, _Traits, _Alloc>& __s2) const; | |
7184 | static locale | |
7185 | global(const locale&); | |
7186 | static const locale& | |
7187 | classic(); | |
7188 | private: | |
7189 | _Impl* _M_impl; | |
7190 | static _Impl* _S_classic; | |
7191 | static _Impl* _S_global; | |
7192 | static const char* const* const _S_categories; | |
7193 | enum { _S_categories_size = 6 + 0 }; | |
7194 | static __gthread_once_t _S_once; | |
7195 | explicit | |
7196 | locale(_Impl*) throw(); | |
7197 | static void | |
7198 | _S_initialize(); | |
7199 | static void | |
7200 | _S_initialize_once(); | |
7201 | static category | |
7202 | _S_normalize_category(category); | |
7203 | void | |
7204 | _M_coalesce(const locale& __base, const locale& __add, category __cat); | |
7205 | }; | |
7206 | class locale::facet | |
7207 | { | |
7208 | private: | |
7209 | friend class locale; | |
7210 | friend class locale::_Impl; | |
7211 | mutable _Atomic_word _M_refcount; | |
7212 | static __c_locale _S_c_locale; | |
7213 | static const char _S_c_name[2]; | |
7214 | static __gthread_once_t _S_once; | |
7215 | static void | |
7216 | _S_initialize_once(); | |
7217 | protected: | |
7218 | explicit | |
7219 | facet(size_t __refs = 0) throw() : _M_refcount(__refs ? 1 : 0) | |
7220 | { } | |
7221 | virtual | |
7222 | ~facet(); | |
7223 | static void | |
7224 | _S_create_c_locale(__c_locale& __cloc, const char* __s, | |
7225 | __c_locale __old = 0); | |
7226 | static __c_locale | |
7227 | _S_clone_c_locale(__c_locale& __cloc); | |
7228 | static void | |
7229 | _S_destroy_c_locale(__c_locale& __cloc); | |
7230 | static __c_locale | |
7231 | _S_get_c_locale(); | |
7232 | static const char* | |
7233 | _S_get_c_name(); | |
7234 | private: | |
7235 | void | |
7236 | _M_add_reference() const throw() | |
7237 | { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } | |
7238 | void | |
7239 | _M_remove_reference() const throw() | |
7240 | { | |
7241 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) | |
7242 | { | |
7243 | try | |
7244 | { delete this; } | |
7245 | catch(...) | |
7246 | { } | |
7247 | } | |
7248 | } | |
7249 | facet(const facet&); | |
7250 | facet& | |
7251 | operator=(const facet&); | |
7252 | }; | |
7253 | class locale::id | |
7254 | { | |
7255 | private: | |
7256 | friend class locale; | |
7257 | friend class locale::_Impl; | |
7258 | template<typename _Facet> | |
7259 | friend const _Facet& | |
7260 | use_facet(const locale&); | |
7261 | template<typename _Facet> | |
7262 | friend bool | |
7263 | has_facet(const locale&) throw (); | |
7264 | mutable size_t _M_index; | |
7265 | static _Atomic_word _S_refcount; | |
7266 | void | |
7267 | operator=(const id&); | |
7268 | id(const id&); | |
7269 | public: | |
7270 | id() { } | |
7271 | size_t | |
7272 | _M_id() const; | |
7273 | }; | |
7274 | class locale::_Impl | |
7275 | { | |
7276 | public: | |
7277 | friend class locale; | |
7278 | friend class locale::facet; | |
7279 | template<typename _Facet> | |
7280 | friend bool | |
7281 | has_facet(const locale&) throw(); | |
7282 | template<typename _Facet> | |
7283 | friend const _Facet& | |
7284 | use_facet(const locale&); | |
7285 | template<typename _Cache> | |
7286 | friend struct __use_cache; | |
7287 | private: | |
7288 | _Atomic_word _M_refcount; | |
7289 | const facet** _M_facets; | |
7290 | size_t _M_facets_size; | |
7291 | const facet** _M_caches; | |
7292 | char** _M_names; | |
7293 | static const locale::id* const _S_id_ctype[]; | |
7294 | static const locale::id* const _S_id_numeric[]; | |
7295 | static const locale::id* const _S_id_collate[]; | |
7296 | static const locale::id* const _S_id_time[]; | |
7297 | static const locale::id* const _S_id_monetary[]; | |
7298 | static const locale::id* const _S_id_messages[]; | |
7299 | static const locale::id* const* const _S_facet_categories[]; | |
7300 | void | |
7301 | _M_add_reference() throw() | |
7302 | { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } | |
7303 | void | |
7304 | _M_remove_reference() throw() | |
7305 | { | |
7306 | if (__gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1) == 1) | |
7307 | { | |
7308 | try | |
7309 | { delete this; } | |
7310 | catch(...) | |
7311 | { } | |
7312 | } | |
7313 | } | |
7314 | _Impl(const _Impl&, size_t); | |
7315 | _Impl(const char*, size_t); | |
7316 | _Impl(size_t) throw(); | |
7317 | ~_Impl() throw(); | |
7318 | _Impl(const _Impl&); | |
7319 | void | |
7320 | operator=(const _Impl&); | |
7321 | bool | |
7322 | _M_check_same_name() | |
7323 | { | |
7324 | bool __ret = true; | |
7325 | if (_M_names[1]) | |
7326 | for (size_t __i = 0; __ret && __i < _S_categories_size - 1; ++__i) | |
7327 | __ret = __builtin_strcmp(_M_names[__i], _M_names[__i + 1]) == 0; | |
7328 | return __ret; | |
7329 | } | |
7330 | void | |
7331 | _M_replace_categories(const _Impl*, category); | |
7332 | void | |
7333 | _M_replace_category(const _Impl*, const locale::id* const*); | |
7334 | void | |
7335 | _M_replace_facet(const _Impl*, const locale::id*); | |
7336 | void | |
7337 | _M_install_facet(const locale::id*, const facet*); | |
7338 | template<typename _Facet> | |
7339 | void | |
7340 | _M_init_facet(_Facet* __facet) | |
7341 | { _M_install_facet(&_Facet::id, __facet); } | |
7342 | void | |
7343 | _M_install_cache(const facet*, size_t); | |
7344 | }; | |
7345 | template<typename _Facet> | |
7346 | bool | |
7347 | has_facet(const locale& __loc) throw(); | |
7348 | template<typename _Facet> | |
7349 | const _Facet& | |
7350 | use_facet(const locale& __loc); | |
7351 | template<typename _CharT> | |
7352 | class collate : public locale::facet | |
7353 | { | |
7354 | public: | |
7355 | typedef _CharT char_type; | |
7356 | typedef basic_string<_CharT> string_type; | |
7357 | protected: | |
7358 | __c_locale _M_c_locale_collate; | |
7359 | public: | |
7360 | static locale::id id; | |
7361 | explicit | |
7362 | collate(size_t __refs = 0) | |
7363 | : facet(__refs), _M_c_locale_collate(_S_get_c_locale()) | |
7364 | { } | |
7365 | explicit | |
7366 | collate(__c_locale __cloc, size_t __refs = 0) | |
7367 | : facet(__refs), _M_c_locale_collate(_S_clone_c_locale(__cloc)) | |
7368 | { } | |
7369 | int | |
7370 | compare(const _CharT* __lo1, const _CharT* __hi1, | |
7371 | const _CharT* __lo2, const _CharT* __hi2) const | |
7372 | { return this->do_compare(__lo1, __hi1, __lo2, __hi2); } | |
7373 | string_type | |
7374 | transform(const _CharT* __lo, const _CharT* __hi) const | |
7375 | { return this->do_transform(__lo, __hi); } | |
7376 | long | |
7377 | hash(const _CharT* __lo, const _CharT* __hi) const | |
7378 | { return this->do_hash(__lo, __hi); } | |
7379 | int | |
7380 | _M_compare(const _CharT*, const _CharT*) const; | |
7381 | size_t | |
7382 | _M_transform(_CharT*, const _CharT*, size_t) const; | |
7383 | protected: | |
7384 | virtual | |
7385 | ~collate() | |
7386 | { _S_destroy_c_locale(_M_c_locale_collate); } | |
7387 | virtual int | |
7388 | do_compare(const _CharT* __lo1, const _CharT* __hi1, | |
7389 | const _CharT* __lo2, const _CharT* __hi2) const; | |
7390 | virtual string_type | |
7391 | do_transform(const _CharT* __lo, const _CharT* __hi) const; | |
7392 | virtual long | |
7393 | do_hash(const _CharT* __lo, const _CharT* __hi) const; | |
7394 | }; | |
7395 | template<typename _CharT> | |
7396 | locale::id collate<_CharT>::id; | |
7397 | template<> | |
7398 | int | |
7399 | collate<char>::_M_compare(const char*, const char*) const; | |
7400 | template<> | |
7401 | size_t | |
7402 | collate<char>::_M_transform(char*, const char*, size_t) const; | |
7403 | template<typename _CharT> | |
7404 | class collate_byname : public collate<_CharT> | |
7405 | { | |
7406 | public: | |
7407 | typedef _CharT char_type; | |
7408 | typedef basic_string<_CharT> string_type; | |
7409 | explicit | |
7410 | collate_byname(const char* __s, size_t __refs = 0) | |
7411 | : collate<_CharT>(__refs) | |
7412 | { | |
7413 | if (__builtin_strcmp(__s, "C") != 0 | |
7414 | && __builtin_strcmp(__s, "POSIX") != 0) | |
7415 | { | |
7416 | this->_S_destroy_c_locale(this->_M_c_locale_collate); | |
7417 | this->_S_create_c_locale(this->_M_c_locale_collate, __s); | |
7418 | } | |
7419 | } | |
7420 | protected: | |
7421 | virtual | |
7422 | ~collate_byname() { } | |
7423 | }; | |
7424 | } | |
7425 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
7426 | template<typename _Facet> | |
7427 | locale:: | |
7428 | locale(const locale& __other, _Facet* __f) | |
7429 | { | |
7430 | _M_impl = new _Impl(*__other._M_impl, 1); | |
7431 | try | |
7432 | { _M_impl->_M_install_facet(&_Facet::id, __f); } | |
7433 | catch(...) | |
7434 | { | |
7435 | _M_impl->_M_remove_reference(); | |
7436 | throw; | |
7437 | } | |
7438 | delete [] _M_impl->_M_names[0]; | |
7439 | _M_impl->_M_names[0] = 0; | |
7440 | } | |
7441 | template<typename _Facet> | |
7442 | locale | |
7443 | locale:: | |
7444 | combine(const locale& __other) const | |
7445 | { | |
7446 | _Impl* __tmp = new _Impl(*_M_impl, 1); | |
7447 | try | |
7448 | { | |
7449 | __tmp->_M_replace_facet(__other._M_impl, &_Facet::id); | |
7450 | } | |
7451 | catch(...) | |
7452 | { | |
7453 | __tmp->_M_remove_reference(); | |
7454 | throw; | |
7455 | } | |
7456 | return locale(__tmp); | |
7457 | } | |
7458 | template<typename _CharT, typename _Traits, typename _Alloc> | |
7459 | bool | |
7460 | locale:: | |
7461 | operator()(const basic_string<_CharT, _Traits, _Alloc>& __s1, | |
7462 | const basic_string<_CharT, _Traits, _Alloc>& __s2) const | |
7463 | { | |
7464 | typedef std::collate<_CharT> __collate_type; | |
7465 | const __collate_type& __collate = use_facet<__collate_type>(*this); | |
7466 | return (__collate.compare(__s1.data(), __s1.data() + __s1.length(), | |
7467 | __s2.data(), __s2.data() + __s2.length()) < 0); | |
7468 | } | |
7469 | template<typename _Facet> | |
7470 | bool | |
7471 | has_facet(const locale& __loc) throw() | |
7472 | { | |
7473 | const size_t __i = _Facet::id._M_id(); | |
7474 | const locale::facet** __facets = __loc._M_impl->_M_facets; | |
7475 | return (__i < __loc._M_impl->_M_facets_size | |
7476 | && dynamic_cast<const _Facet*>(__facets[__i])); | |
7477 | } | |
7478 | template<typename _Facet> | |
7479 | const _Facet& | |
7480 | use_facet(const locale& __loc) | |
7481 | { | |
7482 | const size_t __i = _Facet::id._M_id(); | |
7483 | const locale::facet** __facets = __loc._M_impl->_M_facets; | |
7484 | if (__i >= __loc._M_impl->_M_facets_size || !__facets[__i]) | |
7485 | __throw_bad_cast(); | |
7486 | return dynamic_cast<const _Facet&>(*__facets[__i]); | |
7487 | } | |
7488 | template<typename _CharT> | |
7489 | int | |
7490 | collate<_CharT>::_M_compare(const _CharT*, const _CharT*) const | |
7491 | { return 0; } | |
7492 | template<typename _CharT> | |
7493 | size_t | |
7494 | collate<_CharT>::_M_transform(_CharT*, const _CharT*, size_t) const | |
7495 | { return 0; } | |
7496 | template<typename _CharT> | |
7497 | int | |
7498 | collate<_CharT>:: | |
7499 | do_compare(const _CharT* __lo1, const _CharT* __hi1, | |
7500 | const _CharT* __lo2, const _CharT* __hi2) const | |
7501 | { | |
7502 | const string_type __one(__lo1, __hi1); | |
7503 | const string_type __two(__lo2, __hi2); | |
7504 | const _CharT* __p = __one.c_str(); | |
7505 | const _CharT* __pend = __one.data() + __one.length(); | |
7506 | const _CharT* __q = __two.c_str(); | |
7507 | const _CharT* __qend = __two.data() + __two.length(); | |
7508 | for (;;) | |
7509 | { | |
7510 | const int __res = _M_compare(__p, __q); | |
7511 | if (__res) | |
7512 | return __res; | |
7513 | __p += char_traits<_CharT>::length(__p); | |
7514 | __q += char_traits<_CharT>::length(__q); | |
7515 | if (__p == __pend && __q == __qend) | |
7516 | return 0; | |
7517 | else if (__p == __pend) | |
7518 | return -1; | |
7519 | else if (__q == __qend) | |
7520 | return 1; | |
7521 | __p++; | |
7522 | __q++; | |
7523 | } | |
7524 | } | |
7525 | template<typename _CharT> | |
7526 | typename collate<_CharT>::string_type | |
7527 | collate<_CharT>:: | |
7528 | do_transform(const _CharT* __lo, const _CharT* __hi) const | |
7529 | { | |
7530 | string_type __ret; | |
7531 | const string_type __str(__lo, __hi); | |
7532 | const _CharT* __p = __str.c_str(); | |
7533 | const _CharT* __pend = __str.data() + __str.length(); | |
7534 | size_t __len = (__hi - __lo) * 2; | |
7535 | _CharT* __c = new _CharT[__len]; | |
7536 | try | |
7537 | { | |
7538 | for (;;) | |
7539 | { | |
7540 | size_t __res = _M_transform(__c, __p, __len); | |
7541 | if (__res >= __len) | |
7542 | { | |
7543 | __len = __res + 1; | |
7544 | delete [] __c, __c = 0; | |
7545 | __c = new _CharT[__len]; | |
7546 | __res = _M_transform(__c, __p, __len); | |
7547 | } | |
7548 | __ret.append(__c, __res); | |
7549 | __p += char_traits<_CharT>::length(__p); | |
7550 | if (__p == __pend) | |
7551 | break; | |
7552 | __p++; | |
7553 | __ret.push_back(_CharT()); | |
7554 | } | |
7555 | } | |
7556 | catch(...) | |
7557 | { | |
7558 | delete [] __c; | |
7559 | throw; | |
7560 | } | |
7561 | delete [] __c; | |
7562 | return __ret; | |
7563 | } | |
7564 | template<typename _CharT> | |
7565 | long | |
7566 | collate<_CharT>:: | |
7567 | do_hash(const _CharT* __lo, const _CharT* __hi) const | |
7568 | { | |
7569 | unsigned long __val = 0; | |
7570 | for (; __lo < __hi; ++__lo) | |
7571 | __val = | |
7572 | *__lo + ((__val << 7) | |
7573 | | (__val >> (__gnu_cxx::__numeric_traits<unsigned long>:: | |
7574 | __digits - 7))); | |
7575 | return static_cast<long>(__val); | |
7576 | } | |
7577 | extern template class collate<char>; | |
7578 | extern template class collate_byname<char>; | |
7579 | extern template | |
7580 | const collate<char>& | |
7581 | use_facet<collate<char> >(const locale&); | |
7582 | extern template | |
7583 | bool | |
7584 | has_facet<collate<char> >(const locale&); | |
7585 | } | |
7586 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
7587 | enum _Ios_Fmtflags | |
7588 | { | |
7589 | _S_boolalpha = 1L << 0, | |
7590 | _S_dec = 1L << 1, | |
7591 | _S_fixed = 1L << 2, | |
7592 | _S_hex = 1L << 3, | |
7593 | _S_internal = 1L << 4, | |
7594 | _S_left = 1L << 5, | |
7595 | _S_oct = 1L << 6, | |
7596 | _S_right = 1L << 7, | |
7597 | _S_scientific = 1L << 8, | |
7598 | _S_showbase = 1L << 9, | |
7599 | _S_showpoint = 1L << 10, | |
7600 | _S_showpos = 1L << 11, | |
7601 | _S_skipws = 1L << 12, | |
7602 | _S_unitbuf = 1L << 13, | |
7603 | _S_uppercase = 1L << 14, | |
7604 | _S_adjustfield = _S_left | _S_right | _S_internal, | |
7605 | _S_basefield = _S_dec | _S_oct | _S_hex, | |
7606 | _S_floatfield = _S_scientific | _S_fixed, | |
7607 | _S_ios_fmtflags_end = 1L << 16 | |
7608 | }; | |
7609 | inline _Ios_Fmtflags | |
7610 | operator&(_Ios_Fmtflags __a, _Ios_Fmtflags __b) | |
7611 | { return _Ios_Fmtflags(static_cast<int>(__a) & static_cast<int>(__b)); } | |
7612 | inline _Ios_Fmtflags | |
7613 | operator|(_Ios_Fmtflags __a, _Ios_Fmtflags __b) | |
7614 | { return _Ios_Fmtflags(static_cast<int>(__a) | static_cast<int>(__b)); } | |
7615 | inline _Ios_Fmtflags | |
7616 | operator^(_Ios_Fmtflags __a, _Ios_Fmtflags __b) | |
7617 | { return _Ios_Fmtflags(static_cast<int>(__a) ^ static_cast<int>(__b)); } | |
7618 | inline _Ios_Fmtflags& | |
7619 | operator|=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) | |
7620 | { return __a = __a | __b; } | |
7621 | inline _Ios_Fmtflags& | |
7622 | operator&=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) | |
7623 | { return __a = __a & __b; } | |
7624 | inline _Ios_Fmtflags& | |
7625 | operator^=(_Ios_Fmtflags& __a, _Ios_Fmtflags __b) | |
7626 | { return __a = __a ^ __b; } | |
7627 | inline _Ios_Fmtflags | |
7628 | operator~(_Ios_Fmtflags __a) | |
7629 | { return _Ios_Fmtflags(~static_cast<int>(__a)); } | |
7630 | enum _Ios_Openmode | |
7631 | { | |
7632 | _S_app = 1L << 0, | |
7633 | _S_ate = 1L << 1, | |
7634 | _S_bin = 1L << 2, | |
7635 | _S_in = 1L << 3, | |
7636 | _S_out = 1L << 4, | |
7637 | _S_trunc = 1L << 5, | |
7638 | _S_ios_openmode_end = 1L << 16 | |
7639 | }; | |
7640 | inline _Ios_Openmode | |
7641 | operator&(_Ios_Openmode __a, _Ios_Openmode __b) | |
7642 | { return _Ios_Openmode(static_cast<int>(__a) & static_cast<int>(__b)); } | |
7643 | inline _Ios_Openmode | |
7644 | operator|(_Ios_Openmode __a, _Ios_Openmode __b) | |
7645 | { return _Ios_Openmode(static_cast<int>(__a) | static_cast<int>(__b)); } | |
7646 | inline _Ios_Openmode | |
7647 | operator^(_Ios_Openmode __a, _Ios_Openmode __b) | |
7648 | { return _Ios_Openmode(static_cast<int>(__a) ^ static_cast<int>(__b)); } | |
7649 | inline _Ios_Openmode& | |
7650 | operator|=(_Ios_Openmode& __a, _Ios_Openmode __b) | |
7651 | { return __a = __a | __b; } | |
7652 | inline _Ios_Openmode& | |
7653 | operator&=(_Ios_Openmode& __a, _Ios_Openmode __b) | |
7654 | { return __a = __a & __b; } | |
7655 | inline _Ios_Openmode& | |
7656 | operator^=(_Ios_Openmode& __a, _Ios_Openmode __b) | |
7657 | { return __a = __a ^ __b; } | |
7658 | inline _Ios_Openmode | |
7659 | operator~(_Ios_Openmode __a) | |
7660 | { return _Ios_Openmode(~static_cast<int>(__a)); } | |
7661 | enum _Ios_Iostate | |
7662 | { | |
7663 | _S_goodbit = 0, | |
7664 | _S_badbit = 1L << 0, | |
7665 | _S_eofbit = 1L << 1, | |
7666 | _S_failbit = 1L << 2, | |
7667 | _S_ios_iostate_end = 1L << 16 | |
7668 | }; | |
7669 | inline _Ios_Iostate | |
7670 | operator&(_Ios_Iostate __a, _Ios_Iostate __b) | |
7671 | { return _Ios_Iostate(static_cast<int>(__a) & static_cast<int>(__b)); } | |
7672 | inline _Ios_Iostate | |
7673 | operator|(_Ios_Iostate __a, _Ios_Iostate __b) | |
7674 | { return _Ios_Iostate(static_cast<int>(__a) | static_cast<int>(__b)); } | |
7675 | inline _Ios_Iostate | |
7676 | operator^(_Ios_Iostate __a, _Ios_Iostate __b) | |
7677 | { return _Ios_Iostate(static_cast<int>(__a) ^ static_cast<int>(__b)); } | |
7678 | inline _Ios_Iostate& | |
7679 | operator|=(_Ios_Iostate& __a, _Ios_Iostate __b) | |
7680 | { return __a = __a | __b; } | |
7681 | inline _Ios_Iostate& | |
7682 | operator&=(_Ios_Iostate& __a, _Ios_Iostate __b) | |
7683 | { return __a = __a & __b; } | |
7684 | inline _Ios_Iostate& | |
7685 | operator^=(_Ios_Iostate& __a, _Ios_Iostate __b) | |
7686 | { return __a = __a ^ __b; } | |
7687 | inline _Ios_Iostate | |
7688 | operator~(_Ios_Iostate __a) | |
7689 | { return _Ios_Iostate(~static_cast<int>(__a)); } | |
7690 | enum _Ios_Seekdir | |
7691 | { | |
7692 | _S_beg = 0, | |
7693 | _S_cur = 1, | |
7694 | _S_end = 2, | |
7695 | _S_ios_seekdir_end = 1L << 16 | |
7696 | }; | |
7697 | class ios_base | |
7698 | { | |
7699 | public: | |
7700 | class failure : public exception | |
7701 | { | |
7702 | public: | |
7703 | explicit | |
7704 | failure(const string& __str) throw(); | |
7705 | virtual | |
7706 | ~failure() throw(); | |
7707 | virtual const char* | |
7708 | what() const throw(); | |
7709 | private: | |
7710 | string _M_msg; | |
7711 | }; | |
7712 | typedef _Ios_Fmtflags fmtflags; | |
7713 | static const fmtflags boolalpha = _S_boolalpha; | |
7714 | static const fmtflags dec = _S_dec; | |
7715 | static const fmtflags fixed = _S_fixed; | |
7716 | static const fmtflags hex = _S_hex; | |
7717 | static const fmtflags internal = _S_internal; | |
7718 | static const fmtflags left = _S_left; | |
7719 | static const fmtflags oct = _S_oct; | |
7720 | static const fmtflags right = _S_right; | |
7721 | static const fmtflags scientific = _S_scientific; | |
7722 | static const fmtflags showbase = _S_showbase; | |
7723 | static const fmtflags showpoint = _S_showpoint; | |
7724 | static const fmtflags showpos = _S_showpos; | |
7725 | static const fmtflags skipws = _S_skipws; | |
7726 | static const fmtflags unitbuf = _S_unitbuf; | |
7727 | static const fmtflags uppercase = _S_uppercase; | |
7728 | static const fmtflags adjustfield = _S_adjustfield; | |
7729 | static const fmtflags basefield = _S_basefield; | |
7730 | static const fmtflags floatfield = _S_floatfield; | |
7731 | typedef _Ios_Iostate iostate; | |
7732 | static const iostate badbit = _S_badbit; | |
7733 | static const iostate eofbit = _S_eofbit; | |
7734 | static const iostate failbit = _S_failbit; | |
7735 | static const iostate goodbit = _S_goodbit; | |
7736 | typedef _Ios_Openmode openmode; | |
7737 | static const openmode app = _S_app; | |
7738 | static const openmode ate = _S_ate; | |
7739 | static const openmode binary = _S_bin; | |
7740 | static const openmode in = _S_in; | |
7741 | static const openmode out = _S_out; | |
7742 | static const openmode trunc = _S_trunc; | |
7743 | typedef _Ios_Seekdir seekdir; | |
7744 | static const seekdir beg = _S_beg; | |
7745 | static const seekdir cur = _S_cur; | |
7746 | static const seekdir end = _S_end; | |
7747 | typedef int io_state; | |
7748 | typedef int open_mode; | |
7749 | typedef int seek_dir; | |
7750 | typedef std::streampos streampos; | |
7751 | typedef std::streamoff streamoff; | |
7752 | enum event | |
7753 | { | |
7754 | erase_event, | |
7755 | imbue_event, | |
7756 | copyfmt_event | |
7757 | }; | |
7758 | typedef void (*event_callback) (event, ios_base&, int); | |
7759 | void | |
7760 | register_callback(event_callback __fn, int __index); | |
7761 | protected: | |
7762 | streamsize _M_precision; | |
7763 | streamsize _M_width; | |
7764 | fmtflags _M_flags; | |
7765 | iostate _M_exception; | |
7766 | iostate _M_streambuf_state; | |
7767 | struct _Callback_list | |
7768 | { | |
7769 | _Callback_list* _M_next; | |
7770 | ios_base::event_callback _M_fn; | |
7771 | int _M_index; | |
7772 | _Atomic_word _M_refcount; | |
7773 | _Callback_list(ios_base::event_callback __fn, int __index, | |
7774 | _Callback_list* __cb) | |
7775 | : _M_next(__cb), _M_fn(__fn), _M_index(__index), _M_refcount(0) { } | |
7776 | void | |
7777 | _M_add_reference() { __gnu_cxx::__atomic_add_dispatch(&_M_refcount, 1); } | |
7778 | int | |
7779 | _M_remove_reference() | |
7780 | { return __gnu_cxx::__exchange_and_add_dispatch(&_M_refcount, -1); } | |
7781 | }; | |
7782 | _Callback_list* _M_callbacks; | |
7783 | void | |
7784 | _M_call_callbacks(event __ev) throw(); | |
7785 | void | |
7786 | _M_dispose_callbacks(void); | |
7787 | struct _Words | |
7788 | { | |
7789 | void* _M_pword; | |
7790 | long _M_iword; | |
7791 | _Words() : _M_pword(0), _M_iword(0) { } | |
7792 | }; | |
7793 | _Words _M_word_zero; | |
7794 | enum { _S_local_word_size = 8 }; | |
7795 | _Words _M_local_word[_S_local_word_size]; | |
7796 | int _M_word_size; | |
7797 | _Words* _M_word; | |
7798 | _Words& | |
7799 | _M_grow_words(int __index, bool __iword); | |
7800 | locale _M_ios_locale; | |
7801 | void | |
7802 | _M_init(); | |
7803 | public: | |
7804 | class Init | |
7805 | { | |
7806 | friend class ios_base; | |
7807 | public: | |
7808 | Init(); | |
7809 | ~Init(); | |
7810 | private: | |
7811 | static _Atomic_word _S_refcount; | |
7812 | static bool _S_synced_with_stdio; | |
7813 | }; | |
7814 | fmtflags | |
7815 | flags() const | |
7816 | { return _M_flags; } | |
7817 | fmtflags | |
7818 | flags(fmtflags __fmtfl) | |
7819 | { | |
7820 | fmtflags __old = _M_flags; | |
7821 | _M_flags = __fmtfl; | |
7822 | return __old; | |
7823 | } | |
7824 | fmtflags | |
7825 | setf(fmtflags __fmtfl) | |
7826 | { | |
7827 | fmtflags __old = _M_flags; | |
7828 | _M_flags |= __fmtfl; | |
7829 | return __old; | |
7830 | } | |
7831 | fmtflags | |
7832 | setf(fmtflags __fmtfl, fmtflags __mask) | |
7833 | { | |
7834 | fmtflags __old = _M_flags; | |
7835 | _M_flags &= ~__mask; | |
7836 | _M_flags |= (__fmtfl & __mask); | |
7837 | return __old; | |
7838 | } | |
7839 | void | |
7840 | unsetf(fmtflags __mask) | |
7841 | { _M_flags &= ~__mask; } | |
7842 | streamsize | |
7843 | precision() const | |
7844 | { return _M_precision; } | |
7845 | streamsize | |
7846 | precision(streamsize __prec) | |
7847 | { | |
7848 | streamsize __old = _M_precision; | |
7849 | _M_precision = __prec; | |
7850 | return __old; | |
7851 | } | |
7852 | streamsize | |
7853 | width() const | |
7854 | { return _M_width; } | |
7855 | streamsize | |
7856 | width(streamsize __wide) | |
7857 | { | |
7858 | streamsize __old = _M_width; | |
7859 | _M_width = __wide; | |
7860 | return __old; | |
7861 | } | |
7862 | static bool | |
7863 | sync_with_stdio(bool __sync = true); | |
7864 | locale | |
7865 | imbue(const locale& __loc); | |
7866 | locale | |
7867 | getloc() const | |
7868 | { return _M_ios_locale; } | |
7869 | const locale& | |
7870 | _M_getloc() const | |
7871 | { return _M_ios_locale; } | |
7872 | static int | |
7873 | xalloc() throw(); | |
7874 | long& | |
7875 | iword(int __ix) | |
7876 | { | |
7877 | _Words& __word = (__ix < _M_word_size) | |
7878 | ? _M_word[__ix] : _M_grow_words(__ix, true); | |
7879 | return __word._M_iword; | |
7880 | } | |
7881 | void*& | |
7882 | pword(int __ix) | |
7883 | { | |
7884 | _Words& __word = (__ix < _M_word_size) | |
7885 | ? _M_word[__ix] : _M_grow_words(__ix, false); | |
7886 | return __word._M_pword; | |
7887 | } | |
7888 | virtual ~ios_base(); | |
7889 | protected: | |
7890 | ios_base(); | |
7891 | private: | |
7892 | ios_base(const ios_base&); | |
7893 | ios_base& | |
7894 | operator=(const ios_base&); | |
7895 | }; | |
7896 | inline ios_base& | |
7897 | boolalpha(ios_base& __base) | |
7898 | { | |
7899 | __base.setf(ios_base::boolalpha); | |
7900 | return __base; | |
7901 | } | |
7902 | inline ios_base& | |
7903 | noboolalpha(ios_base& __base) | |
7904 | { | |
7905 | __base.unsetf(ios_base::boolalpha); | |
7906 | return __base; | |
7907 | } | |
7908 | inline ios_base& | |
7909 | showbase(ios_base& __base) | |
7910 | { | |
7911 | __base.setf(ios_base::showbase); | |
7912 | return __base; | |
7913 | } | |
7914 | inline ios_base& | |
7915 | noshowbase(ios_base& __base) | |
7916 | { | |
7917 | __base.unsetf(ios_base::showbase); | |
7918 | return __base; | |
7919 | } | |
7920 | inline ios_base& | |
7921 | showpoint(ios_base& __base) | |
7922 | { | |
7923 | __base.setf(ios_base::showpoint); | |
7924 | return __base; | |
7925 | } | |
7926 | inline ios_base& | |
7927 | noshowpoint(ios_base& __base) | |
7928 | { | |
7929 | __base.unsetf(ios_base::showpoint); | |
7930 | return __base; | |
7931 | } | |
7932 | inline ios_base& | |
7933 | showpos(ios_base& __base) | |
7934 | { | |
7935 | __base.setf(ios_base::showpos); | |
7936 | return __base; | |
7937 | } | |
7938 | inline ios_base& | |
7939 | noshowpos(ios_base& __base) | |
7940 | { | |
7941 | __base.unsetf(ios_base::showpos); | |
7942 | return __base; | |
7943 | } | |
7944 | inline ios_base& | |
7945 | skipws(ios_base& __base) | |
7946 | { | |
7947 | __base.setf(ios_base::skipws); | |
7948 | return __base; | |
7949 | } | |
7950 | inline ios_base& | |
7951 | noskipws(ios_base& __base) | |
7952 | { | |
7953 | __base.unsetf(ios_base::skipws); | |
7954 | return __base; | |
7955 | } | |
7956 | inline ios_base& | |
7957 | uppercase(ios_base& __base) | |
7958 | { | |
7959 | __base.setf(ios_base::uppercase); | |
7960 | return __base; | |
7961 | } | |
7962 | inline ios_base& | |
7963 | nouppercase(ios_base& __base) | |
7964 | { | |
7965 | __base.unsetf(ios_base::uppercase); | |
7966 | return __base; | |
7967 | } | |
7968 | inline ios_base& | |
7969 | unitbuf(ios_base& __base) | |
7970 | { | |
7971 | __base.setf(ios_base::unitbuf); | |
7972 | return __base; | |
7973 | } | |
7974 | inline ios_base& | |
7975 | nounitbuf(ios_base& __base) | |
7976 | { | |
7977 | __base.unsetf(ios_base::unitbuf); | |
7978 | return __base; | |
7979 | } | |
7980 | inline ios_base& | |
7981 | internal(ios_base& __base) | |
7982 | { | |
7983 | __base.setf(ios_base::internal, ios_base::adjustfield); | |
7984 | return __base; | |
7985 | } | |
7986 | inline ios_base& | |
7987 | left(ios_base& __base) | |
7988 | { | |
7989 | __base.setf(ios_base::left, ios_base::adjustfield); | |
7990 | return __base; | |
7991 | } | |
7992 | inline ios_base& | |
7993 | right(ios_base& __base) | |
7994 | { | |
7995 | __base.setf(ios_base::right, ios_base::adjustfield); | |
7996 | return __base; | |
7997 | } | |
7998 | inline ios_base& | |
7999 | dec(ios_base& __base) | |
8000 | { | |
8001 | __base.setf(ios_base::dec, ios_base::basefield); | |
8002 | return __base; | |
8003 | } | |
8004 | inline ios_base& | |
8005 | hex(ios_base& __base) | |
8006 | { | |
8007 | __base.setf(ios_base::hex, ios_base::basefield); | |
8008 | return __base; | |
8009 | } | |
8010 | inline ios_base& | |
8011 | oct(ios_base& __base) | |
8012 | { | |
8013 | __base.setf(ios_base::oct, ios_base::basefield); | |
8014 | return __base; | |
8015 | } | |
8016 | inline ios_base& | |
8017 | fixed(ios_base& __base) | |
8018 | { | |
8019 | __base.setf(ios_base::fixed, ios_base::floatfield); | |
8020 | return __base; | |
8021 | } | |
8022 | inline ios_base& | |
8023 | scientific(ios_base& __base) | |
8024 | { | |
8025 | __base.setf(ios_base::scientific, ios_base::floatfield); | |
8026 | return __base; | |
8027 | } | |
8028 | } | |
8029 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
8030 | template<typename _CharT, typename _Traits> | |
8031 | streamsize | |
8032 | __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>*, | |
8033 | basic_streambuf<_CharT, _Traits>*, bool&); | |
8034 | template<typename _CharT, typename _Traits> | |
8035 | class basic_streambuf | |
8036 | { | |
8037 | public: | |
8038 | typedef _CharT char_type; | |
8039 | typedef _Traits traits_type; | |
8040 | typedef typename traits_type::int_type int_type; | |
8041 | typedef typename traits_type::pos_type pos_type; | |
8042 | typedef typename traits_type::off_type off_type; | |
8043 | typedef basic_streambuf<char_type, traits_type> __streambuf_type; | |
8044 | friend class basic_ios<char_type, traits_type>; | |
8045 | friend class basic_istream<char_type, traits_type>; | |
8046 | friend class basic_ostream<char_type, traits_type>; | |
8047 | friend class istreambuf_iterator<char_type, traits_type>; | |
8048 | friend class ostreambuf_iterator<char_type, traits_type>; | |
8049 | friend streamsize | |
8050 | __copy_streambufs_eof<>(__streambuf_type*, __streambuf_type*, bool&); | |
8051 | template<bool _IsMove, typename _CharT2> | |
8052 | friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, | |
8053 | _CharT2*>::__type | |
8054 | __copy_move_a2(istreambuf_iterator<_CharT2>, | |
8055 | istreambuf_iterator<_CharT2>, _CharT2*); | |
8056 | template<typename _CharT2> | |
8057 | friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, | |
8058 | istreambuf_iterator<_CharT2> >::__type | |
8059 | find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, | |
8060 | const _CharT2&); | |
8061 | template<typename _CharT2, typename _Traits2> | |
8062 | friend basic_istream<_CharT2, _Traits2>& | |
8063 | operator>>(basic_istream<_CharT2, _Traits2>&, _CharT2*); | |
8064 | template<typename _CharT2, typename _Traits2, typename _Alloc> | |
8065 | friend basic_istream<_CharT2, _Traits2>& | |
8066 | operator>>(basic_istream<_CharT2, _Traits2>&, | |
8067 | basic_string<_CharT2, _Traits2, _Alloc>&); | |
8068 | template<typename _CharT2, typename _Traits2, typename _Alloc> | |
8069 | friend basic_istream<_CharT2, _Traits2>& | |
8070 | getline(basic_istream<_CharT2, _Traits2>&, | |
8071 | basic_string<_CharT2, _Traits2, _Alloc>&, _CharT2); | |
8072 | protected: | |
8073 | char_type* _M_in_beg; | |
8074 | char_type* _M_in_cur; | |
8075 | char_type* _M_in_end; | |
8076 | char_type* _M_out_beg; | |
8077 | char_type* _M_out_cur; | |
8078 | char_type* _M_out_end; | |
8079 | locale _M_buf_locale; | |
8080 | public: | |
8081 | virtual | |
8082 | ~basic_streambuf() | |
8083 | { } | |
8084 | locale | |
8085 | pubimbue(const locale &__loc) | |
8086 | { | |
8087 | locale __tmp(this->getloc()); | |
8088 | this->imbue(__loc); | |
8089 | _M_buf_locale = __loc; | |
8090 | return __tmp; | |
8091 | } | |
8092 | locale | |
8093 | getloc() const | |
8094 | { return _M_buf_locale; } | |
8095 | __streambuf_type* | |
8096 | pubsetbuf(char_type* __s, streamsize __n) | |
8097 | { return this->setbuf(__s, __n); } | |
8098 | pos_type | |
8099 | pubseekoff(off_type __off, ios_base::seekdir __way, | |
8100 | ios_base::openmode __mode = ios_base::in | ios_base::out) | |
8101 | { return this->seekoff(__off, __way, __mode); } | |
8102 | pos_type | |
8103 | pubseekpos(pos_type __sp, | |
8104 | ios_base::openmode __mode = ios_base::in | ios_base::out) | |
8105 | { return this->seekpos(__sp, __mode); } | |
8106 | int | |
8107 | pubsync() { return this->sync(); } | |
8108 | streamsize | |
8109 | in_avail() | |
8110 | { | |
8111 | const streamsize __ret = this->egptr() - this->gptr(); | |
8112 | return __ret ? __ret : this->showmanyc(); | |
8113 | } | |
8114 | int_type | |
8115 | snextc() | |
8116 | { | |
8117 | int_type __ret = traits_type::eof(); | |
8118 | if (__builtin_expect(!traits_type::eq_int_type(this->sbumpc(), | |
8119 | __ret), true)) | |
8120 | __ret = this->sgetc(); | |
8121 | return __ret; | |
8122 | } | |
8123 | int_type | |
8124 | sbumpc() | |
8125 | { | |
8126 | int_type __ret; | |
8127 | if (__builtin_expect(this->gptr() < this->egptr(), true)) | |
8128 | { | |
8129 | __ret = traits_type::to_int_type(*this->gptr()); | |
8130 | this->gbump(1); | |
8131 | } | |
8132 | else | |
8133 | __ret = this->uflow(); | |
8134 | return __ret; | |
8135 | } | |
8136 | int_type | |
8137 | sgetc() | |
8138 | { | |
8139 | int_type __ret; | |
8140 | if (__builtin_expect(this->gptr() < this->egptr(), true)) | |
8141 | __ret = traits_type::to_int_type(*this->gptr()); | |
8142 | else | |
8143 | __ret = this->underflow(); | |
8144 | return __ret; | |
8145 | } | |
8146 | streamsize | |
8147 | sgetn(char_type* __s, streamsize __n) | |
8148 | { return this->xsgetn(__s, __n); } | |
8149 | int_type | |
8150 | sputbackc(char_type __c) | |
8151 | { | |
8152 | int_type __ret; | |
8153 | const bool __testpos = this->eback() < this->gptr(); | |
8154 | if (__builtin_expect(!__testpos || | |
8155 | !traits_type::eq(__c, this->gptr()[-1]), false)) | |
8156 | __ret = this->pbackfail(traits_type::to_int_type(__c)); | |
8157 | else | |
8158 | { | |
8159 | this->gbump(-1); | |
8160 | __ret = traits_type::to_int_type(*this->gptr()); | |
8161 | } | |
8162 | return __ret; | |
8163 | } | |
8164 | int_type | |
8165 | sungetc() | |
8166 | { | |
8167 | int_type __ret; | |
8168 | if (__builtin_expect(this->eback() < this->gptr(), true)) | |
8169 | { | |
8170 | this->gbump(-1); | |
8171 | __ret = traits_type::to_int_type(*this->gptr()); | |
8172 | } | |
8173 | else | |
8174 | __ret = this->pbackfail(); | |
8175 | return __ret; | |
8176 | } | |
8177 | int_type | |
8178 | sputc(char_type __c) | |
8179 | { | |
8180 | int_type __ret; | |
8181 | if (__builtin_expect(this->pptr() < this->epptr(), true)) | |
8182 | { | |
8183 | *this->pptr() = __c; | |
8184 | this->pbump(1); | |
8185 | __ret = traits_type::to_int_type(__c); | |
8186 | } | |
8187 | else | |
8188 | __ret = this->overflow(traits_type::to_int_type(__c)); | |
8189 | return __ret; | |
8190 | } | |
8191 | streamsize | |
8192 | sputn(const char_type* __s, streamsize __n) | |
8193 | { return this->xsputn(__s, __n); } | |
8194 | protected: | |
8195 | basic_streambuf() | |
8196 | : _M_in_beg(0), _M_in_cur(0), _M_in_end(0), | |
8197 | _M_out_beg(0), _M_out_cur(0), _M_out_end(0), | |
8198 | _M_buf_locale(locale()) | |
8199 | { } | |
8200 | char_type* | |
8201 | eback() const { return _M_in_beg; } | |
8202 | char_type* | |
8203 | gptr() const { return _M_in_cur; } | |
8204 | char_type* | |
8205 | egptr() const { return _M_in_end; } | |
8206 | void | |
8207 | gbump(int __n) { _M_in_cur += __n; } | |
8208 | void | |
8209 | setg(char_type* __gbeg, char_type* __gnext, char_type* __gend) | |
8210 | { | |
8211 | _M_in_beg = __gbeg; | |
8212 | _M_in_cur = __gnext; | |
8213 | _M_in_end = __gend; | |
8214 | } | |
8215 | char_type* | |
8216 | pbase() const { return _M_out_beg; } | |
8217 | char_type* | |
8218 | pptr() const { return _M_out_cur; } | |
8219 | char_type* | |
8220 | epptr() const { return _M_out_end; } | |
8221 | void | |
8222 | pbump(int __n) { _M_out_cur += __n; } | |
8223 | void | |
8224 | setp(char_type* __pbeg, char_type* __pend) | |
8225 | { | |
8226 | _M_out_beg = _M_out_cur = __pbeg; | |
8227 | _M_out_end = __pend; | |
8228 | } | |
8229 | virtual void | |
8230 | imbue(const locale&) | |
8231 | { } | |
8232 | virtual basic_streambuf<char_type,_Traits>* | |
8233 | setbuf(char_type*, streamsize) | |
8234 | { return this; } | |
8235 | virtual pos_type | |
8236 | seekoff(off_type, ios_base::seekdir, | |
8237 | ios_base::openmode = ios_base::in | ios_base::out) | |
8238 | { return pos_type(off_type(-1)); } | |
8239 | virtual pos_type | |
8240 | seekpos(pos_type, | |
8241 | ios_base::openmode = ios_base::in | ios_base::out) | |
8242 | { return pos_type(off_type(-1)); } | |
8243 | virtual int | |
8244 | sync() { return 0; } | |
8245 | virtual streamsize | |
8246 | showmanyc() { return 0; } | |
8247 | virtual streamsize | |
8248 | xsgetn(char_type* __s, streamsize __n); | |
8249 | virtual int_type | |
8250 | underflow() | |
8251 | { return traits_type::eof(); } | |
8252 | virtual int_type | |
8253 | uflow() | |
8254 | { | |
8255 | int_type __ret = traits_type::eof(); | |
8256 | const bool __testeof = traits_type::eq_int_type(this->underflow(), | |
8257 | __ret); | |
8258 | if (!__testeof) | |
8259 | { | |
8260 | __ret = traits_type::to_int_type(*this->gptr()); | |
8261 | this->gbump(1); | |
8262 | } | |
8263 | return __ret; | |
8264 | } | |
8265 | virtual int_type | |
8266 | pbackfail(int_type = traits_type::eof()) | |
8267 | { return traits_type::eof(); } | |
8268 | virtual streamsize | |
8269 | xsputn(const char_type* __s, streamsize __n); | |
8270 | virtual int_type | |
8271 | overflow(int_type = traits_type::eof()) | |
8272 | { return traits_type::eof(); } | |
8273 | public: | |
8274 | void | |
8275 | stossc() | |
8276 | { | |
8277 | if (this->gptr() < this->egptr()) | |
8278 | this->gbump(1); | |
8279 | else | |
8280 | this->uflow(); | |
8281 | } | |
8282 | private: | |
8283 | basic_streambuf(const __streambuf_type& __sb) | |
8284 | : _M_in_beg(__sb._M_in_beg), _M_in_cur(__sb._M_in_cur), | |
8285 | _M_in_end(__sb._M_in_end), _M_out_beg(__sb._M_out_beg), | |
8286 | _M_out_cur(__sb._M_out_cur), _M_out_end(__sb._M_out_cur), | |
8287 | _M_buf_locale(__sb._M_buf_locale) | |
8288 | { } | |
8289 | __streambuf_type& | |
8290 | operator=(const __streambuf_type&) { return *this; }; | |
8291 | }; | |
8292 | template<> | |
8293 | streamsize | |
8294 | __copy_streambufs_eof(basic_streambuf<char>* __sbin, | |
8295 | basic_streambuf<char>* __sbout, bool& __ineof); | |
8296 | } | |
8297 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
8298 | template<typename _CharT, typename _Traits> | |
8299 | streamsize | |
8300 | basic_streambuf<_CharT, _Traits>:: | |
8301 | xsgetn(char_type* __s, streamsize __n) | |
8302 | { | |
8303 | streamsize __ret = 0; | |
8304 | while (__ret < __n) | |
8305 | { | |
8306 | const streamsize __buf_len = this->egptr() - this->gptr(); | |
8307 | if (__buf_len) | |
8308 | { | |
8309 | const streamsize __remaining = __n - __ret; | |
8310 | const streamsize __len = std::min(__buf_len, __remaining); | |
8311 | traits_type::copy(__s, this->gptr(), __len); | |
8312 | __ret += __len; | |
8313 | __s += __len; | |
8314 | this->gbump(__len); | |
8315 | } | |
8316 | if (__ret < __n) | |
8317 | { | |
8318 | const int_type __c = this->uflow(); | |
8319 | if (!traits_type::eq_int_type(__c, traits_type::eof())) | |
8320 | { | |
8321 | traits_type::assign(*__s++, traits_type::to_char_type(__c)); | |
8322 | ++__ret; | |
8323 | } | |
8324 | else | |
8325 | break; | |
8326 | } | |
8327 | } | |
8328 | return __ret; | |
8329 | } | |
8330 | template<typename _CharT, typename _Traits> | |
8331 | streamsize | |
8332 | basic_streambuf<_CharT, _Traits>:: | |
8333 | xsputn(const char_type* __s, streamsize __n) | |
8334 | { | |
8335 | streamsize __ret = 0; | |
8336 | while (__ret < __n) | |
8337 | { | |
8338 | const streamsize __buf_len = this->epptr() - this->pptr(); | |
8339 | if (__buf_len) | |
8340 | { | |
8341 | const streamsize __remaining = __n - __ret; | |
8342 | const streamsize __len = std::min(__buf_len, __remaining); | |
8343 | traits_type::copy(this->pptr(), __s, __len); | |
8344 | __ret += __len; | |
8345 | __s += __len; | |
8346 | this->pbump(__len); | |
8347 | } | |
8348 | if (__ret < __n) | |
8349 | { | |
8350 | int_type __c = this->overflow(traits_type::to_int_type(*__s)); | |
8351 | if (!traits_type::eq_int_type(__c, traits_type::eof())) | |
8352 | { | |
8353 | ++__ret; | |
8354 | ++__s; | |
8355 | } | |
8356 | else | |
8357 | break; | |
8358 | } | |
8359 | } | |
8360 | return __ret; | |
8361 | } | |
8362 | template<typename _CharT, typename _Traits> | |
8363 | streamsize | |
8364 | __copy_streambufs_eof(basic_streambuf<_CharT, _Traits>* __sbin, | |
8365 | basic_streambuf<_CharT, _Traits>* __sbout, | |
8366 | bool& __ineof) | |
8367 | { | |
8368 | streamsize __ret = 0; | |
8369 | __ineof = true; | |
8370 | typename _Traits::int_type __c = __sbin->sgetc(); | |
8371 | while (!_Traits::eq_int_type(__c, _Traits::eof())) | |
8372 | { | |
8373 | __c = __sbout->sputc(_Traits::to_char_type(__c)); | |
8374 | if (_Traits::eq_int_type(__c, _Traits::eof())) | |
8375 | { | |
8376 | __ineof = false; | |
8377 | break; | |
8378 | } | |
8379 | ++__ret; | |
8380 | __c = __sbin->snextc(); | |
8381 | } | |
8382 | return __ret; | |
8383 | } | |
8384 | template<typename _CharT, typename _Traits> | |
8385 | inline streamsize | |
8386 | __copy_streambufs(basic_streambuf<_CharT, _Traits>* __sbin, | |
8387 | basic_streambuf<_CharT, _Traits>* __sbout) | |
8388 | { | |
8389 | bool __ineof; | |
8390 | return __copy_streambufs_eof(__sbin, __sbout, __ineof); | |
8391 | } | |
8392 | extern template class basic_streambuf<char>; | |
8393 | extern template | |
8394 | streamsize | |
8395 | __copy_streambufs(basic_streambuf<char>*, | |
8396 | basic_streambuf<char>*); | |
8397 | extern template | |
8398 | streamsize | |
8399 | __copy_streambufs_eof(basic_streambuf<char>*, | |
8400 | basic_streambuf<char>*, bool&); | |
8401 | } | |
8402 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
8403 | struct ctype_base | |
8404 | { | |
8405 | typedef const __ctype_touplow_t* __to_type; | |
8406 | typedef __ctype_mask_t mask; | |
8407 | static const mask upper = _ISupper; | |
8408 | static const mask lower = _ISlower; | |
8409 | static const mask alpha = _ISalpha; | |
8410 | static const mask digit = _ISdigit; | |
8411 | static const mask xdigit = _ISxdigit; | |
8412 | static const mask space = _ISspace; | |
8413 | static const mask print = _ISprint; | |
8414 | static const mask graph = _ISalpha | _ISdigit | _ISpunct; | |
8415 | static const mask cntrl = _IScntrl; | |
8416 | static const mask punct = _ISpunct; | |
8417 | static const mask alnum = _ISalpha | _ISdigit; | |
8418 | }; | |
8419 | } | |
8420 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
8421 | template<typename _CharT, typename _Traits> | |
8422 | class istreambuf_iterator | |
8423 | : public iterator<input_iterator_tag, _CharT, typename _Traits::off_type, | |
8424 | _CharT*, _CharT&> | |
8425 | { | |
8426 | public: | |
8427 | typedef _CharT char_type; | |
8428 | typedef _Traits traits_type; | |
8429 | typedef typename _Traits::int_type int_type; | |
8430 | typedef basic_streambuf<_CharT, _Traits> streambuf_type; | |
8431 | typedef basic_istream<_CharT, _Traits> istream_type; | |
8432 | template<typename _CharT2> | |
8433 | friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, | |
8434 | ostreambuf_iterator<_CharT2> >::__type | |
8435 | copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, | |
8436 | ostreambuf_iterator<_CharT2>); | |
8437 | template<bool _IsMove, typename _CharT2> | |
8438 | friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, | |
8439 | _CharT2*>::__type | |
8440 | __copy_move_a2(istreambuf_iterator<_CharT2>, | |
8441 | istreambuf_iterator<_CharT2>, _CharT2*); | |
8442 | template<typename _CharT2> | |
8443 | friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, | |
8444 | istreambuf_iterator<_CharT2> >::__type | |
8445 | find(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, | |
8446 | const _CharT2&); | |
8447 | private: | |
8448 | mutable streambuf_type* _M_sbuf; | |
8449 | mutable int_type _M_c; | |
8450 | public: | |
8451 | istreambuf_iterator() throw() | |
8452 | : _M_sbuf(0), _M_c(traits_type::eof()) { } | |
8453 | istreambuf_iterator(istream_type& __s) throw() | |
8454 | : _M_sbuf(__s.rdbuf()), _M_c(traits_type::eof()) { } | |
8455 | istreambuf_iterator(streambuf_type* __s) throw() | |
8456 | : _M_sbuf(__s), _M_c(traits_type::eof()) { } | |
8457 | char_type | |
8458 | operator*() const | |
8459 | { | |
8460 | return traits_type::to_char_type(_M_get()); | |
8461 | } | |
8462 | istreambuf_iterator& | |
8463 | operator++() | |
8464 | { | |
8465 | ; | |
8466 | if (_M_sbuf) | |
8467 | { | |
8468 | _M_sbuf->sbumpc(); | |
8469 | _M_c = traits_type::eof(); | |
8470 | } | |
8471 | return *this; | |
8472 | } | |
8473 | istreambuf_iterator | |
8474 | operator++(int) | |
8475 | { | |
8476 | ; | |
8477 | istreambuf_iterator __old = *this; | |
8478 | if (_M_sbuf) | |
8479 | { | |
8480 | __old._M_c = _M_sbuf->sbumpc(); | |
8481 | _M_c = traits_type::eof(); | |
8482 | } | |
8483 | return __old; | |
8484 | } | |
8485 | bool | |
8486 | equal(const istreambuf_iterator& __b) const | |
8487 | { return _M_at_eof() == __b._M_at_eof(); } | |
8488 | private: | |
8489 | int_type | |
8490 | _M_get() const | |
8491 | { | |
8492 | const int_type __eof = traits_type::eof(); | |
8493 | int_type __ret = __eof; | |
8494 | if (_M_sbuf) | |
8495 | { | |
8496 | if (!traits_type::eq_int_type(_M_c, __eof)) | |
8497 | __ret = _M_c; | |
8498 | else if (!traits_type::eq_int_type((__ret = _M_sbuf->sgetc()), | |
8499 | __eof)) | |
8500 | _M_c = __ret; | |
8501 | else | |
8502 | _M_sbuf = 0; | |
8503 | } | |
8504 | return __ret; | |
8505 | } | |
8506 | bool | |
8507 | _M_at_eof() const | |
8508 | { | |
8509 | const int_type __eof = traits_type::eof(); | |
8510 | return traits_type::eq_int_type(_M_get(), __eof); | |
8511 | } | |
8512 | }; | |
8513 | template<typename _CharT, typename _Traits> | |
8514 | inline bool | |
8515 | operator==(const istreambuf_iterator<_CharT, _Traits>& __a, | |
8516 | const istreambuf_iterator<_CharT, _Traits>& __b) | |
8517 | { return __a.equal(__b); } | |
8518 | template<typename _CharT, typename _Traits> | |
8519 | inline bool | |
8520 | operator!=(const istreambuf_iterator<_CharT, _Traits>& __a, | |
8521 | const istreambuf_iterator<_CharT, _Traits>& __b) | |
8522 | { return !__a.equal(__b); } | |
8523 | template<typename _CharT, typename _Traits> | |
8524 | class ostreambuf_iterator | |
8525 | : public iterator<output_iterator_tag, void, void, void, void> | |
8526 | { | |
8527 | public: | |
8528 | typedef _CharT char_type; | |
8529 | typedef _Traits traits_type; | |
8530 | typedef basic_streambuf<_CharT, _Traits> streambuf_type; | |
8531 | typedef basic_ostream<_CharT, _Traits> ostream_type; | |
8532 | template<typename _CharT2> | |
8533 | friend typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, | |
8534 | ostreambuf_iterator<_CharT2> >::__type | |
8535 | copy(istreambuf_iterator<_CharT2>, istreambuf_iterator<_CharT2>, | |
8536 | ostreambuf_iterator<_CharT2>); | |
8537 | private: | |
8538 | streambuf_type* _M_sbuf; | |
8539 | bool _M_failed; | |
8540 | public: | |
8541 | ostreambuf_iterator(ostream_type& __s) throw () | |
8542 | : _M_sbuf(__s.rdbuf()), _M_failed(!_M_sbuf) { } | |
8543 | ostreambuf_iterator(streambuf_type* __s) throw () | |
8544 | : _M_sbuf(__s), _M_failed(!_M_sbuf) { } | |
8545 | ostreambuf_iterator& | |
8546 | operator=(_CharT __c) | |
8547 | { | |
8548 | if (!_M_failed && | |
8549 | _Traits::eq_int_type(_M_sbuf->sputc(__c), _Traits::eof())) | |
8550 | _M_failed = true; | |
8551 | return *this; | |
8552 | } | |
8553 | ostreambuf_iterator& | |
8554 | operator*() | |
8555 | { return *this; } | |
8556 | ostreambuf_iterator& | |
8557 | operator++(int) | |
8558 | { return *this; } | |
8559 | ostreambuf_iterator& | |
8560 | operator++() | |
8561 | { return *this; } | |
8562 | bool | |
8563 | failed() const throw() | |
8564 | { return _M_failed; } | |
8565 | ostreambuf_iterator& | |
8566 | _M_put(const _CharT* __ws, streamsize __len) | |
8567 | { | |
8568 | if (__builtin_expect(!_M_failed, true) | |
8569 | && __builtin_expect(this->_M_sbuf->sputn(__ws, __len) != __len, | |
8570 | false)) | |
8571 | _M_failed = true; | |
8572 | return *this; | |
8573 | } | |
8574 | }; | |
8575 | template<typename _CharT> | |
8576 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
8577 | ostreambuf_iterator<_CharT> >::__type | |
8578 | copy(istreambuf_iterator<_CharT> __first, | |
8579 | istreambuf_iterator<_CharT> __last, | |
8580 | ostreambuf_iterator<_CharT> __result) | |
8581 | { | |
8582 | if (__first._M_sbuf && !__last._M_sbuf && !__result._M_failed) | |
8583 | { | |
8584 | bool __ineof; | |
8585 | __copy_streambufs_eof(__first._M_sbuf, __result._M_sbuf, __ineof); | |
8586 | if (!__ineof) | |
8587 | __result._M_failed = true; | |
8588 | } | |
8589 | return __result; | |
8590 | } | |
8591 | template<bool _IsMove, typename _CharT> | |
8592 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
8593 | ostreambuf_iterator<_CharT> >::__type | |
8594 | __copy_move_a2(_CharT* __first, _CharT* __last, | |
8595 | ostreambuf_iterator<_CharT> __result) | |
8596 | { | |
8597 | const streamsize __num = __last - __first; | |
8598 | if (__num > 0) | |
8599 | __result._M_put(__first, __num); | |
8600 | return __result; | |
8601 | } | |
8602 | template<bool _IsMove, typename _CharT> | |
8603 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
8604 | ostreambuf_iterator<_CharT> >::__type | |
8605 | __copy_move_a2(const _CharT* __first, const _CharT* __last, | |
8606 | ostreambuf_iterator<_CharT> __result) | |
8607 | { | |
8608 | const streamsize __num = __last - __first; | |
8609 | if (__num > 0) | |
8610 | __result._M_put(__first, __num); | |
8611 | return __result; | |
8612 | } | |
8613 | template<bool _IsMove, typename _CharT> | |
8614 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
8615 | _CharT*>::__type | |
8616 | __copy_move_a2(istreambuf_iterator<_CharT> __first, | |
8617 | istreambuf_iterator<_CharT> __last, _CharT* __result) | |
8618 | { | |
8619 | typedef istreambuf_iterator<_CharT> __is_iterator_type; | |
8620 | typedef typename __is_iterator_type::traits_type traits_type; | |
8621 | typedef typename __is_iterator_type::streambuf_type streambuf_type; | |
8622 | typedef typename traits_type::int_type int_type; | |
8623 | if (__first._M_sbuf && !__last._M_sbuf) | |
8624 | { | |
8625 | streambuf_type* __sb = __first._M_sbuf; | |
8626 | int_type __c = __sb->sgetc(); | |
8627 | while (!traits_type::eq_int_type(__c, traits_type::eof())) | |
8628 | { | |
8629 | const streamsize __n = __sb->egptr() - __sb->gptr(); | |
8630 | if (__n > 1) | |
8631 | { | |
8632 | traits_type::copy(__result, __sb->gptr(), __n); | |
8633 | __sb->gbump(__n); | |
8634 | __result += __n; | |
8635 | __c = __sb->underflow(); | |
8636 | } | |
8637 | else | |
8638 | { | |
8639 | *__result++ = traits_type::to_char_type(__c); | |
8640 | __c = __sb->snextc(); | |
8641 | } | |
8642 | } | |
8643 | } | |
8644 | return __result; | |
8645 | } | |
8646 | template<typename _CharT> | |
8647 | typename __gnu_cxx::__enable_if<__is_char<_CharT>::__value, | |
8648 | istreambuf_iterator<_CharT> >::__type | |
8649 | find(istreambuf_iterator<_CharT> __first, | |
8650 | istreambuf_iterator<_CharT> __last, const _CharT& __val) | |
8651 | { | |
8652 | typedef istreambuf_iterator<_CharT> __is_iterator_type; | |
8653 | typedef typename __is_iterator_type::traits_type traits_type; | |
8654 | typedef typename __is_iterator_type::streambuf_type streambuf_type; | |
8655 | typedef typename traits_type::int_type int_type; | |
8656 | if (__first._M_sbuf && !__last._M_sbuf) | |
8657 | { | |
8658 | const int_type __ival = traits_type::to_int_type(__val); | |
8659 | streambuf_type* __sb = __first._M_sbuf; | |
8660 | int_type __c = __sb->sgetc(); | |
8661 | while (!traits_type::eq_int_type(__c, traits_type::eof()) | |
8662 | && !traits_type::eq_int_type(__c, __ival)) | |
8663 | { | |
8664 | streamsize __n = __sb->egptr() - __sb->gptr(); | |
8665 | if (__n > 1) | |
8666 | { | |
8667 | const _CharT* __p = traits_type::find(__sb->gptr(), | |
8668 | __n, __val); | |
8669 | if (__p) | |
8670 | __n = __p - __sb->gptr(); | |
8671 | __sb->gbump(__n); | |
8672 | __c = __sb->sgetc(); | |
8673 | } | |
8674 | else | |
8675 | __c = __sb->snextc(); | |
8676 | } | |
8677 | if (!traits_type::eq_int_type(__c, traits_type::eof())) | |
8678 | __first._M_c = __c; | |
8679 | else | |
8680 | __first._M_sbuf = 0; | |
8681 | } | |
8682 | return __first; | |
8683 | } | |
8684 | } | |
8685 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
8686 | template<typename _Tv> | |
8687 | void | |
8688 | __convert_to_v(const char* __in, _Tv& __out, ios_base::iostate& __err, | |
8689 | const __c_locale& __cloc); | |
8690 | template<> | |
8691 | void | |
8692 | __convert_to_v(const char*, float&, ios_base::iostate&, | |
8693 | const __c_locale&); | |
8694 | template<> | |
8695 | void | |
8696 | __convert_to_v(const char*, double&, ios_base::iostate&, | |
8697 | const __c_locale&); | |
8698 | template<> | |
8699 | void | |
8700 | __convert_to_v(const char*, long double&, ios_base::iostate&, | |
8701 | const __c_locale&); | |
8702 | template<typename _CharT, typename _Traits> | |
8703 | struct __pad | |
8704 | { | |
8705 | static void | |
8706 | _S_pad(ios_base& __io, _CharT __fill, _CharT* __news, | |
8707 | const _CharT* __olds, const streamsize __newlen, | |
8708 | const streamsize __oldlen); | |
8709 | }; | |
8710 | template<typename _CharT> | |
8711 | _CharT* | |
8712 | __add_grouping(_CharT* __s, _CharT __sep, | |
8713 | const char* __gbeg, size_t __gsize, | |
8714 | const _CharT* __first, const _CharT* __last); | |
8715 | template<typename _CharT> | |
8716 | inline | |
8717 | ostreambuf_iterator<_CharT> | |
8718 | __write(ostreambuf_iterator<_CharT> __s, const _CharT* __ws, int __len) | |
8719 | { | |
8720 | __s._M_put(__ws, __len); | |
8721 | return __s; | |
8722 | } | |
8723 | template<typename _CharT, typename _OutIter> | |
8724 | inline | |
8725 | _OutIter | |
8726 | __write(_OutIter __s, const _CharT* __ws, int __len) | |
8727 | { | |
8728 | for (int __j = 0; __j < __len; __j++, ++__s) | |
8729 | *__s = __ws[__j]; | |
8730 | return __s; | |
8731 | } | |
8732 | template<typename _CharT> | |
8733 | class __ctype_abstract_base : public locale::facet, public ctype_base | |
8734 | { | |
8735 | public: | |
8736 | typedef _CharT char_type; | |
8737 | bool | |
8738 | is(mask __m, char_type __c) const | |
8739 | { return this->do_is(__m, __c); } | |
8740 | const char_type* | |
8741 | is(const char_type *__lo, const char_type *__hi, mask *__vec) const | |
8742 | { return this->do_is(__lo, __hi, __vec); } | |
8743 | const char_type* | |
8744 | scan_is(mask __m, const char_type* __lo, const char_type* __hi) const | |
8745 | { return this->do_scan_is(__m, __lo, __hi); } | |
8746 | const char_type* | |
8747 | scan_not(mask __m, const char_type* __lo, const char_type* __hi) const | |
8748 | { return this->do_scan_not(__m, __lo, __hi); } | |
8749 | char_type | |
8750 | toupper(char_type __c) const | |
8751 | { return this->do_toupper(__c); } | |
8752 | const char_type* | |
8753 | toupper(char_type *__lo, const char_type* __hi) const | |
8754 | { return this->do_toupper(__lo, __hi); } | |
8755 | char_type | |
8756 | tolower(char_type __c) const | |
8757 | { return this->do_tolower(__c); } | |
8758 | const char_type* | |
8759 | tolower(char_type* __lo, const char_type* __hi) const | |
8760 | { return this->do_tolower(__lo, __hi); } | |
8761 | char_type | |
8762 | widen(char __c) const | |
8763 | { return this->do_widen(__c); } | |
8764 | const char* | |
8765 | widen(const char* __lo, const char* __hi, char_type* __to) const | |
8766 | { return this->do_widen(__lo, __hi, __to); } | |
8767 | char | |
8768 | narrow(char_type __c, char __dfault) const | |
8769 | { return this->do_narrow(__c, __dfault); } | |
8770 | const char_type* | |
8771 | narrow(const char_type* __lo, const char_type* __hi, | |
8772 | char __dfault, char *__to) const | |
8773 | { return this->do_narrow(__lo, __hi, __dfault, __to); } | |
8774 | protected: | |
8775 | explicit | |
8776 | __ctype_abstract_base(size_t __refs = 0): facet(__refs) { } | |
8777 | virtual | |
8778 | ~__ctype_abstract_base() { } | |
8779 | virtual bool | |
8780 | do_is(mask __m, char_type __c) const = 0; | |
8781 | virtual const char_type* | |
8782 | do_is(const char_type* __lo, const char_type* __hi, | |
8783 | mask* __vec) const = 0; | |
8784 | virtual const char_type* | |
8785 | do_scan_is(mask __m, const char_type* __lo, | |
8786 | const char_type* __hi) const = 0; | |
8787 | virtual const char_type* | |
8788 | do_scan_not(mask __m, const char_type* __lo, | |
8789 | const char_type* __hi) const = 0; | |
8790 | virtual char_type | |
8791 | do_toupper(char_type) const = 0; | |
8792 | virtual const char_type* | |
8793 | do_toupper(char_type* __lo, const char_type* __hi) const = 0; | |
8794 | virtual char_type | |
8795 | do_tolower(char_type) const = 0; | |
8796 | virtual const char_type* | |
8797 | do_tolower(char_type* __lo, const char_type* __hi) const = 0; | |
8798 | virtual char_type | |
8799 | do_widen(char) const = 0; | |
8800 | virtual const char* | |
8801 | do_widen(const char* __lo, const char* __hi, | |
8802 | char_type* __dest) const = 0; | |
8803 | virtual char | |
8804 | do_narrow(char_type, char __dfault) const = 0; | |
8805 | virtual const char_type* | |
8806 | do_narrow(const char_type* __lo, const char_type* __hi, | |
8807 | char __dfault, char* __dest) const = 0; | |
8808 | }; | |
8809 | template<typename _CharT> | |
8810 | class ctype : public __ctype_abstract_base<_CharT> | |
8811 | { | |
8812 | public: | |
8813 | typedef _CharT char_type; | |
8814 | typedef typename __ctype_abstract_base<_CharT>::mask mask; | |
8815 | static locale::id id; | |
8816 | explicit | |
8817 | ctype(size_t __refs = 0) : __ctype_abstract_base<_CharT>(__refs) { } | |
8818 | protected: | |
8819 | virtual | |
8820 | ~ctype(); | |
8821 | virtual bool | |
8822 | do_is(mask __m, char_type __c) const; | |
8823 | virtual const char_type* | |
8824 | do_is(const char_type* __lo, const char_type* __hi, mask* __vec) const; | |
8825 | virtual const char_type* | |
8826 | do_scan_is(mask __m, const char_type* __lo, const char_type* __hi) const; | |
8827 | virtual const char_type* | |
8828 | do_scan_not(mask __m, const char_type* __lo, | |
8829 | const char_type* __hi) const; | |
8830 | virtual char_type | |
8831 | do_toupper(char_type __c) const; | |
8832 | virtual const char_type* | |
8833 | do_toupper(char_type* __lo, const char_type* __hi) const; | |
8834 | virtual char_type | |
8835 | do_tolower(char_type __c) const; | |
8836 | virtual const char_type* | |
8837 | do_tolower(char_type* __lo, const char_type* __hi) const; | |
8838 | virtual char_type | |
8839 | do_widen(char __c) const; | |
8840 | virtual const char* | |
8841 | do_widen(const char* __lo, const char* __hi, char_type* __dest) const; | |
8842 | virtual char | |
8843 | do_narrow(char_type, char __dfault) const; | |
8844 | virtual const char_type* | |
8845 | do_narrow(const char_type* __lo, const char_type* __hi, | |
8846 | char __dfault, char* __dest) const; | |
8847 | }; | |
8848 | template<typename _CharT> | |
8849 | locale::id ctype<_CharT>::id; | |
8850 | template<> | |
8851 | class ctype<char> : public locale::facet, public ctype_base | |
8852 | { | |
8853 | public: | |
8854 | typedef char char_type; | |
8855 | protected: | |
8856 | __c_locale _M_c_locale_ctype; | |
8857 | bool _M_del; | |
8858 | __to_type _M_toupper; | |
8859 | __to_type _M_tolower; | |
8860 | const mask* _M_table; | |
8861 | mutable char _M_widen_ok; | |
8862 | mutable char _M_widen[1 + static_cast<unsigned char>(-1)]; | |
8863 | mutable char _M_narrow[1 + static_cast<unsigned char>(-1)]; | |
8864 | mutable char _M_narrow_ok; | |
8865 | public: | |
8866 | static locale::id id; | |
8867 | static const size_t table_size = 1 + static_cast<unsigned char>(-1); | |
8868 | explicit | |
8869 | ctype(const mask* __table = 0, bool __del = false, size_t __refs = 0); | |
8870 | explicit | |
8871 | ctype(__c_locale __cloc, const mask* __table = 0, bool __del = false, | |
8872 | size_t __refs = 0); | |
8873 | inline bool | |
8874 | is(mask __m, char __c) const; | |
8875 | inline const char* | |
8876 | is(const char* __lo, const char* __hi, mask* __vec) const; | |
8877 | inline const char* | |
8878 | scan_is(mask __m, const char* __lo, const char* __hi) const; | |
8879 | inline const char* | |
8880 | scan_not(mask __m, const char* __lo, const char* __hi) const; | |
8881 | char_type | |
8882 | toupper(char_type __c) const | |
8883 | { return this->do_toupper(__c); } | |
8884 | const char_type* | |
8885 | toupper(char_type *__lo, const char_type* __hi) const | |
8886 | { return this->do_toupper(__lo, __hi); } | |
8887 | char_type | |
8888 | tolower(char_type __c) const | |
8889 | { return this->do_tolower(__c); } | |
8890 | const char_type* | |
8891 | tolower(char_type* __lo, const char_type* __hi) const | |
8892 | { return this->do_tolower(__lo, __hi); } | |
8893 | char_type | |
8894 | widen(char __c) const | |
8895 | { | |
8896 | if (_M_widen_ok) | |
8897 | return _M_widen[static_cast<unsigned char>(__c)]; | |
8898 | this->_M_widen_init(); | |
8899 | return this->do_widen(__c); | |
8900 | } | |
8901 | const char* | |
8902 | widen(const char* __lo, const char* __hi, char_type* __to) const | |
8903 | { | |
8904 | if (_M_widen_ok == 1) | |
8905 | { | |
8906 | __builtin_memcpy(__to, __lo, __hi - __lo); | |
8907 | return __hi; | |
8908 | } | |
8909 | if (!_M_widen_ok) | |
8910 | _M_widen_init(); | |
8911 | return this->do_widen(__lo, __hi, __to); | |
8912 | } | |
8913 | char | |
8914 | narrow(char_type __c, char __dfault) const | |
8915 | { | |
8916 | if (_M_narrow[static_cast<unsigned char>(__c)]) | |
8917 | return _M_narrow[static_cast<unsigned char>(__c)]; | |
8918 | const char __t = do_narrow(__c, __dfault); | |
8919 | if (__t != __dfault) | |
8920 | _M_narrow[static_cast<unsigned char>(__c)] = __t; | |
8921 | return __t; | |
8922 | } | |
8923 | const char_type* | |
8924 | narrow(const char_type* __lo, const char_type* __hi, | |
8925 | char __dfault, char *__to) const | |
8926 | { | |
8927 | if (__builtin_expect(_M_narrow_ok == 1, true)) | |
8928 | { | |
8929 | __builtin_memcpy(__to, __lo, __hi - __lo); | |
8930 | return __hi; | |
8931 | } | |
8932 | if (!_M_narrow_ok) | |
8933 | _M_narrow_init(); | |
8934 | return this->do_narrow(__lo, __hi, __dfault, __to); | |
8935 | } | |
8936 | const mask* | |
8937 | table() const throw() | |
8938 | { return _M_table; } | |
8939 | static const mask* | |
8940 | classic_table() throw(); | |
8941 | protected: | |
8942 | virtual | |
8943 | ~ctype(); | |
8944 | virtual char_type | |
8945 | do_toupper(char_type) const; | |
8946 | virtual const char_type* | |
8947 | do_toupper(char_type* __lo, const char_type* __hi) const; | |
8948 | virtual char_type | |
8949 | do_tolower(char_type) const; | |
8950 | virtual const char_type* | |
8951 | do_tolower(char_type* __lo, const char_type* __hi) const; | |
8952 | virtual char_type | |
8953 | do_widen(char __c) const | |
8954 | { return __c; } | |
8955 | virtual const char* | |
8956 | do_widen(const char* __lo, const char* __hi, char_type* __dest) const | |
8957 | { | |
8958 | __builtin_memcpy(__dest, __lo, __hi - __lo); | |
8959 | return __hi; | |
8960 | } | |
8961 | virtual char | |
8962 | do_narrow(char_type __c, char) const | |
8963 | { return __c; } | |
8964 | virtual const char_type* | |
8965 | do_narrow(const char_type* __lo, const char_type* __hi, | |
8966 | char, char* __dest) const | |
8967 | { | |
8968 | __builtin_memcpy(__dest, __lo, __hi - __lo); | |
8969 | return __hi; | |
8970 | } | |
8971 | private: | |
8972 | void _M_widen_init() const | |
8973 | { | |
8974 | char __tmp[sizeof(_M_widen)]; | |
8975 | for (size_t __i = 0; __i < sizeof(_M_widen); ++__i) | |
8976 | __tmp[__i] = __i; | |
8977 | do_widen(__tmp, __tmp + sizeof(__tmp), _M_widen); | |
8978 | _M_widen_ok = 1; | |
8979 | if (__builtin_memcmp(__tmp, _M_widen, sizeof(_M_widen))) | |
8980 | _M_widen_ok = 2; | |
8981 | } | |
8982 | void _M_narrow_init() const | |
8983 | { | |
8984 | char __tmp[sizeof(_M_narrow)]; | |
8985 | for (size_t __i = 0; __i < sizeof(_M_narrow); ++__i) | |
8986 | __tmp[__i] = __i; | |
8987 | do_narrow(__tmp, __tmp + sizeof(__tmp), 0, _M_narrow); | |
8988 | _M_narrow_ok = 1; | |
8989 | if (__builtin_memcmp(__tmp, _M_narrow, sizeof(_M_narrow))) | |
8990 | _M_narrow_ok = 2; | |
8991 | else | |
8992 | { | |
8993 | char __c; | |
8994 | do_narrow(__tmp, __tmp + 1, 1, &__c); | |
8995 | if (__c == 1) | |
8996 | _M_narrow_ok = 2; | |
8997 | } | |
8998 | } | |
8999 | }; | |
9000 | template<> | |
9001 | const ctype<char>& | |
9002 | use_facet<ctype<char> >(const locale& __loc); | |
9003 | template<typename _CharT> | |
9004 | class ctype_byname : public ctype<_CharT> | |
9005 | { | |
9006 | public: | |
9007 | typedef typename ctype<_CharT>::mask mask; | |
9008 | explicit | |
9009 | ctype_byname(const char* __s, size_t __refs = 0); | |
9010 | protected: | |
9011 | virtual | |
9012 | ~ctype_byname() { }; | |
9013 | }; | |
9014 | template<> | |
9015 | class ctype_byname<char> : public ctype<char> | |
9016 | { | |
9017 | public: | |
9018 | explicit | |
9019 | ctype_byname(const char* __s, size_t __refs = 0); | |
9020 | protected: | |
9021 | virtual | |
9022 | ~ctype_byname(); | |
9023 | }; | |
9024 | } | |
9025 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
9026 | bool | |
9027 | ctype<char>:: | |
9028 | is(mask __m, char __c) const | |
9029 | { return _M_table[static_cast<unsigned char>(__c)] & __m; } | |
9030 | const char* | |
9031 | ctype<char>:: | |
9032 | is(const char* __low, const char* __high, mask* __vec) const | |
9033 | { | |
9034 | while (__low < __high) | |
9035 | *__vec++ = _M_table[static_cast<unsigned char>(*__low++)]; | |
9036 | return __high; | |
9037 | } | |
9038 | const char* | |
9039 | ctype<char>:: | |
9040 | scan_is(mask __m, const char* __low, const char* __high) const | |
9041 | { | |
9042 | while (__low < __high | |
9043 | && !(_M_table[static_cast<unsigned char>(*__low)] & __m)) | |
9044 | ++__low; | |
9045 | return __low; | |
9046 | } | |
9047 | const char* | |
9048 | ctype<char>:: | |
9049 | scan_not(mask __m, const char* __low, const char* __high) const | |
9050 | { | |
9051 | while (__low < __high | |
9052 | && (_M_table[static_cast<unsigned char>(*__low)] & __m) != 0) | |
9053 | ++__low; | |
9054 | return __low; | |
9055 | } | |
9056 | } | |
9057 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
9058 | class __num_base | |
9059 | { | |
9060 | public: | |
9061 | enum | |
9062 | { | |
9063 | _S_ominus, | |
9064 | _S_oplus, | |
9065 | _S_ox, | |
9066 | _S_oX, | |
9067 | _S_odigits, | |
9068 | _S_odigits_end = _S_odigits + 16, | |
9069 | _S_oudigits = _S_odigits_end, | |
9070 | _S_oudigits_end = _S_oudigits + 16, | |
9071 | _S_oe = _S_odigits + 14, | |
9072 | _S_oE = _S_oudigits + 14, | |
9073 | _S_oend = _S_oudigits_end | |
9074 | }; | |
9075 | static const char* _S_atoms_out; | |
9076 | static const char* _S_atoms_in; | |
9077 | enum | |
9078 | { | |
9079 | _S_iminus, | |
9080 | _S_iplus, | |
9081 | _S_ix, | |
9082 | _S_iX, | |
9083 | _S_izero, | |
9084 | _S_ie = _S_izero + 14, | |
9085 | _S_iE = _S_izero + 20, | |
9086 | _S_iend = 26 | |
9087 | }; | |
9088 | static void | |
9089 | _S_format_float(const ios_base& __io, char* __fptr, char __mod); | |
9090 | }; | |
9091 | template<typename _CharT> | |
9092 | struct __numpunct_cache : public locale::facet | |
9093 | { | |
9094 | const char* _M_grouping; | |
9095 | size_t _M_grouping_size; | |
9096 | bool _M_use_grouping; | |
9097 | const _CharT* _M_truename; | |
9098 | size_t _M_truename_size; | |
9099 | const _CharT* _M_falsename; | |
9100 | size_t _M_falsename_size; | |
9101 | _CharT _M_decimal_point; | |
9102 | _CharT _M_thousands_sep; | |
9103 | _CharT _M_atoms_out[__num_base::_S_oend]; | |
9104 | _CharT _M_atoms_in[__num_base::_S_iend]; | |
9105 | bool _M_allocated; | |
9106 | __numpunct_cache(size_t __refs = 0) : facet(__refs), | |
9107 | _M_grouping(__null), _M_grouping_size(0), _M_use_grouping(false), | |
9108 | _M_truename(__null), _M_truename_size(0), _M_falsename(__null), | |
9109 | _M_falsename_size(0), _M_decimal_point(_CharT()), | |
9110 | _M_thousands_sep(_CharT()), _M_allocated(false) | |
9111 | { } | |
9112 | ~__numpunct_cache(); | |
9113 | void | |
9114 | _M_cache(const locale& __loc); | |
9115 | private: | |
9116 | __numpunct_cache& | |
9117 | operator=(const __numpunct_cache&); | |
9118 | explicit | |
9119 | __numpunct_cache(const __numpunct_cache&); | |
9120 | }; | |
9121 | template<typename _CharT> | |
9122 | __numpunct_cache<_CharT>::~__numpunct_cache() | |
9123 | { | |
9124 | if (_M_allocated) | |
9125 | { | |
9126 | delete [] _M_grouping; | |
9127 | delete [] _M_truename; | |
9128 | delete [] _M_falsename; | |
9129 | } | |
9130 | } | |
9131 | template<typename _CharT> | |
9132 | class numpunct : public locale::facet | |
9133 | { | |
9134 | public: | |
9135 | typedef _CharT char_type; | |
9136 | typedef basic_string<_CharT> string_type; | |
9137 | typedef __numpunct_cache<_CharT> __cache_type; | |
9138 | protected: | |
9139 | __cache_type* _M_data; | |
9140 | public: | |
9141 | static locale::id id; | |
9142 | explicit | |
9143 | numpunct(size_t __refs = 0) : facet(__refs), _M_data(__null) | |
9144 | { _M_initialize_numpunct(); } | |
9145 | explicit | |
9146 | numpunct(__cache_type* __cache, size_t __refs = 0) | |
9147 | : facet(__refs), _M_data(__cache) | |
9148 | { _M_initialize_numpunct(); } | |
9149 | explicit | |
9150 | numpunct(__c_locale __cloc, size_t __refs = 0) | |
9151 | : facet(__refs), _M_data(__null) | |
9152 | { _M_initialize_numpunct(__cloc); } | |
9153 | char_type | |
9154 | decimal_point() const | |
9155 | { return this->do_decimal_point(); } | |
9156 | char_type | |
9157 | thousands_sep() const | |
9158 | { return this->do_thousands_sep(); } | |
9159 | string | |
9160 | grouping() const | |
9161 | { return this->do_grouping(); } | |
9162 | string_type | |
9163 | truename() const | |
9164 | { return this->do_truename(); } | |
9165 | string_type | |
9166 | falsename() const | |
9167 | { return this->do_falsename(); } | |
9168 | protected: | |
9169 | virtual | |
9170 | ~numpunct(); | |
9171 | virtual char_type | |
9172 | do_decimal_point() const | |
9173 | { return _M_data->_M_decimal_point; } | |
9174 | virtual char_type | |
9175 | do_thousands_sep() const | |
9176 | { return _M_data->_M_thousands_sep; } | |
9177 | virtual string | |
9178 | do_grouping() const | |
9179 | { return _M_data->_M_grouping; } | |
9180 | virtual string_type | |
9181 | do_truename() const | |
9182 | { return _M_data->_M_truename; } | |
9183 | virtual string_type | |
9184 | do_falsename() const | |
9185 | { return _M_data->_M_falsename; } | |
9186 | void | |
9187 | _M_initialize_numpunct(__c_locale __cloc = __null); | |
9188 | }; | |
9189 | template<typename _CharT> | |
9190 | locale::id numpunct<_CharT>::id; | |
9191 | template<> | |
9192 | numpunct<char>::~numpunct(); | |
9193 | template<> | |
9194 | void | |
9195 | numpunct<char>::_M_initialize_numpunct(__c_locale __cloc); | |
9196 | template<typename _CharT> | |
9197 | class numpunct_byname : public numpunct<_CharT> | |
9198 | { | |
9199 | public: | |
9200 | typedef _CharT char_type; | |
9201 | typedef basic_string<_CharT> string_type; | |
9202 | explicit | |
9203 | numpunct_byname(const char* __s, size_t __refs = 0) | |
9204 | : numpunct<_CharT>(__refs) | |
9205 | { | |
9206 | if (__builtin_strcmp(__s, "C") != 0 | |
9207 | && __builtin_strcmp(__s, "POSIX") != 0) | |
9208 | { | |
9209 | __c_locale __tmp; | |
9210 | this->_S_create_c_locale(__tmp, __s); | |
9211 | this->_M_initialize_numpunct(__tmp); | |
9212 | this->_S_destroy_c_locale(__tmp); | |
9213 | } | |
9214 | } | |
9215 | protected: | |
9216 | virtual | |
9217 | ~numpunct_byname() { } | |
9218 | }; | |
9219 | template<typename _CharT, typename _InIter> | |
9220 | class num_get : public locale::facet | |
9221 | { | |
9222 | public: | |
9223 | typedef _CharT char_type; | |
9224 | typedef _InIter iter_type; | |
9225 | static locale::id id; | |
9226 | explicit | |
9227 | num_get(size_t __refs = 0) : facet(__refs) { } | |
9228 | iter_type | |
9229 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9230 | ios_base::iostate& __err, bool& __v) const | |
9231 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9232 | iter_type | |
9233 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9234 | ios_base::iostate& __err, long& __v) const | |
9235 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9236 | iter_type | |
9237 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9238 | ios_base::iostate& __err, unsigned short& __v) const | |
9239 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9240 | iter_type | |
9241 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9242 | ios_base::iostate& __err, unsigned int& __v) const | |
9243 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9244 | iter_type | |
9245 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9246 | ios_base::iostate& __err, unsigned long& __v) const | |
9247 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9248 | iter_type | |
9249 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9250 | ios_base::iostate& __err, long long& __v) const | |
9251 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9252 | iter_type | |
9253 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9254 | ios_base::iostate& __err, unsigned long long& __v) const | |
9255 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9256 | iter_type | |
9257 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9258 | ios_base::iostate& __err, float& __v) const | |
9259 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9260 | iter_type | |
9261 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9262 | ios_base::iostate& __err, double& __v) const | |
9263 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9264 | iter_type | |
9265 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9266 | ios_base::iostate& __err, long double& __v) const | |
9267 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9268 | iter_type | |
9269 | get(iter_type __in, iter_type __end, ios_base& __io, | |
9270 | ios_base::iostate& __err, void*& __v) const | |
9271 | { return this->do_get(__in, __end, __io, __err, __v); } | |
9272 | protected: | |
9273 | virtual ~num_get() { } | |
9274 | iter_type | |
9275 | _M_extract_float(iter_type, iter_type, ios_base&, ios_base::iostate&, | |
9276 | string& __xtrc) const; | |
9277 | template<typename _ValueT> | |
9278 | iter_type | |
9279 | _M_extract_int(iter_type, iter_type, ios_base&, ios_base::iostate&, | |
9280 | _ValueT& __v) const; | |
9281 | template<typename _CharT2> | |
9282 | typename __gnu_cxx::__enable_if<__is_char<_CharT2>::__value, int>::__type | |
9283 | _M_find(const _CharT2*, size_t __len, _CharT2 __c) const | |
9284 | { | |
9285 | int __ret = -1; | |
9286 | if (__len <= 10) | |
9287 | { | |
9288 | if (__c >= _CharT2('0') && __c < _CharT2(_CharT2('0') + __len)) | |
9289 | __ret = __c - _CharT2('0'); | |
9290 | } | |
9291 | else | |
9292 | { | |
9293 | if (__c >= _CharT2('0') && __c <= _CharT2('9')) | |
9294 | __ret = __c - _CharT2('0'); | |
9295 | else if (__c >= _CharT2('a') && __c <= _CharT2('f')) | |
9296 | __ret = 10 + (__c - _CharT2('a')); | |
9297 | else if (__c >= _CharT2('A') && __c <= _CharT2('F')) | |
9298 | __ret = 10 + (__c - _CharT2('A')); | |
9299 | } | |
9300 | return __ret; | |
9301 | } | |
9302 | template<typename _CharT2> | |
9303 | typename __gnu_cxx::__enable_if<!__is_char<_CharT2>::__value, | |
9304 | int>::__type | |
9305 | _M_find(const _CharT2* __zero, size_t __len, _CharT2 __c) const | |
9306 | { | |
9307 | int __ret = -1; | |
9308 | const char_type* __q = char_traits<_CharT2>::find(__zero, __len, __c); | |
9309 | if (__q) | |
9310 | { | |
9311 | __ret = __q - __zero; | |
9312 | if (__ret > 15) | |
9313 | __ret -= 6; | |
9314 | } | |
9315 | return __ret; | |
9316 | } | |
9317 | virtual iter_type | |
9318 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, bool&) const; | |
9319 | virtual iter_type | |
9320 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate&, long&) const; | |
9321 | virtual iter_type | |
9322 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9323 | unsigned short&) const; | |
9324 | virtual iter_type | |
9325 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9326 | unsigned int&) const; | |
9327 | virtual iter_type | |
9328 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9329 | unsigned long&) const; | |
9330 | virtual iter_type | |
9331 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9332 | long long&) const; | |
9333 | virtual iter_type | |
9334 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9335 | unsigned long long&) const; | |
9336 | virtual iter_type | |
9337 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9338 | float&) const; | |
9339 | virtual iter_type | |
9340 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9341 | double&) const; | |
9342 | virtual iter_type | |
9343 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9344 | long double&) const; | |
9345 | virtual iter_type | |
9346 | do_get(iter_type, iter_type, ios_base&, ios_base::iostate& __err, | |
9347 | void*&) const; | |
9348 | }; | |
9349 | template<typename _CharT, typename _InIter> | |
9350 | locale::id num_get<_CharT, _InIter>::id; | |
9351 | template<typename _CharT, typename _OutIter> | |
9352 | class num_put : public locale::facet | |
9353 | { | |
9354 | public: | |
9355 | typedef _CharT char_type; | |
9356 | typedef _OutIter iter_type; | |
9357 | static locale::id id; | |
9358 | explicit | |
9359 | num_put(size_t __refs = 0) : facet(__refs) { } | |
9360 | iter_type | |
9361 | put(iter_type __s, ios_base& __f, char_type __fill, bool __v) const | |
9362 | { return this->do_put(__s, __f, __fill, __v); } | |
9363 | iter_type | |
9364 | put(iter_type __s, ios_base& __f, char_type __fill, long __v) const | |
9365 | { return this->do_put(__s, __f, __fill, __v); } | |
9366 | iter_type | |
9367 | put(iter_type __s, ios_base& __f, char_type __fill, | |
9368 | unsigned long __v) const | |
9369 | { return this->do_put(__s, __f, __fill, __v); } | |
9370 | iter_type | |
9371 | put(iter_type __s, ios_base& __f, char_type __fill, long long __v) const | |
9372 | { return this->do_put(__s, __f, __fill, __v); } | |
9373 | iter_type | |
9374 | put(iter_type __s, ios_base& __f, char_type __fill, | |
9375 | unsigned long long __v) const | |
9376 | { return this->do_put(__s, __f, __fill, __v); } | |
9377 | iter_type | |
9378 | put(iter_type __s, ios_base& __f, char_type __fill, double __v) const | |
9379 | { return this->do_put(__s, __f, __fill, __v); } | |
9380 | iter_type | |
9381 | put(iter_type __s, ios_base& __f, char_type __fill, | |
9382 | long double __v) const | |
9383 | { return this->do_put(__s, __f, __fill, __v); } | |
9384 | iter_type | |
9385 | put(iter_type __s, ios_base& __f, char_type __fill, | |
9386 | const void* __v) const | |
9387 | { return this->do_put(__s, __f, __fill, __v); } | |
9388 | protected: | |
9389 | template<typename _ValueT> | |
9390 | iter_type | |
9391 | _M_insert_float(iter_type, ios_base& __io, char_type __fill, | |
9392 | char __mod, _ValueT __v) const; | |
9393 | void | |
9394 | _M_group_float(const char* __grouping, size_t __grouping_size, | |
9395 | char_type __sep, const char_type* __p, char_type* __new, | |
9396 | char_type* __cs, int& __len) const; | |
9397 | template<typename _ValueT> | |
9398 | iter_type | |
9399 | _M_insert_int(iter_type, ios_base& __io, char_type __fill, | |
9400 | _ValueT __v) const; | |
9401 | void | |
9402 | _M_group_int(const char* __grouping, size_t __grouping_size, | |
9403 | char_type __sep, ios_base& __io, char_type* __new, | |
9404 | char_type* __cs, int& __len) const; | |
9405 | void | |
9406 | _M_pad(char_type __fill, streamsize __w, ios_base& __io, | |
9407 | char_type* __new, const char_type* __cs, int& __len) const; | |
9408 | virtual | |
9409 | ~num_put() { }; | |
9410 | virtual iter_type | |
9411 | do_put(iter_type, ios_base&, char_type __fill, bool __v) const; | |
9412 | virtual iter_type | |
9413 | do_put(iter_type, ios_base&, char_type __fill, long __v) const; | |
9414 | virtual iter_type | |
9415 | do_put(iter_type, ios_base&, char_type __fill, unsigned long) const; | |
9416 | virtual iter_type | |
9417 | do_put(iter_type, ios_base&, char_type __fill, long long __v) const; | |
9418 | virtual iter_type | |
9419 | do_put(iter_type, ios_base&, char_type __fill, unsigned long long) const; | |
9420 | virtual iter_type | |
9421 | do_put(iter_type, ios_base&, char_type __fill, double __v) const; | |
9422 | virtual iter_type | |
9423 | do_put(iter_type, ios_base&, char_type __fill, long double __v) const; | |
9424 | virtual iter_type | |
9425 | do_put(iter_type, ios_base&, char_type __fill, const void* __v) const; | |
9426 | }; | |
9427 | template <typename _CharT, typename _OutIter> | |
9428 | locale::id num_put<_CharT, _OutIter>::id; | |
9429 | template<typename _CharT> | |
9430 | inline bool | |
9431 | isspace(_CharT __c, const locale& __loc) | |
9432 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::space, __c); } | |
9433 | template<typename _CharT> | |
9434 | inline bool | |
9435 | isprint(_CharT __c, const locale& __loc) | |
9436 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::print, __c); } | |
9437 | template<typename _CharT> | |
9438 | inline bool | |
9439 | iscntrl(_CharT __c, const locale& __loc) | |
9440 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::cntrl, __c); } | |
9441 | template<typename _CharT> | |
9442 | inline bool | |
9443 | isupper(_CharT __c, const locale& __loc) | |
9444 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::upper, __c); } | |
9445 | template<typename _CharT> | |
9446 | inline bool | |
9447 | islower(_CharT __c, const locale& __loc) | |
9448 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::lower, __c); } | |
9449 | template<typename _CharT> | |
9450 | inline bool | |
9451 | isalpha(_CharT __c, const locale& __loc) | |
9452 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alpha, __c); } | |
9453 | template<typename _CharT> | |
9454 | inline bool | |
9455 | isdigit(_CharT __c, const locale& __loc) | |
9456 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::digit, __c); } | |
9457 | template<typename _CharT> | |
9458 | inline bool | |
9459 | ispunct(_CharT __c, const locale& __loc) | |
9460 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::punct, __c); } | |
9461 | template<typename _CharT> | |
9462 | inline bool | |
9463 | isxdigit(_CharT __c, const locale& __loc) | |
9464 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::xdigit, __c); } | |
9465 | template<typename _CharT> | |
9466 | inline bool | |
9467 | isalnum(_CharT __c, const locale& __loc) | |
9468 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::alnum, __c); } | |
9469 | template<typename _CharT> | |
9470 | inline bool | |
9471 | isgraph(_CharT __c, const locale& __loc) | |
9472 | { return use_facet<ctype<_CharT> >(__loc).is(ctype_base::graph, __c); } | |
9473 | template<typename _CharT> | |
9474 | inline _CharT | |
9475 | toupper(_CharT __c, const locale& __loc) | |
9476 | { return use_facet<ctype<_CharT> >(__loc).toupper(__c); } | |
9477 | template<typename _CharT> | |
9478 | inline _CharT | |
9479 | tolower(_CharT __c, const locale& __loc) | |
9480 | { return use_facet<ctype<_CharT> >(__loc).tolower(__c); } | |
9481 | } | |
9482 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
9483 | template<typename _Facet> | |
9484 | struct __use_cache | |
9485 | { | |
9486 | const _Facet* | |
9487 | operator() (const locale& __loc) const; | |
9488 | }; | |
9489 | template<typename _CharT> | |
9490 | struct __use_cache<__numpunct_cache<_CharT> > | |
9491 | { | |
9492 | const __numpunct_cache<_CharT>* | |
9493 | operator() (const locale& __loc) const | |
9494 | { | |
9495 | const size_t __i = numpunct<_CharT>::id._M_id(); | |
9496 | const locale::facet** __caches = __loc._M_impl->_M_caches; | |
9497 | if (!__caches[__i]) | |
9498 | { | |
9499 | __numpunct_cache<_CharT>* __tmp = __null; | |
9500 | try | |
9501 | { | |
9502 | __tmp = new __numpunct_cache<_CharT>; | |
9503 | __tmp->_M_cache(__loc); | |
9504 | } | |
9505 | catch(...) | |
9506 | { | |
9507 | delete __tmp; | |
9508 | throw; | |
9509 | } | |
9510 | __loc._M_impl->_M_install_cache(__tmp, __i); | |
9511 | } | |
9512 | return static_cast<const __numpunct_cache<_CharT>*>(__caches[__i]); | |
9513 | } | |
9514 | }; | |
9515 | template<typename _CharT> | |
9516 | void | |
9517 | __numpunct_cache<_CharT>::_M_cache(const locale& __loc) | |
9518 | { | |
9519 | _M_allocated = true; | |
9520 | const numpunct<_CharT>& __np = use_facet<numpunct<_CharT> >(__loc); | |
9521 | _M_grouping_size = __np.grouping().size(); | |
9522 | char* __grouping = new char[_M_grouping_size]; | |
9523 | __np.grouping().copy(__grouping, _M_grouping_size); | |
9524 | _M_grouping = __grouping; | |
9525 | _M_use_grouping = (_M_grouping_size | |
9526 | && static_cast<signed char>(__np.grouping()[0]) > 0); | |
9527 | _M_truename_size = __np.truename().size(); | |
9528 | _CharT* __truename = new _CharT[_M_truename_size]; | |
9529 | __np.truename().copy(__truename, _M_truename_size); | |
9530 | _M_truename = __truename; | |
9531 | _M_falsename_size = __np.falsename().size(); | |
9532 | _CharT* __falsename = new _CharT[_M_falsename_size]; | |
9533 | __np.falsename().copy(__falsename, _M_falsename_size); | |
9534 | _M_falsename = __falsename; | |
9535 | _M_decimal_point = __np.decimal_point(); | |
9536 | _M_thousands_sep = __np.thousands_sep(); | |
9537 | const ctype<_CharT>& __ct = use_facet<ctype<_CharT> >(__loc); | |
9538 | __ct.widen(__num_base::_S_atoms_out, | |
9539 | __num_base::_S_atoms_out + __num_base::_S_oend, _M_atoms_out); | |
9540 | __ct.widen(__num_base::_S_atoms_in, | |
9541 | __num_base::_S_atoms_in + __num_base::_S_iend, _M_atoms_in); | |
9542 | } | |
9543 | bool | |
9544 | __verify_grouping(const char* __grouping, size_t __grouping_size, | |
9545 | const string& __grouping_tmp); | |
9546 | template<typename _CharT, typename _InIter> | |
9547 | _InIter | |
9548 | num_get<_CharT, _InIter>:: | |
9549 | _M_extract_float(_InIter __beg, _InIter __end, ios_base& __io, | |
9550 | ios_base::iostate& __err, string& __xtrc) const | |
9551 | { | |
9552 | typedef char_traits<_CharT> __traits_type; | |
9553 | typedef __numpunct_cache<_CharT> __cache_type; | |
9554 | __use_cache<__cache_type> __uc; | |
9555 | const locale& __loc = __io._M_getloc(); | |
9556 | const __cache_type* __lc = __uc(__loc); | |
9557 | const _CharT* __lit = __lc->_M_atoms_in; | |
9558 | char_type __c = char_type(); | |
9559 | bool __testeof = __beg == __end; | |
9560 | if (!__testeof) | |
9561 | { | |
9562 | __c = *__beg; | |
9563 | const bool __plus = __c == __lit[__num_base::_S_iplus]; | |
9564 | if ((__plus || __c == __lit[__num_base::_S_iminus]) | |
9565 | && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) | |
9566 | && !(__c == __lc->_M_decimal_point)) | |
9567 | { | |
9568 | __xtrc += __plus ? '+' : '-'; | |
9569 | if (++__beg != __end) | |
9570 | __c = *__beg; | |
9571 | else | |
9572 | __testeof = true; | |
9573 | } | |
9574 | } | |
9575 | bool __found_mantissa = false; | |
9576 | int __sep_pos = 0; | |
9577 | while (!__testeof) | |
9578 | { | |
9579 | if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) | |
9580 | || __c == __lc->_M_decimal_point) | |
9581 | break; | |
9582 | else if (__c == __lit[__num_base::_S_izero]) | |
9583 | { | |
9584 | if (!__found_mantissa) | |
9585 | { | |
9586 | __xtrc += '0'; | |
9587 | __found_mantissa = true; | |
9588 | } | |
9589 | ++__sep_pos; | |
9590 | if (++__beg != __end) | |
9591 | __c = *__beg; | |
9592 | else | |
9593 | __testeof = true; | |
9594 | } | |
9595 | else | |
9596 | break; | |
9597 | } | |
9598 | bool __found_dec = false; | |
9599 | bool __found_sci = false; | |
9600 | string __found_grouping; | |
9601 | if (__lc->_M_use_grouping) | |
9602 | __found_grouping.reserve(32); | |
9603 | const char_type* __lit_zero = __lit + __num_base::_S_izero; | |
9604 | if (!__lc->_M_allocated) | |
9605 | while (!__testeof) | |
9606 | { | |
9607 | const int __digit = _M_find(__lit_zero, 10, __c); | |
9608 | if (__digit != -1) | |
9609 | { | |
9610 | __xtrc += '0' + __digit; | |
9611 | __found_mantissa = true; | |
9612 | } | |
9613 | else if (__c == __lc->_M_decimal_point | |
9614 | && !__found_dec && !__found_sci) | |
9615 | { | |
9616 | __xtrc += '.'; | |
9617 | __found_dec = true; | |
9618 | } | |
9619 | else if ((__c == __lit[__num_base::_S_ie] | |
9620 | || __c == __lit[__num_base::_S_iE]) | |
9621 | && !__found_sci && __found_mantissa) | |
9622 | { | |
9623 | __xtrc += 'e'; | |
9624 | __found_sci = true; | |
9625 | if (++__beg != __end) | |
9626 | { | |
9627 | __c = *__beg; | |
9628 | const bool __plus = __c == __lit[__num_base::_S_iplus]; | |
9629 | if (__plus || __c == __lit[__num_base::_S_iminus]) | |
9630 | __xtrc += __plus ? '+' : '-'; | |
9631 | else | |
9632 | continue; | |
9633 | } | |
9634 | else | |
9635 | { | |
9636 | __testeof = true; | |
9637 | break; | |
9638 | } | |
9639 | } | |
9640 | else | |
9641 | break; | |
9642 | if (++__beg != __end) | |
9643 | __c = *__beg; | |
9644 | else | |
9645 | __testeof = true; | |
9646 | } | |
9647 | else | |
9648 | while (!__testeof) | |
9649 | { | |
9650 | if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) | |
9651 | { | |
9652 | if (!__found_dec && !__found_sci) | |
9653 | { | |
9654 | if (__sep_pos) | |
9655 | { | |
9656 | __found_grouping += static_cast<char>(__sep_pos); | |
9657 | __sep_pos = 0; | |
9658 | } | |
9659 | else | |
9660 | { | |
9661 | __xtrc.clear(); | |
9662 | break; | |
9663 | } | |
9664 | } | |
9665 | else | |
9666 | break; | |
9667 | } | |
9668 | else if (__c == __lc->_M_decimal_point) | |
9669 | { | |
9670 | if (!__found_dec && !__found_sci) | |
9671 | { | |
9672 | if (__found_grouping.size()) | |
9673 | __found_grouping += static_cast<char>(__sep_pos); | |
9674 | __xtrc += '.'; | |
9675 | __found_dec = true; | |
9676 | } | |
9677 | else | |
9678 | break; | |
9679 | } | |
9680 | else | |
9681 | { | |
9682 | const char_type* __q = | |
9683 | __traits_type::find(__lit_zero, 10, __c); | |
9684 | if (__q) | |
9685 | { | |
9686 | __xtrc += '0' + (__q - __lit_zero); | |
9687 | __found_mantissa = true; | |
9688 | ++__sep_pos; | |
9689 | } | |
9690 | else if ((__c == __lit[__num_base::_S_ie] | |
9691 | || __c == __lit[__num_base::_S_iE]) | |
9692 | && !__found_sci && __found_mantissa) | |
9693 | { | |
9694 | if (__found_grouping.size() && !__found_dec) | |
9695 | __found_grouping += static_cast<char>(__sep_pos); | |
9696 | __xtrc += 'e'; | |
9697 | __found_sci = true; | |
9698 | if (++__beg != __end) | |
9699 | { | |
9700 | __c = *__beg; | |
9701 | const bool __plus = __c == __lit[__num_base::_S_iplus]; | |
9702 | if ((__plus || __c == __lit[__num_base::_S_iminus]) | |
9703 | && !(__lc->_M_use_grouping | |
9704 | && __c == __lc->_M_thousands_sep) | |
9705 | && !(__c == __lc->_M_decimal_point)) | |
9706 | __xtrc += __plus ? '+' : '-'; | |
9707 | else | |
9708 | continue; | |
9709 | } | |
9710 | else | |
9711 | { | |
9712 | __testeof = true; | |
9713 | break; | |
9714 | } | |
9715 | } | |
9716 | else | |
9717 | break; | |
9718 | } | |
9719 | if (++__beg != __end) | |
9720 | __c = *__beg; | |
9721 | else | |
9722 | __testeof = true; | |
9723 | } | |
9724 | if (__found_grouping.size()) | |
9725 | { | |
9726 | if (!__found_dec && !__found_sci) | |
9727 | __found_grouping += static_cast<char>(__sep_pos); | |
9728 | if (!std::__verify_grouping(__lc->_M_grouping, | |
9729 | __lc->_M_grouping_size, | |
9730 | __found_grouping)) | |
9731 | __err |= ios_base::failbit; | |
9732 | } | |
9733 | if (__testeof) | |
9734 | __err |= ios_base::eofbit; | |
9735 | return __beg; | |
9736 | } | |
9737 | template<typename _CharT, typename _InIter> | |
9738 | template<typename _ValueT> | |
9739 | _InIter | |
9740 | num_get<_CharT, _InIter>:: | |
9741 | _M_extract_int(_InIter __beg, _InIter __end, ios_base& __io, | |
9742 | ios_base::iostate& __err, _ValueT& __v) const | |
9743 | { | |
9744 | typedef char_traits<_CharT> __traits_type; | |
9745 | using __gnu_cxx::__add_unsigned; | |
9746 | typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; | |
9747 | typedef __numpunct_cache<_CharT> __cache_type; | |
9748 | __use_cache<__cache_type> __uc; | |
9749 | const locale& __loc = __io._M_getloc(); | |
9750 | const __cache_type* __lc = __uc(__loc); | |
9751 | const _CharT* __lit = __lc->_M_atoms_in; | |
9752 | char_type __c = char_type(); | |
9753 | const ios_base::fmtflags __basefield = __io.flags() | |
9754 | & ios_base::basefield; | |
9755 | const bool __oct = __basefield == ios_base::oct; | |
9756 | int __base = __oct ? 8 : (__basefield == ios_base::hex ? 16 : 10); | |
9757 | bool __testeof = __beg == __end; | |
9758 | bool __negative = false; | |
9759 | if (!__testeof) | |
9760 | { | |
9761 | __c = *__beg; | |
9762 | if (__gnu_cxx::__numeric_traits<_ValueT>::__is_signed) | |
9763 | __negative = __c == __lit[__num_base::_S_iminus]; | |
9764 | if ((__negative || __c == __lit[__num_base::_S_iplus]) | |
9765 | && !(__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) | |
9766 | && !(__c == __lc->_M_decimal_point)) | |
9767 | { | |
9768 | if (++__beg != __end) | |
9769 | __c = *__beg; | |
9770 | else | |
9771 | __testeof = true; | |
9772 | } | |
9773 | } | |
9774 | bool __found_zero = false; | |
9775 | int __sep_pos = 0; | |
9776 | while (!__testeof) | |
9777 | { | |
9778 | if ((__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) | |
9779 | || __c == __lc->_M_decimal_point) | |
9780 | break; | |
9781 | else if (__c == __lit[__num_base::_S_izero] | |
9782 | && (!__found_zero || __base == 10)) | |
9783 | { | |
9784 | __found_zero = true; | |
9785 | ++__sep_pos; | |
9786 | if (__basefield == 0) | |
9787 | __base = 8; | |
9788 | if (__base == 8) | |
9789 | __sep_pos = 0; | |
9790 | } | |
9791 | else if (__found_zero | |
9792 | && (__c == __lit[__num_base::_S_ix] | |
9793 | || __c == __lit[__num_base::_S_iX])) | |
9794 | { | |
9795 | if (__basefield == 0) | |
9796 | __base = 16; | |
9797 | if (__base == 16) | |
9798 | { | |
9799 | __found_zero = false; | |
9800 | __sep_pos = 0; | |
9801 | } | |
9802 | else | |
9803 | break; | |
9804 | } | |
9805 | else | |
9806 | break; | |
9807 | if (++__beg != __end) | |
9808 | { | |
9809 | __c = *__beg; | |
9810 | if (!__found_zero) | |
9811 | break; | |
9812 | } | |
9813 | else | |
9814 | __testeof = true; | |
9815 | } | |
9816 | const size_t __len = (__base == 16 ? __num_base::_S_iend | |
9817 | - __num_base::_S_izero : __base); | |
9818 | string __found_grouping; | |
9819 | if (__lc->_M_use_grouping) | |
9820 | __found_grouping.reserve(32); | |
9821 | bool __testfail = false; | |
9822 | const __unsigned_type __max = __negative | |
9823 | ? -__gnu_cxx::__numeric_traits<_ValueT>::__min | |
9824 | : __gnu_cxx::__numeric_traits<_ValueT>::__max; | |
9825 | const __unsigned_type __smax = __max / __base; | |
9826 | __unsigned_type __result = 0; | |
9827 | int __digit = 0; | |
9828 | const char_type* __lit_zero = __lit + __num_base::_S_izero; | |
9829 | if (!__lc->_M_allocated) | |
9830 | while (!__testeof) | |
9831 | { | |
9832 | __digit = _M_find(__lit_zero, __len, __c); | |
9833 | if (__digit == -1) | |
9834 | break; | |
9835 | if (__result > __smax) | |
9836 | __testfail = true; | |
9837 | else | |
9838 | { | |
9839 | __result *= __base; | |
9840 | __testfail |= __result > __max - __digit; | |
9841 | __result += __digit; | |
9842 | ++__sep_pos; | |
9843 | } | |
9844 | if (++__beg != __end) | |
9845 | __c = *__beg; | |
9846 | else | |
9847 | __testeof = true; | |
9848 | } | |
9849 | else | |
9850 | while (!__testeof) | |
9851 | { | |
9852 | if (__lc->_M_use_grouping && __c == __lc->_M_thousands_sep) | |
9853 | { | |
9854 | if (__sep_pos) | |
9855 | { | |
9856 | __found_grouping += static_cast<char>(__sep_pos); | |
9857 | __sep_pos = 0; | |
9858 | } | |
9859 | else | |
9860 | { | |
9861 | __testfail = true; | |
9862 | break; | |
9863 | } | |
9864 | } | |
9865 | else if (__c == __lc->_M_decimal_point) | |
9866 | break; | |
9867 | else | |
9868 | { | |
9869 | const char_type* __q = | |
9870 | __traits_type::find(__lit_zero, __len, __c); | |
9871 | if (!__q) | |
9872 | break; | |
9873 | __digit = __q - __lit_zero; | |
9874 | if (__digit > 15) | |
9875 | __digit -= 6; | |
9876 | if (__result > __smax) | |
9877 | __testfail = true; | |
9878 | else | |
9879 | { | |
9880 | __result *= __base; | |
9881 | __testfail |= __result > __max - __digit; | |
9882 | __result += __digit; | |
9883 | ++__sep_pos; | |
9884 | } | |
9885 | } | |
9886 | if (++__beg != __end) | |
9887 | __c = *__beg; | |
9888 | else | |
9889 | __testeof = true; | |
9890 | } | |
9891 | if (__found_grouping.size()) | |
9892 | { | |
9893 | __found_grouping += static_cast<char>(__sep_pos); | |
9894 | if (!std::__verify_grouping(__lc->_M_grouping, | |
9895 | __lc->_M_grouping_size, | |
9896 | __found_grouping)) | |
9897 | __err |= ios_base::failbit; | |
9898 | } | |
9899 | if (!__testfail && (__sep_pos || __found_zero | |
9900 | || __found_grouping.size())) | |
9901 | __v = __negative ? -__result : __result; | |
9902 | else | |
9903 | __err |= ios_base::failbit; | |
9904 | if (__testeof) | |
9905 | __err |= ios_base::eofbit; | |
9906 | return __beg; | |
9907 | } | |
9908 | template<typename _CharT, typename _InIter> | |
9909 | _InIter | |
9910 | num_get<_CharT, _InIter>:: | |
9911 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
9912 | ios_base::iostate& __err, bool& __v) const | |
9913 | { | |
9914 | if (!(__io.flags() & ios_base::boolalpha)) | |
9915 | { | |
9916 | long __l = -1; | |
9917 | __beg = _M_extract_int(__beg, __end, __io, __err, __l); | |
9918 | if (__l == 0 || __l == 1) | |
9919 | __v = bool(__l); | |
9920 | else | |
9921 | __err |= ios_base::failbit; | |
9922 | } | |
9923 | else | |
9924 | { | |
9925 | typedef __numpunct_cache<_CharT> __cache_type; | |
9926 | __use_cache<__cache_type> __uc; | |
9927 | const locale& __loc = __io._M_getloc(); | |
9928 | const __cache_type* __lc = __uc(__loc); | |
9929 | bool __testf = true; | |
9930 | bool __testt = true; | |
9931 | size_t __n; | |
9932 | bool __testeof = __beg == __end; | |
9933 | for (__n = 0; !__testeof; ++__n) | |
9934 | { | |
9935 | const char_type __c = *__beg; | |
9936 | if (__testf) | |
9937 | { | |
9938 | if (__n < __lc->_M_falsename_size) | |
9939 | __testf = __c == __lc->_M_falsename[__n]; | |
9940 | else | |
9941 | break; | |
9942 | } | |
9943 | if (__testt) | |
9944 | { | |
9945 | if (__n < __lc->_M_truename_size) | |
9946 | __testt = __c == __lc->_M_truename[__n]; | |
9947 | else | |
9948 | break; | |
9949 | } | |
9950 | if (!__testf && !__testt) | |
9951 | break; | |
9952 | if (++__beg == __end) | |
9953 | __testeof = true; | |
9954 | } | |
9955 | if (__testf && __n == __lc->_M_falsename_size) | |
9956 | __v = false; | |
9957 | else if (__testt && __n == __lc->_M_truename_size) | |
9958 | __v = true; | |
9959 | else | |
9960 | __err |= ios_base::failbit; | |
9961 | if (__testeof) | |
9962 | __err |= ios_base::eofbit; | |
9963 | } | |
9964 | return __beg; | |
9965 | } | |
9966 | template<typename _CharT, typename _InIter> | |
9967 | _InIter | |
9968 | num_get<_CharT, _InIter>:: | |
9969 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
9970 | ios_base::iostate& __err, long& __v) const | |
9971 | { return _M_extract_int(__beg, __end, __io, __err, __v); } | |
9972 | template<typename _CharT, typename _InIter> | |
9973 | _InIter | |
9974 | num_get<_CharT, _InIter>:: | |
9975 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
9976 | ios_base::iostate& __err, unsigned short& __v) const | |
9977 | { return _M_extract_int(__beg, __end, __io, __err, __v); } | |
9978 | template<typename _CharT, typename _InIter> | |
9979 | _InIter | |
9980 | num_get<_CharT, _InIter>:: | |
9981 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
9982 | ios_base::iostate& __err, unsigned int& __v) const | |
9983 | { return _M_extract_int(__beg, __end, __io, __err, __v); } | |
9984 | template<typename _CharT, typename _InIter> | |
9985 | _InIter | |
9986 | num_get<_CharT, _InIter>:: | |
9987 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
9988 | ios_base::iostate& __err, unsigned long& __v) const | |
9989 | { return _M_extract_int(__beg, __end, __io, __err, __v); } | |
9990 | template<typename _CharT, typename _InIter> | |
9991 | _InIter | |
9992 | num_get<_CharT, _InIter>:: | |
9993 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
9994 | ios_base::iostate& __err, long long& __v) const | |
9995 | { return _M_extract_int(__beg, __end, __io, __err, __v); } | |
9996 | template<typename _CharT, typename _InIter> | |
9997 | _InIter | |
9998 | num_get<_CharT, _InIter>:: | |
9999 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
10000 | ios_base::iostate& __err, unsigned long long& __v) const | |
10001 | { return _M_extract_int(__beg, __end, __io, __err, __v); } | |
10002 | template<typename _CharT, typename _InIter> | |
10003 | _InIter | |
10004 | num_get<_CharT, _InIter>:: | |
10005 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
10006 | ios_base::iostate& __err, float& __v) const | |
10007 | { | |
10008 | string __xtrc; | |
10009 | __xtrc.reserve(32); | |
10010 | __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); | |
10011 | std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); | |
10012 | return __beg; | |
10013 | } | |
10014 | template<typename _CharT, typename _InIter> | |
10015 | _InIter | |
10016 | num_get<_CharT, _InIter>:: | |
10017 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
10018 | ios_base::iostate& __err, double& __v) const | |
10019 | { | |
10020 | string __xtrc; | |
10021 | __xtrc.reserve(32); | |
10022 | __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); | |
10023 | std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); | |
10024 | return __beg; | |
10025 | } | |
10026 | template<typename _CharT, typename _InIter> | |
10027 | _InIter | |
10028 | num_get<_CharT, _InIter>:: | |
10029 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
10030 | ios_base::iostate& __err, long double& __v) const | |
10031 | { | |
10032 | string __xtrc; | |
10033 | __xtrc.reserve(32); | |
10034 | __beg = _M_extract_float(__beg, __end, __io, __err, __xtrc); | |
10035 | std::__convert_to_v(__xtrc.c_str(), __v, __err, _S_get_c_locale()); | |
10036 | return __beg; | |
10037 | } | |
10038 | template<typename _CharT, typename _InIter> | |
10039 | _InIter | |
10040 | num_get<_CharT, _InIter>:: | |
10041 | do_get(iter_type __beg, iter_type __end, ios_base& __io, | |
10042 | ios_base::iostate& __err, void*& __v) const | |
10043 | { | |
10044 | typedef ios_base::fmtflags fmtflags; | |
10045 | const fmtflags __fmt = __io.flags(); | |
10046 | __io.flags((__fmt & ~ios_base::basefield) | ios_base::hex); | |
10047 | typedef __gnu_cxx::__conditional_type<(sizeof(void*) | |
10048 | <= sizeof(unsigned long)), | |
10049 | unsigned long, unsigned long long>::__type _UIntPtrType; | |
10050 | _UIntPtrType __ul; | |
10051 | __beg = _M_extract_int(__beg, __end, __io, __err, __ul); | |
10052 | __io.flags(__fmt); | |
10053 | if (!(__err & ios_base::failbit)) | |
10054 | __v = reinterpret_cast<void*>(__ul); | |
10055 | return __beg; | |
10056 | } | |
10057 | template<typename _CharT, typename _OutIter> | |
10058 | void | |
10059 | num_put<_CharT, _OutIter>:: | |
10060 | _M_pad(_CharT __fill, streamsize __w, ios_base& __io, | |
10061 | _CharT* __new, const _CharT* __cs, int& __len) const | |
10062 | { | |
10063 | __pad<_CharT, char_traits<_CharT> >::_S_pad(__io, __fill, __new, | |
10064 | __cs, __w, __len); | |
10065 | __len = static_cast<int>(__w); | |
10066 | } | |
10067 | template<typename _CharT, typename _ValueT> | |
10068 | int | |
10069 | __int_to_char(_CharT* __bufend, _ValueT __v, const _CharT* __lit, | |
10070 | ios_base::fmtflags __flags, bool __dec) | |
10071 | { | |
10072 | _CharT* __buf = __bufend; | |
10073 | if (__builtin_expect(__dec, true)) | |
10074 | { | |
10075 | do | |
10076 | { | |
10077 | *--__buf = __lit[(__v % 10) + __num_base::_S_odigits]; | |
10078 | __v /= 10; | |
10079 | } | |
10080 | while (__v != 0); | |
10081 | } | |
10082 | else if ((__flags & ios_base::basefield) == ios_base::oct) | |
10083 | { | |
10084 | do | |
10085 | { | |
10086 | *--__buf = __lit[(__v & 0x7) + __num_base::_S_odigits]; | |
10087 | __v >>= 3; | |
10088 | } | |
10089 | while (__v != 0); | |
10090 | } | |
10091 | else | |
10092 | { | |
10093 | const bool __uppercase = __flags & ios_base::uppercase; | |
10094 | const int __case_offset = __uppercase ? __num_base::_S_oudigits | |
10095 | : __num_base::_S_odigits; | |
10096 | do | |
10097 | { | |
10098 | *--__buf = __lit[(__v & 0xf) + __case_offset]; | |
10099 | __v >>= 4; | |
10100 | } | |
10101 | while (__v != 0); | |
10102 | } | |
10103 | return __bufend - __buf; | |
10104 | } | |
10105 | template<typename _CharT, typename _OutIter> | |
10106 | void | |
10107 | num_put<_CharT, _OutIter>:: | |
10108 | _M_group_int(const char* __grouping, size_t __grouping_size, _CharT __sep, | |
10109 | ios_base&, _CharT* __new, _CharT* __cs, int& __len) const | |
10110 | { | |
10111 | _CharT* __p = std::__add_grouping(__new, __sep, __grouping, | |
10112 | __grouping_size, __cs, __cs + __len); | |
10113 | __len = __p - __new; | |
10114 | } | |
10115 | template<typename _CharT, typename _OutIter> | |
10116 | template<typename _ValueT> | |
10117 | _OutIter | |
10118 | num_put<_CharT, _OutIter>:: | |
10119 | _M_insert_int(_OutIter __s, ios_base& __io, _CharT __fill, | |
10120 | _ValueT __v) const | |
10121 | { | |
10122 | using __gnu_cxx::__add_unsigned; | |
10123 | typedef typename __add_unsigned<_ValueT>::__type __unsigned_type; | |
10124 | typedef __numpunct_cache<_CharT> __cache_type; | |
10125 | __use_cache<__cache_type> __uc; | |
10126 | const locale& __loc = __io._M_getloc(); | |
10127 | const __cache_type* __lc = __uc(__loc); | |
10128 | const _CharT* __lit = __lc->_M_atoms_out; | |
10129 | const ios_base::fmtflags __flags = __io.flags(); | |
10130 | const int __ilen = 5 * sizeof(_ValueT); | |
10131 | _CharT* __cs = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10132 | * __ilen)); | |
10133 | const ios_base::fmtflags __basefield = __flags & ios_base::basefield; | |
10134 | const bool __dec = (__basefield != ios_base::oct | |
10135 | && __basefield != ios_base::hex); | |
10136 | const __unsigned_type __u = ((__v > 0 || !__dec) | |
10137 | ? __unsigned_type(__v) | |
10138 | : -__unsigned_type(__v)); | |
10139 | int __len = __int_to_char(__cs + __ilen, __u, __lit, __flags, __dec); | |
10140 | __cs += __ilen - __len; | |
10141 | if (__lc->_M_use_grouping) | |
10142 | { | |
10143 | _CharT* __cs2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10144 | * (__len + 1) | |
10145 | * 2)); | |
10146 | _M_group_int(__lc->_M_grouping, __lc->_M_grouping_size, | |
10147 | __lc->_M_thousands_sep, __io, __cs2 + 2, __cs, __len); | |
10148 | __cs = __cs2 + 2; | |
10149 | } | |
10150 | if (__builtin_expect(__dec, true)) | |
10151 | { | |
10152 | if (__v >= 0) | |
10153 | { | |
10154 | if (bool(__flags & ios_base::showpos) | |
10155 | && __gnu_cxx::__numeric_traits<_ValueT>::__is_signed) | |
10156 | *--__cs = __lit[__num_base::_S_oplus], ++__len; | |
10157 | } | |
10158 | else | |
10159 | *--__cs = __lit[__num_base::_S_ominus], ++__len; | |
10160 | } | |
10161 | else if (bool(__flags & ios_base::showbase) && __v) | |
10162 | { | |
10163 | if (__basefield == ios_base::oct) | |
10164 | *--__cs = __lit[__num_base::_S_odigits], ++__len; | |
10165 | else | |
10166 | { | |
10167 | const bool __uppercase = __flags & ios_base::uppercase; | |
10168 | *--__cs = __lit[__num_base::_S_ox + __uppercase]; | |
10169 | *--__cs = __lit[__num_base::_S_odigits]; | |
10170 | __len += 2; | |
10171 | } | |
10172 | } | |
10173 | const streamsize __w = __io.width(); | |
10174 | if (__w > static_cast<streamsize>(__len)) | |
10175 | { | |
10176 | _CharT* __cs3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10177 | * __w)); | |
10178 | _M_pad(__fill, __w, __io, __cs3, __cs, __len); | |
10179 | __cs = __cs3; | |
10180 | } | |
10181 | __io.width(0); | |
10182 | return std::__write(__s, __cs, __len); | |
10183 | } | |
10184 | template<typename _CharT, typename _OutIter> | |
10185 | void | |
10186 | num_put<_CharT, _OutIter>:: | |
10187 | _M_group_float(const char* __grouping, size_t __grouping_size, | |
10188 | _CharT __sep, const _CharT* __p, _CharT* __new, | |
10189 | _CharT* __cs, int& __len) const | |
10190 | { | |
10191 | const int __declen = __p ? __p - __cs : __len; | |
10192 | _CharT* __p2 = std::__add_grouping(__new, __sep, __grouping, | |
10193 | __grouping_size, | |
10194 | __cs, __cs + __declen); | |
10195 | int __newlen = __p2 - __new; | |
10196 | if (__p) | |
10197 | { | |
10198 | char_traits<_CharT>::copy(__p2, __p, __len - __declen); | |
10199 | __newlen += __len - __declen; | |
10200 | } | |
10201 | __len = __newlen; | |
10202 | } | |
10203 | template<typename _CharT, typename _OutIter> | |
10204 | template<typename _ValueT> | |
10205 | _OutIter | |
10206 | num_put<_CharT, _OutIter>:: | |
10207 | _M_insert_float(_OutIter __s, ios_base& __io, _CharT __fill, char __mod, | |
10208 | _ValueT __v) const | |
10209 | { | |
10210 | typedef __numpunct_cache<_CharT> __cache_type; | |
10211 | __use_cache<__cache_type> __uc; | |
10212 | const locale& __loc = __io._M_getloc(); | |
10213 | const __cache_type* __lc = __uc(__loc); | |
10214 | const streamsize __prec = __io.precision() < 0 ? 6 : __io.precision(); | |
10215 | const int __max_digits = | |
10216 | __gnu_cxx::__numeric_traits<_ValueT>::__digits10; | |
10217 | int __len; | |
10218 | char __fbuf[16]; | |
10219 | __num_base::_S_format_float(__io, __fbuf, __mod); | |
10220 | const bool __fixed = __io.flags() & ios_base::fixed; | |
10221 | const int __max_exp = | |
10222 | __gnu_cxx::__numeric_traits<_ValueT>::__max_exponent10; | |
10223 | const int __cs_size = __fixed ? __max_exp + __prec + 4 | |
10224 | : __max_digits * 2 + __prec; | |
10225 | char* __cs = static_cast<char*>(__builtin_alloca(__cs_size)); | |
10226 | __len = std::__convert_from_v(_S_get_c_locale(), __cs, 0, __fbuf, | |
10227 | __prec, __v); | |
10228 | const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); | |
10229 | _CharT* __ws = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10230 | * __len)); | |
10231 | __ctype.widen(__cs, __cs + __len, __ws); | |
10232 | _CharT* __wp = 0; | |
10233 | const char* __p = char_traits<char>::find(__cs, __len, '.'); | |
10234 | if (__p) | |
10235 | { | |
10236 | __wp = __ws + (__p - __cs); | |
10237 | *__wp = __lc->_M_decimal_point; | |
10238 | } | |
10239 | if (__lc->_M_use_grouping | |
10240 | && (__wp || __len < 3 || (__cs[1] <= '9' && __cs[2] <= '9' | |
10241 | && __cs[1] >= '0' && __cs[2] >= '0'))) | |
10242 | { | |
10243 | _CharT* __ws2 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10244 | * __len * 2)); | |
10245 | streamsize __off = 0; | |
10246 | if (__cs[0] == '-' || __cs[0] == '+') | |
10247 | { | |
10248 | __off = 1; | |
10249 | __ws2[0] = __ws[0]; | |
10250 | __len -= 1; | |
10251 | } | |
10252 | _M_group_float(__lc->_M_grouping, __lc->_M_grouping_size, | |
10253 | __lc->_M_thousands_sep, __wp, __ws2 + __off, | |
10254 | __ws + __off, __len); | |
10255 | __len += __off; | |
10256 | __ws = __ws2; | |
10257 | } | |
10258 | const streamsize __w = __io.width(); | |
10259 | if (__w > static_cast<streamsize>(__len)) | |
10260 | { | |
10261 | _CharT* __ws3 = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10262 | * __w)); | |
10263 | _M_pad(__fill, __w, __io, __ws3, __ws, __len); | |
10264 | __ws = __ws3; | |
10265 | } | |
10266 | __io.width(0); | |
10267 | return std::__write(__s, __ws, __len); | |
10268 | } | |
10269 | template<typename _CharT, typename _OutIter> | |
10270 | _OutIter | |
10271 | num_put<_CharT, _OutIter>:: | |
10272 | do_put(iter_type __s, ios_base& __io, char_type __fill, bool __v) const | |
10273 | { | |
10274 | const ios_base::fmtflags __flags = __io.flags(); | |
10275 | if ((__flags & ios_base::boolalpha) == 0) | |
10276 | { | |
10277 | const long __l = __v; | |
10278 | __s = _M_insert_int(__s, __io, __fill, __l); | |
10279 | } | |
10280 | else | |
10281 | { | |
10282 | typedef __numpunct_cache<_CharT> __cache_type; | |
10283 | __use_cache<__cache_type> __uc; | |
10284 | const locale& __loc = __io._M_getloc(); | |
10285 | const __cache_type* __lc = __uc(__loc); | |
10286 | const _CharT* __name = __v ? __lc->_M_truename | |
10287 | : __lc->_M_falsename; | |
10288 | int __len = __v ? __lc->_M_truename_size | |
10289 | : __lc->_M_falsename_size; | |
10290 | const streamsize __w = __io.width(); | |
10291 | if (__w > static_cast<streamsize>(__len)) | |
10292 | { | |
10293 | _CharT* __cs | |
10294 | = static_cast<_CharT*>(__builtin_alloca(sizeof(_CharT) | |
10295 | * __w)); | |
10296 | _M_pad(__fill, __w, __io, __cs, __name, __len); | |
10297 | __name = __cs; | |
10298 | } | |
10299 | __io.width(0); | |
10300 | __s = std::__write(__s, __name, __len); | |
10301 | } | |
10302 | return __s; | |
10303 | } | |
10304 | template<typename _CharT, typename _OutIter> | |
10305 | _OutIter | |
10306 | num_put<_CharT, _OutIter>:: | |
10307 | do_put(iter_type __s, ios_base& __io, char_type __fill, long __v) const | |
10308 | { return _M_insert_int(__s, __io, __fill, __v); } | |
10309 | template<typename _CharT, typename _OutIter> | |
10310 | _OutIter | |
10311 | num_put<_CharT, _OutIter>:: | |
10312 | do_put(iter_type __s, ios_base& __io, char_type __fill, | |
10313 | unsigned long __v) const | |
10314 | { return _M_insert_int(__s, __io, __fill, __v); } | |
10315 | template<typename _CharT, typename _OutIter> | |
10316 | _OutIter | |
10317 | num_put<_CharT, _OutIter>:: | |
10318 | do_put(iter_type __s, ios_base& __io, char_type __fill, long long __v) const | |
10319 | { return _M_insert_int(__s, __io, __fill, __v); } | |
10320 | template<typename _CharT, typename _OutIter> | |
10321 | _OutIter | |
10322 | num_put<_CharT, _OutIter>:: | |
10323 | do_put(iter_type __s, ios_base& __io, char_type __fill, | |
10324 | unsigned long long __v) const | |
10325 | { return _M_insert_int(__s, __io, __fill, __v); } | |
10326 | template<typename _CharT, typename _OutIter> | |
10327 | _OutIter | |
10328 | num_put<_CharT, _OutIter>:: | |
10329 | do_put(iter_type __s, ios_base& __io, char_type __fill, double __v) const | |
10330 | { return _M_insert_float(__s, __io, __fill, char(), __v); } | |
10331 | template<typename _CharT, typename _OutIter> | |
10332 | _OutIter | |
10333 | num_put<_CharT, _OutIter>:: | |
10334 | do_put(iter_type __s, ios_base& __io, char_type __fill, | |
10335 | long double __v) const | |
10336 | { return _M_insert_float(__s, __io, __fill, 'L', __v); } | |
10337 | template<typename _CharT, typename _OutIter> | |
10338 | _OutIter | |
10339 | num_put<_CharT, _OutIter>:: | |
10340 | do_put(iter_type __s, ios_base& __io, char_type __fill, | |
10341 | const void* __v) const | |
10342 | { | |
10343 | const ios_base::fmtflags __flags = __io.flags(); | |
10344 | const ios_base::fmtflags __fmt = ~(ios_base::basefield | |
10345 | | ios_base::uppercase | |
10346 | | ios_base::internal); | |
10347 | __io.flags((__flags & __fmt) | (ios_base::hex | ios_base::showbase)); | |
10348 | typedef __gnu_cxx::__conditional_type<(sizeof(const void*) | |
10349 | <= sizeof(unsigned long)), | |
10350 | unsigned long, unsigned long long>::__type _UIntPtrType; | |
10351 | __s = _M_insert_int(__s, __io, __fill, | |
10352 | reinterpret_cast<_UIntPtrType>(__v)); | |
10353 | __io.flags(__flags); | |
10354 | return __s; | |
10355 | } | |
10356 | template<typename _CharT, typename _Traits> | |
10357 | void | |
10358 | __pad<_CharT, _Traits>::_S_pad(ios_base& __io, _CharT __fill, | |
10359 | _CharT* __news, const _CharT* __olds, | |
10360 | const streamsize __newlen, | |
10361 | const streamsize __oldlen) | |
10362 | { | |
10363 | const size_t __plen = static_cast<size_t>(__newlen - __oldlen); | |
10364 | const ios_base::fmtflags __adjust = __io.flags() & ios_base::adjustfield; | |
10365 | if (__adjust == ios_base::left) | |
10366 | { | |
10367 | _Traits::copy(__news, __olds, __oldlen); | |
10368 | _Traits::assign(__news + __oldlen, __plen, __fill); | |
10369 | return; | |
10370 | } | |
10371 | size_t __mod = 0; | |
10372 | if (__adjust == ios_base::internal) | |
10373 | { | |
10374 | const locale& __loc = __io._M_getloc(); | |
10375 | const ctype<_CharT>& __ctype = use_facet<ctype<_CharT> >(__loc); | |
10376 | if (__ctype.widen('-') == __olds[0] | |
10377 | || __ctype.widen('+') == __olds[0]) | |
10378 | { | |
10379 | __news[0] = __olds[0]; | |
10380 | __mod = 1; | |
10381 | ++__news; | |
10382 | } | |
10383 | else if (__ctype.widen('0') == __olds[0] | |
10384 | && __oldlen > 1 | |
10385 | && (__ctype.widen('x') == __olds[1] | |
10386 | || __ctype.widen('X') == __olds[1])) | |
10387 | { | |
10388 | __news[0] = __olds[0]; | |
10389 | __news[1] = __olds[1]; | |
10390 | __mod = 2; | |
10391 | __news += 2; | |
10392 | } | |
10393 | } | |
10394 | _Traits::assign(__news, __plen, __fill); | |
10395 | _Traits::copy(__news + __plen, __olds + __mod, __oldlen - __mod); | |
10396 | } | |
10397 | template<typename _CharT> | |
10398 | _CharT* | |
10399 | __add_grouping(_CharT* __s, _CharT __sep, | |
10400 | const char* __gbeg, size_t __gsize, | |
10401 | const _CharT* __first, const _CharT* __last) | |
10402 | { | |
10403 | size_t __idx = 0; | |
10404 | size_t __ctr = 0; | |
10405 | while (__last - __first > __gbeg[__idx] | |
10406 | && static_cast<signed char>(__gbeg[__idx]) > 0) | |
10407 | { | |
10408 | __last -= __gbeg[__idx]; | |
10409 | __idx < __gsize - 1 ? ++__idx : ++__ctr; | |
10410 | } | |
10411 | while (__first != __last) | |
10412 | *__s++ = *__first++; | |
10413 | while (__ctr--) | |
10414 | { | |
10415 | *__s++ = __sep; | |
10416 | for (char __i = __gbeg[__idx]; __i > 0; --__i) | |
10417 | *__s++ = *__first++; | |
10418 | } | |
10419 | while (__idx--) | |
10420 | { | |
10421 | *__s++ = __sep; | |
10422 | for (char __i = __gbeg[__idx]; __i > 0; --__i) | |
10423 | *__s++ = *__first++; | |
10424 | } | |
10425 | return __s; | |
10426 | } | |
10427 | extern template class numpunct<char>; | |
10428 | extern template class numpunct_byname<char>; | |
10429 | extern template class num_get<char>; | |
10430 | extern template class num_put<char>; | |
10431 | extern template class ctype_byname<char>; | |
10432 | extern template | |
10433 | const numpunct<char>& | |
10434 | use_facet<numpunct<char> >(const locale&); | |
10435 | extern template | |
10436 | const num_put<char>& | |
10437 | use_facet<num_put<char> >(const locale&); | |
10438 | extern template | |
10439 | const num_get<char>& | |
10440 | use_facet<num_get<char> >(const locale&); | |
10441 | extern template | |
10442 | bool | |
10443 | has_facet<ctype<char> >(const locale&); | |
10444 | extern template | |
10445 | bool | |
10446 | has_facet<numpunct<char> >(const locale&); | |
10447 | extern template | |
10448 | bool | |
10449 | has_facet<num_put<char> >(const locale&); | |
10450 | extern template | |
10451 | bool | |
10452 | has_facet<num_get<char> >(const locale&); | |
10453 | } | |
10454 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
10455 | template<typename _Facet> | |
10456 | inline const _Facet& | |
10457 | __check_facet(const _Facet* __f) | |
10458 | { | |
10459 | if (!__f) | |
10460 | __throw_bad_cast(); | |
10461 | return *__f; | |
10462 | } | |
10463 | template<typename _CharT, typename _Traits> | |
10464 | class basic_ios : public ios_base | |
10465 | { | |
10466 | public: | |
10467 | typedef _CharT char_type; | |
10468 | typedef typename _Traits::int_type int_type; | |
10469 | typedef typename _Traits::pos_type pos_type; | |
10470 | typedef typename _Traits::off_type off_type; | |
10471 | typedef _Traits traits_type; | |
10472 | typedef ctype<_CharT> __ctype_type; | |
10473 | typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > | |
10474 | __num_put_type; | |
10475 | typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > | |
10476 | __num_get_type; | |
10477 | protected: | |
10478 | basic_ostream<_CharT, _Traits>* _M_tie; | |
10479 | mutable char_type _M_fill; | |
10480 | mutable bool _M_fill_init; | |
10481 | basic_streambuf<_CharT, _Traits>* _M_streambuf; | |
10482 | const __ctype_type* _M_ctype; | |
10483 | const __num_put_type* _M_num_put; | |
10484 | const __num_get_type* _M_num_get; | |
10485 | public: | |
10486 | operator void*() const | |
10487 | { return this->fail() ? 0 : const_cast<basic_ios*>(this); } | |
10488 | bool | |
10489 | operator!() const | |
10490 | { return this->fail(); } | |
10491 | iostate | |
10492 | rdstate() const | |
10493 | { return _M_streambuf_state; } | |
10494 | void | |
10495 | clear(iostate __state = goodbit); | |
10496 | void | |
10497 | setstate(iostate __state) | |
10498 | { this->clear(this->rdstate() | __state); } | |
10499 | void | |
10500 | _M_setstate(iostate __state) | |
10501 | { | |
10502 | _M_streambuf_state |= __state; | |
10503 | if (this->exceptions() & __state) | |
10504 | throw; | |
10505 | } | |
10506 | bool | |
10507 | good() const | |
10508 | { return this->rdstate() == 0; } | |
10509 | bool | |
10510 | eof() const | |
10511 | { return (this->rdstate() & eofbit) != 0; } | |
10512 | bool | |
10513 | fail() const | |
10514 | { return (this->rdstate() & (badbit | failbit)) != 0; } | |
10515 | bool | |
10516 | bad() const | |
10517 | { return (this->rdstate() & badbit) != 0; } | |
10518 | iostate | |
10519 | exceptions() const | |
10520 | { return _M_exception; } | |
10521 | void | |
10522 | exceptions(iostate __except) | |
10523 | { | |
10524 | _M_exception = __except; | |
10525 | this->clear(_M_streambuf_state); | |
10526 | } | |
10527 | explicit | |
10528 | basic_ios(basic_streambuf<_CharT, _Traits>* __sb) | |
10529 | : ios_base(), _M_tie(0), _M_fill(), _M_fill_init(false), _M_streambuf(0), | |
10530 | _M_ctype(0), _M_num_put(0), _M_num_get(0) | |
10531 | { this->init(__sb); } | |
10532 | virtual | |
10533 | ~basic_ios() { } | |
10534 | basic_ostream<_CharT, _Traits>* | |
10535 | tie() const | |
10536 | { return _M_tie; } | |
10537 | basic_ostream<_CharT, _Traits>* | |
10538 | tie(basic_ostream<_CharT, _Traits>* __tiestr) | |
10539 | { | |
10540 | basic_ostream<_CharT, _Traits>* __old = _M_tie; | |
10541 | _M_tie = __tiestr; | |
10542 | return __old; | |
10543 | } | |
10544 | basic_streambuf<_CharT, _Traits>* | |
10545 | rdbuf() const | |
10546 | { return _M_streambuf; } | |
10547 | basic_streambuf<_CharT, _Traits>* | |
10548 | rdbuf(basic_streambuf<_CharT, _Traits>* __sb); | |
10549 | basic_ios& | |
10550 | copyfmt(const basic_ios& __rhs); | |
10551 | char_type | |
10552 | fill() const | |
10553 | { | |
10554 | if (!_M_fill_init) | |
10555 | { | |
10556 | _M_fill = this->widen(' '); | |
10557 | _M_fill_init = true; | |
10558 | } | |
10559 | return _M_fill; | |
10560 | } | |
10561 | char_type | |
10562 | fill(char_type __ch) | |
10563 | { | |
10564 | char_type __old = this->fill(); | |
10565 | _M_fill = __ch; | |
10566 | return __old; | |
10567 | } | |
10568 | locale | |
10569 | imbue(const locale& __loc); | |
10570 | char | |
10571 | narrow(char_type __c, char __dfault) const | |
10572 | { return __check_facet(_M_ctype).narrow(__c, __dfault); } | |
10573 | char_type | |
10574 | widen(char __c) const | |
10575 | { return __check_facet(_M_ctype).widen(__c); } | |
10576 | protected: | |
10577 | basic_ios() | |
10578 | : ios_base(), _M_tie(0), _M_fill(char_type()), _M_fill_init(false), | |
10579 | _M_streambuf(0), _M_ctype(0), _M_num_put(0), _M_num_get(0) | |
10580 | { } | |
10581 | void | |
10582 | init(basic_streambuf<_CharT, _Traits>* __sb); | |
10583 | void | |
10584 | _M_cache_locale(const locale& __loc); | |
10585 | }; | |
10586 | } | |
10587 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
10588 | template<typename _CharT, typename _Traits> | |
10589 | void | |
10590 | basic_ios<_CharT, _Traits>::clear(iostate __state) | |
10591 | { | |
10592 | if (this->rdbuf()) | |
10593 | _M_streambuf_state = __state; | |
10594 | else | |
10595 | _M_streambuf_state = __state | badbit; | |
10596 | if (this->exceptions() & this->rdstate()) | |
10597 | __throw_ios_failure(("basic_ios::clear")); | |
10598 | } | |
10599 | template<typename _CharT, typename _Traits> | |
10600 | basic_streambuf<_CharT, _Traits>* | |
10601 | basic_ios<_CharT, _Traits>::rdbuf(basic_streambuf<_CharT, _Traits>* __sb) | |
10602 | { | |
10603 | basic_streambuf<_CharT, _Traits>* __old = _M_streambuf; | |
10604 | _M_streambuf = __sb; | |
10605 | this->clear(); | |
10606 | return __old; | |
10607 | } | |
10608 | template<typename _CharT, typename _Traits> | |
10609 | basic_ios<_CharT, _Traits>& | |
10610 | basic_ios<_CharT, _Traits>::copyfmt(const basic_ios& __rhs) | |
10611 | { | |
10612 | if (this != &__rhs) | |
10613 | { | |
10614 | _Words* __words = (__rhs._M_word_size <= _S_local_word_size) ? | |
10615 | _M_local_word : new _Words[__rhs._M_word_size]; | |
10616 | _Callback_list* __cb = __rhs._M_callbacks; | |
10617 | if (__cb) | |
10618 | __cb->_M_add_reference(); | |
10619 | _M_call_callbacks(erase_event); | |
10620 | if (_M_word != _M_local_word) | |
10621 | { | |
10622 | delete [] _M_word; | |
10623 | _M_word = 0; | |
10624 | } | |
10625 | _M_dispose_callbacks(); | |
10626 | _M_callbacks = __cb; | |
10627 | for (int __i = 0; __i < __rhs._M_word_size; ++__i) | |
10628 | __words[__i] = __rhs._M_word[__i]; | |
10629 | _M_word = __words; | |
10630 | _M_word_size = __rhs._M_word_size; | |
10631 | this->flags(__rhs.flags()); | |
10632 | this->width(__rhs.width()); | |
10633 | this->precision(__rhs.precision()); | |
10634 | this->tie(__rhs.tie()); | |
10635 | this->fill(__rhs.fill()); | |
10636 | _M_ios_locale = __rhs.getloc(); | |
10637 | _M_cache_locale(_M_ios_locale); | |
10638 | _M_call_callbacks(copyfmt_event); | |
10639 | this->exceptions(__rhs.exceptions()); | |
10640 | } | |
10641 | return *this; | |
10642 | } | |
10643 | template<typename _CharT, typename _Traits> | |
10644 | locale | |
10645 | basic_ios<_CharT, _Traits>::imbue(const locale& __loc) | |
10646 | { | |
10647 | locale __old(this->getloc()); | |
10648 | ios_base::imbue(__loc); | |
10649 | _M_cache_locale(__loc); | |
10650 | if (this->rdbuf() != 0) | |
10651 | this->rdbuf()->pubimbue(__loc); | |
10652 | return __old; | |
10653 | } | |
10654 | template<typename _CharT, typename _Traits> | |
10655 | void | |
10656 | basic_ios<_CharT, _Traits>::init(basic_streambuf<_CharT, _Traits>* __sb) | |
10657 | { | |
10658 | ios_base::_M_init(); | |
10659 | _M_cache_locale(_M_ios_locale); | |
10660 | _M_fill = _CharT(); | |
10661 | _M_fill_init = false; | |
10662 | _M_tie = 0; | |
10663 | _M_exception = goodbit; | |
10664 | _M_streambuf = __sb; | |
10665 | _M_streambuf_state = __sb ? goodbit : badbit; | |
10666 | } | |
10667 | template<typename _CharT, typename _Traits> | |
10668 | void | |
10669 | basic_ios<_CharT, _Traits>::_M_cache_locale(const locale& __loc) | |
10670 | { | |
10671 | if (__builtin_expect(has_facet<__ctype_type>(__loc), true)) | |
10672 | _M_ctype = &use_facet<__ctype_type>(__loc); | |
10673 | else | |
10674 | _M_ctype = 0; | |
10675 | if (__builtin_expect(has_facet<__num_put_type>(__loc), true)) | |
10676 | _M_num_put = &use_facet<__num_put_type>(__loc); | |
10677 | else | |
10678 | _M_num_put = 0; | |
10679 | if (__builtin_expect(has_facet<__num_get_type>(__loc), true)) | |
10680 | _M_num_get = &use_facet<__num_get_type>(__loc); | |
10681 | else | |
10682 | _M_num_get = 0; | |
10683 | } | |
10684 | extern template class basic_ios<char>; | |
10685 | } | |
10686 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
10687 | template<typename _CharT, typename _Traits> | |
10688 | class basic_ostream : virtual public basic_ios<_CharT, _Traits> | |
10689 | { | |
10690 | public: | |
10691 | typedef _CharT char_type; | |
10692 | typedef typename _Traits::int_type int_type; | |
10693 | typedef typename _Traits::pos_type pos_type; | |
10694 | typedef typename _Traits::off_type off_type; | |
10695 | typedef _Traits traits_type; | |
10696 | typedef basic_streambuf<_CharT, _Traits> __streambuf_type; | |
10697 | typedef basic_ios<_CharT, _Traits> __ios_type; | |
10698 | typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
10699 | typedef num_put<_CharT, ostreambuf_iterator<_CharT, _Traits> > | |
10700 | __num_put_type; | |
10701 | typedef ctype<_CharT> __ctype_type; | |
10702 | explicit | |
10703 | basic_ostream(__streambuf_type* __sb) | |
10704 | { this->init(__sb); } | |
10705 | virtual | |
10706 | ~basic_ostream() { } | |
10707 | class sentry; | |
10708 | friend class sentry; | |
10709 | __ostream_type& | |
10710 | operator<<(__ostream_type& (*__pf)(__ostream_type&)) | |
10711 | { | |
10712 | return __pf(*this); | |
10713 | } | |
10714 | __ostream_type& | |
10715 | operator<<(__ios_type& (*__pf)(__ios_type&)) | |
10716 | { | |
10717 | __pf(*this); | |
10718 | return *this; | |
10719 | } | |
10720 | __ostream_type& | |
10721 | operator<<(ios_base& (*__pf) (ios_base&)) | |
10722 | { | |
10723 | __pf(*this); | |
10724 | return *this; | |
10725 | } | |
10726 | __ostream_type& | |
10727 | operator<<(long __n) | |
10728 | { return _M_insert(__n); } | |
10729 | __ostream_type& | |
10730 | operator<<(unsigned long __n) | |
10731 | { return _M_insert(__n); } | |
10732 | __ostream_type& | |
10733 | operator<<(bool __n) | |
10734 | { return _M_insert(__n); } | |
10735 | __ostream_type& | |
10736 | operator<<(short __n); | |
10737 | __ostream_type& | |
10738 | operator<<(unsigned short __n) | |
10739 | { | |
10740 | return _M_insert(static_cast<unsigned long>(__n)); | |
10741 | } | |
10742 | __ostream_type& | |
10743 | operator<<(int __n); | |
10744 | __ostream_type& | |
10745 | operator<<(unsigned int __n) | |
10746 | { | |
10747 | return _M_insert(static_cast<unsigned long>(__n)); | |
10748 | } | |
10749 | __ostream_type& | |
10750 | operator<<(long long __n) | |
10751 | { return _M_insert(__n); } | |
10752 | __ostream_type& | |
10753 | operator<<(unsigned long long __n) | |
10754 | { return _M_insert(__n); } | |
10755 | __ostream_type& | |
10756 | operator<<(double __f) | |
10757 | { return _M_insert(__f); } | |
10758 | __ostream_type& | |
10759 | operator<<(float __f) | |
10760 | { | |
10761 | return _M_insert(static_cast<double>(__f)); | |
10762 | } | |
10763 | __ostream_type& | |
10764 | operator<<(long double __f) | |
10765 | { return _M_insert(__f); } | |
10766 | __ostream_type& | |
10767 | operator<<(const void* __p) | |
10768 | { return _M_insert(__p); } | |
10769 | __ostream_type& | |
10770 | operator<<(__streambuf_type* __sb); | |
10771 | __ostream_type& | |
10772 | put(char_type __c); | |
10773 | void | |
10774 | _M_write(const char_type* __s, streamsize __n) | |
10775 | { | |
10776 | const streamsize __put = this->rdbuf()->sputn(__s, __n); | |
10777 | if (__put != __n) | |
10778 | this->setstate(ios_base::badbit); | |
10779 | } | |
10780 | __ostream_type& | |
10781 | write(const char_type* __s, streamsize __n); | |
10782 | __ostream_type& | |
10783 | flush(); | |
10784 | pos_type | |
10785 | tellp(); | |
10786 | __ostream_type& | |
10787 | seekp(pos_type); | |
10788 | __ostream_type& | |
10789 | seekp(off_type, ios_base::seekdir); | |
10790 | protected: | |
10791 | basic_ostream() | |
10792 | { this->init(0); } | |
10793 | template<typename _ValueT> | |
10794 | __ostream_type& | |
10795 | _M_insert(_ValueT __v); | |
10796 | }; | |
10797 | template <typename _CharT, typename _Traits> | |
10798 | class basic_ostream<_CharT, _Traits>::sentry | |
10799 | { | |
10800 | bool _M_ok; | |
10801 | basic_ostream<_CharT, _Traits>& _M_os; | |
10802 | public: | |
10803 | explicit | |
10804 | sentry(basic_ostream<_CharT, _Traits>& __os); | |
10805 | ~sentry() | |
10806 | { | |
10807 | if (bool(_M_os.flags() & ios_base::unitbuf) && !uncaught_exception()) | |
10808 | { | |
10809 | if (_M_os.rdbuf() && _M_os.rdbuf()->pubsync() == -1) | |
10810 | _M_os.setstate(ios_base::badbit); | |
10811 | } | |
10812 | } | |
10813 | operator bool() const | |
10814 | { return _M_ok; } | |
10815 | }; | |
10816 | template<typename _CharT, typename _Traits> | |
10817 | inline basic_ostream<_CharT, _Traits>& | |
10818 | operator<<(basic_ostream<_CharT, _Traits>& __out, _CharT __c) | |
10819 | { return __ostream_insert(__out, &__c, 1); } | |
10820 | template<typename _CharT, typename _Traits> | |
10821 | inline basic_ostream<_CharT, _Traits>& | |
10822 | operator<<(basic_ostream<_CharT, _Traits>& __out, char __c) | |
10823 | { return (__out << __out.widen(__c)); } | |
10824 | template <class _Traits> | |
10825 | inline basic_ostream<char, _Traits>& | |
10826 | operator<<(basic_ostream<char, _Traits>& __out, char __c) | |
10827 | { return __ostream_insert(__out, &__c, 1); } | |
10828 | template<class _Traits> | |
10829 | inline basic_ostream<char, _Traits>& | |
10830 | operator<<(basic_ostream<char, _Traits>& __out, signed char __c) | |
10831 | { return (__out << static_cast<char>(__c)); } | |
10832 | template<class _Traits> | |
10833 | inline basic_ostream<char, _Traits>& | |
10834 | operator<<(basic_ostream<char, _Traits>& __out, unsigned char __c) | |
10835 | { return (__out << static_cast<char>(__c)); } | |
10836 | template<typename _CharT, typename _Traits> | |
10837 | inline basic_ostream<_CharT, _Traits>& | |
10838 | operator<<(basic_ostream<_CharT, _Traits>& __out, const _CharT* __s) | |
10839 | { | |
10840 | if (!__s) | |
10841 | __out.setstate(ios_base::badbit); | |
10842 | else | |
10843 | __ostream_insert(__out, __s, | |
10844 | static_cast<streamsize>(_Traits::length(__s))); | |
10845 | return __out; | |
10846 | } | |
10847 | template<typename _CharT, typename _Traits> | |
10848 | basic_ostream<_CharT, _Traits> & | |
10849 | operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s); | |
10850 | template<class _Traits> | |
10851 | inline basic_ostream<char, _Traits>& | |
10852 | operator<<(basic_ostream<char, _Traits>& __out, const char* __s) | |
10853 | { | |
10854 | if (!__s) | |
10855 | __out.setstate(ios_base::badbit); | |
10856 | else | |
10857 | __ostream_insert(__out, __s, | |
10858 | static_cast<streamsize>(_Traits::length(__s))); | |
10859 | return __out; | |
10860 | } | |
10861 | template<class _Traits> | |
10862 | inline basic_ostream<char, _Traits>& | |
10863 | operator<<(basic_ostream<char, _Traits>& __out, const signed char* __s) | |
10864 | { return (__out << reinterpret_cast<const char*>(__s)); } | |
10865 | template<class _Traits> | |
10866 | inline basic_ostream<char, _Traits> & | |
10867 | operator<<(basic_ostream<char, _Traits>& __out, const unsigned char* __s) | |
10868 | { return (__out << reinterpret_cast<const char*>(__s)); } | |
10869 | template<typename _CharT, typename _Traits> | |
10870 | inline basic_ostream<_CharT, _Traits>& | |
10871 | endl(basic_ostream<_CharT, _Traits>& __os) | |
10872 | { return flush(__os.put(__os.widen('\n'))); } | |
10873 | template<typename _CharT, typename _Traits> | |
10874 | inline basic_ostream<_CharT, _Traits>& | |
10875 | ends(basic_ostream<_CharT, _Traits>& __os) | |
10876 | { return __os.put(_CharT()); } | |
10877 | template<typename _CharT, typename _Traits> | |
10878 | inline basic_ostream<_CharT, _Traits>& | |
10879 | flush(basic_ostream<_CharT, _Traits>& __os) | |
10880 | { return __os.flush(); } | |
10881 | } | |
10882 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
10883 | template<typename _CharT, typename _Traits> | |
10884 | basic_ostream<_CharT, _Traits>::sentry:: | |
10885 | sentry(basic_ostream<_CharT, _Traits>& __os) | |
10886 | : _M_ok(false), _M_os(__os) | |
10887 | { | |
10888 | if (__os.tie() && __os.good()) | |
10889 | __os.tie()->flush(); | |
10890 | if (__os.good()) | |
10891 | _M_ok = true; | |
10892 | else | |
10893 | __os.setstate(ios_base::failbit); | |
10894 | } | |
10895 | template<typename _CharT, typename _Traits> | |
10896 | template<typename _ValueT> | |
10897 | basic_ostream<_CharT, _Traits>& | |
10898 | basic_ostream<_CharT, _Traits>:: | |
10899 | _M_insert(_ValueT __v) | |
10900 | { | |
10901 | sentry __cerb(*this); | |
10902 | if (__cerb) | |
10903 | { | |
10904 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
10905 | try | |
10906 | { | |
10907 | const __num_put_type& __np = __check_facet(this->_M_num_put); | |
10908 | if (__np.put(*this, *this, this->fill(), __v).failed()) | |
10909 | __err |= ios_base::badbit; | |
10910 | } | |
10911 | catch(__cxxabiv1::__forced_unwind&) | |
10912 | { | |
10913 | this->_M_setstate(ios_base::badbit); | |
10914 | throw; | |
10915 | } | |
10916 | catch(...) | |
10917 | { this->_M_setstate(ios_base::badbit); } | |
10918 | if (__err) | |
10919 | this->setstate(__err); | |
10920 | } | |
10921 | return *this; | |
10922 | } | |
10923 | template<typename _CharT, typename _Traits> | |
10924 | basic_ostream<_CharT, _Traits>& | |
10925 | basic_ostream<_CharT, _Traits>:: | |
10926 | operator<<(short __n) | |
10927 | { | |
10928 | const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; | |
10929 | if (__fmt == ios_base::oct || __fmt == ios_base::hex) | |
10930 | return _M_insert(static_cast<long>(static_cast<unsigned short>(__n))); | |
10931 | else | |
10932 | return _M_insert(static_cast<long>(__n)); | |
10933 | } | |
10934 | template<typename _CharT, typename _Traits> | |
10935 | basic_ostream<_CharT, _Traits>& | |
10936 | basic_ostream<_CharT, _Traits>:: | |
10937 | operator<<(int __n) | |
10938 | { | |
10939 | const ios_base::fmtflags __fmt = this->flags() & ios_base::basefield; | |
10940 | if (__fmt == ios_base::oct || __fmt == ios_base::hex) | |
10941 | return _M_insert(static_cast<long>(static_cast<unsigned int>(__n))); | |
10942 | else | |
10943 | return _M_insert(static_cast<long>(__n)); | |
10944 | } | |
10945 | template<typename _CharT, typename _Traits> | |
10946 | basic_ostream<_CharT, _Traits>& | |
10947 | basic_ostream<_CharT, _Traits>:: | |
10948 | operator<<(__streambuf_type* __sbin) | |
10949 | { | |
10950 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
10951 | sentry __cerb(*this); | |
10952 | if (__cerb && __sbin) | |
10953 | { | |
10954 | try | |
10955 | { | |
10956 | if (!__copy_streambufs(__sbin, this->rdbuf())) | |
10957 | __err |= ios_base::failbit; | |
10958 | } | |
10959 | catch(__cxxabiv1::__forced_unwind&) | |
10960 | { | |
10961 | this->_M_setstate(ios_base::badbit); | |
10962 | throw; | |
10963 | } | |
10964 | catch(...) | |
10965 | { this->_M_setstate(ios_base::failbit); } | |
10966 | } | |
10967 | else if (!__sbin) | |
10968 | __err |= ios_base::badbit; | |
10969 | if (__err) | |
10970 | this->setstate(__err); | |
10971 | return *this; | |
10972 | } | |
10973 | template<typename _CharT, typename _Traits> | |
10974 | basic_ostream<_CharT, _Traits>& | |
10975 | basic_ostream<_CharT, _Traits>:: | |
10976 | put(char_type __c) | |
10977 | { | |
10978 | sentry __cerb(*this); | |
10979 | if (__cerb) | |
10980 | { | |
10981 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
10982 | try | |
10983 | { | |
10984 | const int_type __put = this->rdbuf()->sputc(__c); | |
10985 | if (traits_type::eq_int_type(__put, traits_type::eof())) | |
10986 | __err |= ios_base::badbit; | |
10987 | } | |
10988 | catch(__cxxabiv1::__forced_unwind&) | |
10989 | { | |
10990 | this->_M_setstate(ios_base::badbit); | |
10991 | throw; | |
10992 | } | |
10993 | catch(...) | |
10994 | { this->_M_setstate(ios_base::badbit); } | |
10995 | if (__err) | |
10996 | this->setstate(__err); | |
10997 | } | |
10998 | return *this; | |
10999 | } | |
11000 | template<typename _CharT, typename _Traits> | |
11001 | basic_ostream<_CharT, _Traits>& | |
11002 | basic_ostream<_CharT, _Traits>:: | |
11003 | write(const _CharT* __s, streamsize __n) | |
11004 | { | |
11005 | sentry __cerb(*this); | |
11006 | if (__cerb) | |
11007 | { | |
11008 | try | |
11009 | { _M_write(__s, __n); } | |
11010 | catch(__cxxabiv1::__forced_unwind&) | |
11011 | { | |
11012 | this->_M_setstate(ios_base::badbit); | |
11013 | throw; | |
11014 | } | |
11015 | catch(...) | |
11016 | { this->_M_setstate(ios_base::badbit); } | |
11017 | } | |
11018 | return *this; | |
11019 | } | |
11020 | template<typename _CharT, typename _Traits> | |
11021 | basic_ostream<_CharT, _Traits>& | |
11022 | basic_ostream<_CharT, _Traits>:: | |
11023 | flush() | |
11024 | { | |
11025 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11026 | try | |
11027 | { | |
11028 | if (this->rdbuf() && this->rdbuf()->pubsync() == -1) | |
11029 | __err |= ios_base::badbit; | |
11030 | } | |
11031 | catch(__cxxabiv1::__forced_unwind&) | |
11032 | { | |
11033 | this->_M_setstate(ios_base::badbit); | |
11034 | throw; | |
11035 | } | |
11036 | catch(...) | |
11037 | { this->_M_setstate(ios_base::badbit); } | |
11038 | if (__err) | |
11039 | this->setstate(__err); | |
11040 | return *this; | |
11041 | } | |
11042 | template<typename _CharT, typename _Traits> | |
11043 | typename basic_ostream<_CharT, _Traits>::pos_type | |
11044 | basic_ostream<_CharT, _Traits>:: | |
11045 | tellp() | |
11046 | { | |
11047 | pos_type __ret = pos_type(-1); | |
11048 | try | |
11049 | { | |
11050 | if (!this->fail()) | |
11051 | __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, ios_base::out); | |
11052 | } | |
11053 | catch(__cxxabiv1::__forced_unwind&) | |
11054 | { | |
11055 | this->_M_setstate(ios_base::badbit); | |
11056 | throw; | |
11057 | } | |
11058 | catch(...) | |
11059 | { this->_M_setstate(ios_base::badbit); } | |
11060 | return __ret; | |
11061 | } | |
11062 | template<typename _CharT, typename _Traits> | |
11063 | basic_ostream<_CharT, _Traits>& | |
11064 | basic_ostream<_CharT, _Traits>:: | |
11065 | seekp(pos_type __pos) | |
11066 | { | |
11067 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11068 | try | |
11069 | { | |
11070 | if (!this->fail()) | |
11071 | { | |
11072 | const pos_type __p = this->rdbuf()->pubseekpos(__pos, | |
11073 | ios_base::out); | |
11074 | if (__p == pos_type(off_type(-1))) | |
11075 | __err |= ios_base::failbit; | |
11076 | } | |
11077 | } | |
11078 | catch(__cxxabiv1::__forced_unwind&) | |
11079 | { | |
11080 | this->_M_setstate(ios_base::badbit); | |
11081 | throw; | |
11082 | } | |
11083 | catch(...) | |
11084 | { this->_M_setstate(ios_base::badbit); } | |
11085 | if (__err) | |
11086 | this->setstate(__err); | |
11087 | return *this; | |
11088 | } | |
11089 | template<typename _CharT, typename _Traits> | |
11090 | basic_ostream<_CharT, _Traits>& | |
11091 | basic_ostream<_CharT, _Traits>:: | |
11092 | seekp(off_type __off, ios_base::seekdir __dir) | |
11093 | { | |
11094 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11095 | try | |
11096 | { | |
11097 | if (!this->fail()) | |
11098 | { | |
11099 | const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, | |
11100 | ios_base::out); | |
11101 | if (__p == pos_type(off_type(-1))) | |
11102 | __err |= ios_base::failbit; | |
11103 | } | |
11104 | } | |
11105 | catch(__cxxabiv1::__forced_unwind&) | |
11106 | { | |
11107 | this->_M_setstate(ios_base::badbit); | |
11108 | throw; | |
11109 | } | |
11110 | catch(...) | |
11111 | { this->_M_setstate(ios_base::badbit); } | |
11112 | if (__err) | |
11113 | this->setstate(__err); | |
11114 | return *this; | |
11115 | } | |
11116 | template<typename _CharT, typename _Traits> | |
11117 | basic_ostream<_CharT, _Traits>& | |
11118 | operator<<(basic_ostream<_CharT, _Traits>& __out, const char* __s) | |
11119 | { | |
11120 | if (!__s) | |
11121 | __out.setstate(ios_base::badbit); | |
11122 | else | |
11123 | { | |
11124 | const size_t __clen = char_traits<char>::length(__s); | |
11125 | try | |
11126 | { | |
11127 | struct __ptr_guard | |
11128 | { | |
11129 | _CharT *__p; | |
11130 | __ptr_guard (_CharT *__ip): __p(__ip) { } | |
11131 | ~__ptr_guard() { delete[] __p; } | |
11132 | _CharT* __get() { return __p; } | |
11133 | } __pg (new _CharT[__clen]); | |
11134 | _CharT *__ws = __pg.__get(); | |
11135 | for (size_t __i = 0; __i < __clen; ++__i) | |
11136 | __ws[__i] = __out.widen(__s[__i]); | |
11137 | __ostream_insert(__out, __ws, __clen); | |
11138 | } | |
11139 | catch(__cxxabiv1::__forced_unwind&) | |
11140 | { | |
11141 | __out._M_setstate(ios_base::badbit); | |
11142 | throw; | |
11143 | } | |
11144 | catch(...) | |
11145 | { __out._M_setstate(ios_base::badbit); } | |
11146 | } | |
11147 | return __out; | |
11148 | } | |
11149 | extern template class basic_ostream<char>; | |
11150 | extern template ostream& endl(ostream&); | |
11151 | extern template ostream& ends(ostream&); | |
11152 | extern template ostream& flush(ostream&); | |
11153 | extern template ostream& operator<<(ostream&, char); | |
11154 | extern template ostream& operator<<(ostream&, unsigned char); | |
11155 | extern template ostream& operator<<(ostream&, signed char); | |
11156 | extern template ostream& operator<<(ostream&, const char*); | |
11157 | extern template ostream& operator<<(ostream&, const unsigned char*); | |
11158 | extern template ostream& operator<<(ostream&, const signed char*); | |
11159 | extern template ostream& ostream::_M_insert(long); | |
11160 | extern template ostream& ostream::_M_insert(unsigned long); | |
11161 | extern template ostream& ostream::_M_insert(bool); | |
11162 | extern template ostream& ostream::_M_insert(long long); | |
11163 | extern template ostream& ostream::_M_insert(unsigned long long); | |
11164 | extern template ostream& ostream::_M_insert(double); | |
11165 | extern template ostream& ostream::_M_insert(long double); | |
11166 | extern template ostream& ostream::_M_insert(const void*); | |
11167 | } | |
11168 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
11169 | template<typename _CharT, typename _Traits> | |
11170 | class basic_istream : virtual public basic_ios<_CharT, _Traits> | |
11171 | { | |
11172 | public: | |
11173 | typedef _CharT char_type; | |
11174 | typedef typename _Traits::int_type int_type; | |
11175 | typedef typename _Traits::pos_type pos_type; | |
11176 | typedef typename _Traits::off_type off_type; | |
11177 | typedef _Traits traits_type; | |
11178 | typedef basic_streambuf<_CharT, _Traits> __streambuf_type; | |
11179 | typedef basic_ios<_CharT, _Traits> __ios_type; | |
11180 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
11181 | typedef num_get<_CharT, istreambuf_iterator<_CharT, _Traits> > | |
11182 | __num_get_type; | |
11183 | typedef ctype<_CharT> __ctype_type; | |
11184 | protected: | |
11185 | streamsize _M_gcount; | |
11186 | public: | |
11187 | explicit | |
11188 | basic_istream(__streambuf_type* __sb) | |
11189 | : _M_gcount(streamsize(0)) | |
11190 | { this->init(__sb); } | |
11191 | virtual | |
11192 | ~basic_istream() | |
11193 | { _M_gcount = streamsize(0); } | |
11194 | class sentry; | |
11195 | friend class sentry; | |
11196 | __istream_type& | |
11197 | operator>>(__istream_type& (*__pf)(__istream_type&)) | |
11198 | { return __pf(*this); } | |
11199 | __istream_type& | |
11200 | operator>>(__ios_type& (*__pf)(__ios_type&)) | |
11201 | { | |
11202 | __pf(*this); | |
11203 | return *this; | |
11204 | } | |
11205 | __istream_type& | |
11206 | operator>>(ios_base& (*__pf)(ios_base&)) | |
11207 | { | |
11208 | __pf(*this); | |
11209 | return *this; | |
11210 | } | |
11211 | __istream_type& | |
11212 | operator>>(bool& __n) | |
11213 | { return _M_extract(__n); } | |
11214 | __istream_type& | |
11215 | operator>>(short& __n); | |
11216 | __istream_type& | |
11217 | operator>>(unsigned short& __n) | |
11218 | { return _M_extract(__n); } | |
11219 | __istream_type& | |
11220 | operator>>(int& __n); | |
11221 | __istream_type& | |
11222 | operator>>(unsigned int& __n) | |
11223 | { return _M_extract(__n); } | |
11224 | __istream_type& | |
11225 | operator>>(long& __n) | |
11226 | { return _M_extract(__n); } | |
11227 | __istream_type& | |
11228 | operator>>(unsigned long& __n) | |
11229 | { return _M_extract(__n); } | |
11230 | __istream_type& | |
11231 | operator>>(long long& __n) | |
11232 | { return _M_extract(__n); } | |
11233 | __istream_type& | |
11234 | operator>>(unsigned long long& __n) | |
11235 | { return _M_extract(__n); } | |
11236 | __istream_type& | |
11237 | operator>>(float& __f) | |
11238 | { return _M_extract(__f); } | |
11239 | __istream_type& | |
11240 | operator>>(double& __f) | |
11241 | { return _M_extract(__f); } | |
11242 | __istream_type& | |
11243 | operator>>(long double& __f) | |
11244 | { return _M_extract(__f); } | |
11245 | __istream_type& | |
11246 | operator>>(void*& __p) | |
11247 | { return _M_extract(__p); } | |
11248 | __istream_type& | |
11249 | operator>>(__streambuf_type* __sb); | |
11250 | streamsize | |
11251 | gcount() const | |
11252 | { return _M_gcount; } | |
11253 | int_type | |
11254 | get(); | |
11255 | __istream_type& | |
11256 | get(char_type& __c); | |
11257 | __istream_type& | |
11258 | get(char_type* __s, streamsize __n, char_type __delim); | |
11259 | __istream_type& | |
11260 | get(char_type* __s, streamsize __n) | |
11261 | { return this->get(__s, __n, this->widen('\n')); } | |
11262 | __istream_type& | |
11263 | get(__streambuf_type& __sb, char_type __delim); | |
11264 | __istream_type& | |
11265 | get(__streambuf_type& __sb) | |
11266 | { return this->get(__sb, this->widen('\n')); } | |
11267 | __istream_type& | |
11268 | getline(char_type* __s, streamsize __n, char_type __delim); | |
11269 | __istream_type& | |
11270 | getline(char_type* __s, streamsize __n) | |
11271 | { return this->getline(__s, __n, this->widen('\n')); } | |
11272 | __istream_type& | |
11273 | ignore(); | |
11274 | __istream_type& | |
11275 | ignore(streamsize __n); | |
11276 | __istream_type& | |
11277 | ignore(streamsize __n, int_type __delim); | |
11278 | int_type | |
11279 | peek(); | |
11280 | __istream_type& | |
11281 | read(char_type* __s, streamsize __n); | |
11282 | streamsize | |
11283 | readsome(char_type* __s, streamsize __n); | |
11284 | __istream_type& | |
11285 | putback(char_type __c); | |
11286 | __istream_type& | |
11287 | unget(); | |
11288 | int | |
11289 | sync(); | |
11290 | pos_type | |
11291 | tellg(); | |
11292 | __istream_type& | |
11293 | seekg(pos_type); | |
11294 | __istream_type& | |
11295 | seekg(off_type, ios_base::seekdir); | |
11296 | protected: | |
11297 | basic_istream() | |
11298 | : _M_gcount(streamsize(0)) | |
11299 | { this->init(0); } | |
11300 | template<typename _ValueT> | |
11301 | __istream_type& | |
11302 | _M_extract(_ValueT& __v); | |
11303 | }; | |
11304 | template<> | |
11305 | basic_istream<char>& | |
11306 | basic_istream<char>:: | |
11307 | getline(char_type* __s, streamsize __n, char_type __delim); | |
11308 | template<> | |
11309 | basic_istream<char>& | |
11310 | basic_istream<char>:: | |
11311 | ignore(streamsize __n); | |
11312 | template<> | |
11313 | basic_istream<char>& | |
11314 | basic_istream<char>:: | |
11315 | ignore(streamsize __n, int_type __delim); | |
11316 | template<typename _CharT, typename _Traits> | |
11317 | class basic_istream<_CharT, _Traits>::sentry | |
11318 | { | |
11319 | public: | |
11320 | typedef _Traits traits_type; | |
11321 | typedef basic_streambuf<_CharT, _Traits> __streambuf_type; | |
11322 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
11323 | typedef typename __istream_type::__ctype_type __ctype_type; | |
11324 | typedef typename _Traits::int_type __int_type; | |
11325 | explicit | |
11326 | sentry(basic_istream<_CharT, _Traits>& __is, bool __noskipws = false); | |
11327 | operator bool() const | |
11328 | { return _M_ok; } | |
11329 | private: | |
11330 | bool _M_ok; | |
11331 | }; | |
11332 | template<typename _CharT, typename _Traits> | |
11333 | basic_istream<_CharT, _Traits>& | |
11334 | operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c); | |
11335 | template<class _Traits> | |
11336 | inline basic_istream<char, _Traits>& | |
11337 | operator>>(basic_istream<char, _Traits>& __in, unsigned char& __c) | |
11338 | { return (__in >> reinterpret_cast<char&>(__c)); } | |
11339 | template<class _Traits> | |
11340 | inline basic_istream<char, _Traits>& | |
11341 | operator>>(basic_istream<char, _Traits>& __in, signed char& __c) | |
11342 | { return (__in >> reinterpret_cast<char&>(__c)); } | |
11343 | template<typename _CharT, typename _Traits> | |
11344 | basic_istream<_CharT, _Traits>& | |
11345 | operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s); | |
11346 | template<> | |
11347 | basic_istream<char>& | |
11348 | operator>>(basic_istream<char>& __in, char* __s); | |
11349 | template<class _Traits> | |
11350 | inline basic_istream<char, _Traits>& | |
11351 | operator>>(basic_istream<char, _Traits>& __in, unsigned char* __s) | |
11352 | { return (__in >> reinterpret_cast<char*>(__s)); } | |
11353 | template<class _Traits> | |
11354 | inline basic_istream<char, _Traits>& | |
11355 | operator>>(basic_istream<char, _Traits>& __in, signed char* __s) | |
11356 | { return (__in >> reinterpret_cast<char*>(__s)); } | |
11357 | template<typename _CharT, typename _Traits> | |
11358 | class basic_iostream | |
11359 | : public basic_istream<_CharT, _Traits>, | |
11360 | public basic_ostream<_CharT, _Traits> | |
11361 | { | |
11362 | public: | |
11363 | typedef _CharT char_type; | |
11364 | typedef typename _Traits::int_type int_type; | |
11365 | typedef typename _Traits::pos_type pos_type; | |
11366 | typedef typename _Traits::off_type off_type; | |
11367 | typedef _Traits traits_type; | |
11368 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
11369 | typedef basic_ostream<_CharT, _Traits> __ostream_type; | |
11370 | explicit | |
11371 | basic_iostream(basic_streambuf<_CharT, _Traits>* __sb) | |
11372 | : __istream_type(__sb), __ostream_type(__sb) { } | |
11373 | virtual | |
11374 | ~basic_iostream() { } | |
11375 | protected: | |
11376 | basic_iostream() | |
11377 | : __istream_type(), __ostream_type() { } | |
11378 | }; | |
11379 | template<typename _CharT, typename _Traits> | |
11380 | basic_istream<_CharT, _Traits>& | |
11381 | ws(basic_istream<_CharT, _Traits>& __is); | |
11382 | } | |
11383 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
11384 | template<typename _CharT, typename _Traits> | |
11385 | basic_istream<_CharT, _Traits>::sentry:: | |
11386 | sentry(basic_istream<_CharT, _Traits>& __in, bool __noskip) : _M_ok(false) | |
11387 | { | |
11388 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11389 | if (__in.good()) | |
11390 | { | |
11391 | if (__in.tie()) | |
11392 | __in.tie()->flush(); | |
11393 | if (!__noskip && bool(__in.flags() & ios_base::skipws)) | |
11394 | { | |
11395 | const __int_type __eof = traits_type::eof(); | |
11396 | __streambuf_type* __sb = __in.rdbuf(); | |
11397 | __int_type __c = __sb->sgetc(); | |
11398 | const __ctype_type& __ct = __check_facet(__in._M_ctype); | |
11399 | while (!traits_type::eq_int_type(__c, __eof) | |
11400 | && __ct.is(ctype_base::space, | |
11401 | traits_type::to_char_type(__c))) | |
11402 | __c = __sb->snextc(); | |
11403 | if (traits_type::eq_int_type(__c, __eof)) | |
11404 | __err |= ios_base::eofbit; | |
11405 | } | |
11406 | } | |
11407 | if (__in.good() && __err == ios_base::goodbit) | |
11408 | _M_ok = true; | |
11409 | else | |
11410 | { | |
11411 | __err |= ios_base::failbit; | |
11412 | __in.setstate(__err); | |
11413 | } | |
11414 | } | |
11415 | template<typename _CharT, typename _Traits> | |
11416 | template<typename _ValueT> | |
11417 | basic_istream<_CharT, _Traits>& | |
11418 | basic_istream<_CharT, _Traits>:: | |
11419 | _M_extract(_ValueT& __v) | |
11420 | { | |
11421 | sentry __cerb(*this, false); | |
11422 | if (__cerb) | |
11423 | { | |
11424 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11425 | try | |
11426 | { | |
11427 | const __num_get_type& __ng = __check_facet(this->_M_num_get); | |
11428 | __ng.get(*this, 0, *this, __err, __v); | |
11429 | } | |
11430 | catch(__cxxabiv1::__forced_unwind&) | |
11431 | { | |
11432 | this->_M_setstate(ios_base::badbit); | |
11433 | throw; | |
11434 | } | |
11435 | catch(...) | |
11436 | { this->_M_setstate(ios_base::badbit); } | |
11437 | if (__err) | |
11438 | this->setstate(__err); | |
11439 | } | |
11440 | return *this; | |
11441 | } | |
11442 | template<typename _CharT, typename _Traits> | |
11443 | basic_istream<_CharT, _Traits>& | |
11444 | basic_istream<_CharT, _Traits>:: | |
11445 | operator>>(short& __n) | |
11446 | { | |
11447 | long __l; | |
11448 | _M_extract(__l); | |
11449 | if (!this->fail()) | |
11450 | { | |
11451 | if (__gnu_cxx::__numeric_traits<short>::__min <= __l | |
11452 | && __l <= __gnu_cxx::__numeric_traits<short>::__max) | |
11453 | __n = short(__l); | |
11454 | else | |
11455 | this->setstate(ios_base::failbit); | |
11456 | } | |
11457 | return *this; | |
11458 | } | |
11459 | template<typename _CharT, typename _Traits> | |
11460 | basic_istream<_CharT, _Traits>& | |
11461 | basic_istream<_CharT, _Traits>:: | |
11462 | operator>>(int& __n) | |
11463 | { | |
11464 | long __l; | |
11465 | _M_extract(__l); | |
11466 | if (!this->fail()) | |
11467 | { | |
11468 | if (__gnu_cxx::__numeric_traits<int>::__min <= __l | |
11469 | && __l <= __gnu_cxx::__numeric_traits<int>::__max) | |
11470 | __n = int(__l); | |
11471 | else | |
11472 | this->setstate(ios_base::failbit); | |
11473 | } | |
11474 | return *this; | |
11475 | } | |
11476 | template<typename _CharT, typename _Traits> | |
11477 | basic_istream<_CharT, _Traits>& | |
11478 | basic_istream<_CharT, _Traits>:: | |
11479 | operator>>(__streambuf_type* __sbout) | |
11480 | { | |
11481 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11482 | sentry __cerb(*this, false); | |
11483 | if (__cerb && __sbout) | |
11484 | { | |
11485 | try | |
11486 | { | |
11487 | bool __ineof; | |
11488 | if (!__copy_streambufs_eof(this->rdbuf(), __sbout, __ineof)) | |
11489 | __err |= ios_base::failbit; | |
11490 | if (__ineof) | |
11491 | __err |= ios_base::eofbit; | |
11492 | } | |
11493 | catch(__cxxabiv1::__forced_unwind&) | |
11494 | { | |
11495 | this->_M_setstate(ios_base::failbit); | |
11496 | throw; | |
11497 | } | |
11498 | catch(...) | |
11499 | { this->_M_setstate(ios_base::failbit); } | |
11500 | } | |
11501 | else if (!__sbout) | |
11502 | __err |= ios_base::failbit; | |
11503 | if (__err) | |
11504 | this->setstate(__err); | |
11505 | return *this; | |
11506 | } | |
11507 | template<typename _CharT, typename _Traits> | |
11508 | typename basic_istream<_CharT, _Traits>::int_type | |
11509 | basic_istream<_CharT, _Traits>:: | |
11510 | get(void) | |
11511 | { | |
11512 | const int_type __eof = traits_type::eof(); | |
11513 | int_type __c = __eof; | |
11514 | _M_gcount = 0; | |
11515 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11516 | sentry __cerb(*this, true); | |
11517 | if (__cerb) | |
11518 | { | |
11519 | try | |
11520 | { | |
11521 | __c = this->rdbuf()->sbumpc(); | |
11522 | if (!traits_type::eq_int_type(__c, __eof)) | |
11523 | _M_gcount = 1; | |
11524 | else | |
11525 | __err |= ios_base::eofbit; | |
11526 | } | |
11527 | catch(__cxxabiv1::__forced_unwind&) | |
11528 | { | |
11529 | this->_M_setstate(ios_base::badbit); | |
11530 | throw; | |
11531 | } | |
11532 | catch(...) | |
11533 | { this->_M_setstate(ios_base::badbit); } | |
11534 | } | |
11535 | if (!_M_gcount) | |
11536 | __err |= ios_base::failbit; | |
11537 | if (__err) | |
11538 | this->setstate(__err); | |
11539 | return __c; | |
11540 | } | |
11541 | template<typename _CharT, typename _Traits> | |
11542 | basic_istream<_CharT, _Traits>& | |
11543 | basic_istream<_CharT, _Traits>:: | |
11544 | get(char_type& __c) | |
11545 | { | |
11546 | _M_gcount = 0; | |
11547 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11548 | sentry __cerb(*this, true); | |
11549 | if (__cerb) | |
11550 | { | |
11551 | try | |
11552 | { | |
11553 | const int_type __cb = this->rdbuf()->sbumpc(); | |
11554 | if (!traits_type::eq_int_type(__cb, traits_type::eof())) | |
11555 | { | |
11556 | _M_gcount = 1; | |
11557 | __c = traits_type::to_char_type(__cb); | |
11558 | } | |
11559 | else | |
11560 | __err |= ios_base::eofbit; | |
11561 | } | |
11562 | catch(__cxxabiv1::__forced_unwind&) | |
11563 | { | |
11564 | this->_M_setstate(ios_base::badbit); | |
11565 | throw; | |
11566 | } | |
11567 | catch(...) | |
11568 | { this->_M_setstate(ios_base::badbit); } | |
11569 | } | |
11570 | if (!_M_gcount) | |
11571 | __err |= ios_base::failbit; | |
11572 | if (__err) | |
11573 | this->setstate(__err); | |
11574 | return *this; | |
11575 | } | |
11576 | template<typename _CharT, typename _Traits> | |
11577 | basic_istream<_CharT, _Traits>& | |
11578 | basic_istream<_CharT, _Traits>:: | |
11579 | get(char_type* __s, streamsize __n, char_type __delim) | |
11580 | { | |
11581 | _M_gcount = 0; | |
11582 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11583 | sentry __cerb(*this, true); | |
11584 | if (__cerb) | |
11585 | { | |
11586 | try | |
11587 | { | |
11588 | const int_type __idelim = traits_type::to_int_type(__delim); | |
11589 | const int_type __eof = traits_type::eof(); | |
11590 | __streambuf_type* __sb = this->rdbuf(); | |
11591 | int_type __c = __sb->sgetc(); | |
11592 | while (_M_gcount + 1 < __n | |
11593 | && !traits_type::eq_int_type(__c, __eof) | |
11594 | && !traits_type::eq_int_type(__c, __idelim)) | |
11595 | { | |
11596 | *__s++ = traits_type::to_char_type(__c); | |
11597 | ++_M_gcount; | |
11598 | __c = __sb->snextc(); | |
11599 | } | |
11600 | if (traits_type::eq_int_type(__c, __eof)) | |
11601 | __err |= ios_base::eofbit; | |
11602 | } | |
11603 | catch(__cxxabiv1::__forced_unwind&) | |
11604 | { | |
11605 | this->_M_setstate(ios_base::badbit); | |
11606 | throw; | |
11607 | } | |
11608 | catch(...) | |
11609 | { this->_M_setstate(ios_base::badbit); } | |
11610 | } | |
11611 | if (__n > 0) | |
11612 | *__s = char_type(); | |
11613 | if (!_M_gcount) | |
11614 | __err |= ios_base::failbit; | |
11615 | if (__err) | |
11616 | this->setstate(__err); | |
11617 | return *this; | |
11618 | } | |
11619 | template<typename _CharT, typename _Traits> | |
11620 | basic_istream<_CharT, _Traits>& | |
11621 | basic_istream<_CharT, _Traits>:: | |
11622 | get(__streambuf_type& __sb, char_type __delim) | |
11623 | { | |
11624 | _M_gcount = 0; | |
11625 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11626 | sentry __cerb(*this, true); | |
11627 | if (__cerb) | |
11628 | { | |
11629 | try | |
11630 | { | |
11631 | const int_type __idelim = traits_type::to_int_type(__delim); | |
11632 | const int_type __eof = traits_type::eof(); | |
11633 | __streambuf_type* __this_sb = this->rdbuf(); | |
11634 | int_type __c = __this_sb->sgetc(); | |
11635 | char_type __c2 = traits_type::to_char_type(__c); | |
11636 | while (!traits_type::eq_int_type(__c, __eof) | |
11637 | && !traits_type::eq_int_type(__c, __idelim) | |
11638 | && !traits_type::eq_int_type(__sb.sputc(__c2), __eof)) | |
11639 | { | |
11640 | ++_M_gcount; | |
11641 | __c = __this_sb->snextc(); | |
11642 | __c2 = traits_type::to_char_type(__c); | |
11643 | } | |
11644 | if (traits_type::eq_int_type(__c, __eof)) | |
11645 | __err |= ios_base::eofbit; | |
11646 | } | |
11647 | catch(__cxxabiv1::__forced_unwind&) | |
11648 | { | |
11649 | this->_M_setstate(ios_base::badbit); | |
11650 | throw; | |
11651 | } | |
11652 | catch(...) | |
11653 | { this->_M_setstate(ios_base::badbit); } | |
11654 | } | |
11655 | if (!_M_gcount) | |
11656 | __err |= ios_base::failbit; | |
11657 | if (__err) | |
11658 | this->setstate(__err); | |
11659 | return *this; | |
11660 | } | |
11661 | template<typename _CharT, typename _Traits> | |
11662 | basic_istream<_CharT, _Traits>& | |
11663 | basic_istream<_CharT, _Traits>:: | |
11664 | getline(char_type* __s, streamsize __n, char_type __delim) | |
11665 | { | |
11666 | _M_gcount = 0; | |
11667 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11668 | sentry __cerb(*this, true); | |
11669 | if (__cerb) | |
11670 | { | |
11671 | try | |
11672 | { | |
11673 | const int_type __idelim = traits_type::to_int_type(__delim); | |
11674 | const int_type __eof = traits_type::eof(); | |
11675 | __streambuf_type* __sb = this->rdbuf(); | |
11676 | int_type __c = __sb->sgetc(); | |
11677 | while (_M_gcount + 1 < __n | |
11678 | && !traits_type::eq_int_type(__c, __eof) | |
11679 | && !traits_type::eq_int_type(__c, __idelim)) | |
11680 | { | |
11681 | *__s++ = traits_type::to_char_type(__c); | |
11682 | __c = __sb->snextc(); | |
11683 | ++_M_gcount; | |
11684 | } | |
11685 | if (traits_type::eq_int_type(__c, __eof)) | |
11686 | __err |= ios_base::eofbit; | |
11687 | else | |
11688 | { | |
11689 | if (traits_type::eq_int_type(__c, __idelim)) | |
11690 | { | |
11691 | __sb->sbumpc(); | |
11692 | ++_M_gcount; | |
11693 | } | |
11694 | else | |
11695 | __err |= ios_base::failbit; | |
11696 | } | |
11697 | } | |
11698 | catch(__cxxabiv1::__forced_unwind&) | |
11699 | { | |
11700 | this->_M_setstate(ios_base::badbit); | |
11701 | throw; | |
11702 | } | |
11703 | catch(...) | |
11704 | { this->_M_setstate(ios_base::badbit); } | |
11705 | } | |
11706 | if (__n > 0) | |
11707 | *__s = char_type(); | |
11708 | if (!_M_gcount) | |
11709 | __err |= ios_base::failbit; | |
11710 | if (__err) | |
11711 | this->setstate(__err); | |
11712 | return *this; | |
11713 | } | |
11714 | template<typename _CharT, typename _Traits> | |
11715 | basic_istream<_CharT, _Traits>& | |
11716 | basic_istream<_CharT, _Traits>:: | |
11717 | ignore(void) | |
11718 | { | |
11719 | _M_gcount = 0; | |
11720 | sentry __cerb(*this, true); | |
11721 | if (__cerb) | |
11722 | { | |
11723 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11724 | try | |
11725 | { | |
11726 | const int_type __eof = traits_type::eof(); | |
11727 | __streambuf_type* __sb = this->rdbuf(); | |
11728 | if (traits_type::eq_int_type(__sb->sbumpc(), __eof)) | |
11729 | __err |= ios_base::eofbit; | |
11730 | else | |
11731 | _M_gcount = 1; | |
11732 | } | |
11733 | catch(__cxxabiv1::__forced_unwind&) | |
11734 | { | |
11735 | this->_M_setstate(ios_base::badbit); | |
11736 | throw; | |
11737 | } | |
11738 | catch(...) | |
11739 | { this->_M_setstate(ios_base::badbit); } | |
11740 | if (__err) | |
11741 | this->setstate(__err); | |
11742 | } | |
11743 | return *this; | |
11744 | } | |
11745 | template<typename _CharT, typename _Traits> | |
11746 | basic_istream<_CharT, _Traits>& | |
11747 | basic_istream<_CharT, _Traits>:: | |
11748 | ignore(streamsize __n) | |
11749 | { | |
11750 | _M_gcount = 0; | |
11751 | sentry __cerb(*this, true); | |
11752 | if (__cerb && __n > 0) | |
11753 | { | |
11754 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11755 | try | |
11756 | { | |
11757 | const int_type __eof = traits_type::eof(); | |
11758 | __streambuf_type* __sb = this->rdbuf(); | |
11759 | int_type __c = __sb->sgetc(); | |
11760 | bool __large_ignore = false; | |
11761 | while (true) | |
11762 | { | |
11763 | while (_M_gcount < __n | |
11764 | && !traits_type::eq_int_type(__c, __eof)) | |
11765 | { | |
11766 | ++_M_gcount; | |
11767 | __c = __sb->snextc(); | |
11768 | } | |
11769 | if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max | |
11770 | && !traits_type::eq_int_type(__c, __eof)) | |
11771 | { | |
11772 | _M_gcount = | |
11773 | __gnu_cxx::__numeric_traits<streamsize>::__min; | |
11774 | __large_ignore = true; | |
11775 | } | |
11776 | else | |
11777 | break; | |
11778 | } | |
11779 | if (__large_ignore) | |
11780 | _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; | |
11781 | if (traits_type::eq_int_type(__c, __eof)) | |
11782 | __err |= ios_base::eofbit; | |
11783 | } | |
11784 | catch(__cxxabiv1::__forced_unwind&) | |
11785 | { | |
11786 | this->_M_setstate(ios_base::badbit); | |
11787 | throw; | |
11788 | } | |
11789 | catch(...) | |
11790 | { this->_M_setstate(ios_base::badbit); } | |
11791 | if (__err) | |
11792 | this->setstate(__err); | |
11793 | } | |
11794 | return *this; | |
11795 | } | |
11796 | template<typename _CharT, typename _Traits> | |
11797 | basic_istream<_CharT, _Traits>& | |
11798 | basic_istream<_CharT, _Traits>:: | |
11799 | ignore(streamsize __n, int_type __delim) | |
11800 | { | |
11801 | _M_gcount = 0; | |
11802 | sentry __cerb(*this, true); | |
11803 | if (__cerb && __n > 0) | |
11804 | { | |
11805 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11806 | try | |
11807 | { | |
11808 | const int_type __eof = traits_type::eof(); | |
11809 | __streambuf_type* __sb = this->rdbuf(); | |
11810 | int_type __c = __sb->sgetc(); | |
11811 | bool __large_ignore = false; | |
11812 | while (true) | |
11813 | { | |
11814 | while (_M_gcount < __n | |
11815 | && !traits_type::eq_int_type(__c, __eof) | |
11816 | && !traits_type::eq_int_type(__c, __delim)) | |
11817 | { | |
11818 | ++_M_gcount; | |
11819 | __c = __sb->snextc(); | |
11820 | } | |
11821 | if (__n == __gnu_cxx::__numeric_traits<streamsize>::__max | |
11822 | && !traits_type::eq_int_type(__c, __eof) | |
11823 | && !traits_type::eq_int_type(__c, __delim)) | |
11824 | { | |
11825 | _M_gcount = | |
11826 | __gnu_cxx::__numeric_traits<streamsize>::__min; | |
11827 | __large_ignore = true; | |
11828 | } | |
11829 | else | |
11830 | break; | |
11831 | } | |
11832 | if (__large_ignore) | |
11833 | _M_gcount = __gnu_cxx::__numeric_traits<streamsize>::__max; | |
11834 | if (traits_type::eq_int_type(__c, __eof)) | |
11835 | __err |= ios_base::eofbit; | |
11836 | else if (traits_type::eq_int_type(__c, __delim)) | |
11837 | { | |
11838 | if (_M_gcount | |
11839 | < __gnu_cxx::__numeric_traits<streamsize>::__max) | |
11840 | ++_M_gcount; | |
11841 | __sb->sbumpc(); | |
11842 | } | |
11843 | } | |
11844 | catch(__cxxabiv1::__forced_unwind&) | |
11845 | { | |
11846 | this->_M_setstate(ios_base::badbit); | |
11847 | throw; | |
11848 | } | |
11849 | catch(...) | |
11850 | { this->_M_setstate(ios_base::badbit); } | |
11851 | if (__err) | |
11852 | this->setstate(__err); | |
11853 | } | |
11854 | return *this; | |
11855 | } | |
11856 | template<typename _CharT, typename _Traits> | |
11857 | typename basic_istream<_CharT, _Traits>::int_type | |
11858 | basic_istream<_CharT, _Traits>:: | |
11859 | peek(void) | |
11860 | { | |
11861 | int_type __c = traits_type::eof(); | |
11862 | _M_gcount = 0; | |
11863 | sentry __cerb(*this, true); | |
11864 | if (__cerb) | |
11865 | { | |
11866 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11867 | try | |
11868 | { | |
11869 | __c = this->rdbuf()->sgetc(); | |
11870 | if (traits_type::eq_int_type(__c, traits_type::eof())) | |
11871 | __err |= ios_base::eofbit; | |
11872 | } | |
11873 | catch(__cxxabiv1::__forced_unwind&) | |
11874 | { | |
11875 | this->_M_setstate(ios_base::badbit); | |
11876 | throw; | |
11877 | } | |
11878 | catch(...) | |
11879 | { this->_M_setstate(ios_base::badbit); } | |
11880 | if (__err) | |
11881 | this->setstate(__err); | |
11882 | } | |
11883 | return __c; | |
11884 | } | |
11885 | template<typename _CharT, typename _Traits> | |
11886 | basic_istream<_CharT, _Traits>& | |
11887 | basic_istream<_CharT, _Traits>:: | |
11888 | read(char_type* __s, streamsize __n) | |
11889 | { | |
11890 | _M_gcount = 0; | |
11891 | sentry __cerb(*this, true); | |
11892 | if (__cerb) | |
11893 | { | |
11894 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11895 | try | |
11896 | { | |
11897 | _M_gcount = this->rdbuf()->sgetn(__s, __n); | |
11898 | if (_M_gcount != __n) | |
11899 | __err |= (ios_base::eofbit | ios_base::failbit); | |
11900 | } | |
11901 | catch(__cxxabiv1::__forced_unwind&) | |
11902 | { | |
11903 | this->_M_setstate(ios_base::badbit); | |
11904 | throw; | |
11905 | } | |
11906 | catch(...) | |
11907 | { this->_M_setstate(ios_base::badbit); } | |
11908 | if (__err) | |
11909 | this->setstate(__err); | |
11910 | } | |
11911 | return *this; | |
11912 | } | |
11913 | template<typename _CharT, typename _Traits> | |
11914 | streamsize | |
11915 | basic_istream<_CharT, _Traits>:: | |
11916 | readsome(char_type* __s, streamsize __n) | |
11917 | { | |
11918 | _M_gcount = 0; | |
11919 | sentry __cerb(*this, true); | |
11920 | if (__cerb) | |
11921 | { | |
11922 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11923 | try | |
11924 | { | |
11925 | const streamsize __num = this->rdbuf()->in_avail(); | |
11926 | if (__num > 0) | |
11927 | _M_gcount = this->rdbuf()->sgetn(__s, std::min(__num, __n)); | |
11928 | else if (__num == -1) | |
11929 | __err |= ios_base::eofbit; | |
11930 | } | |
11931 | catch(__cxxabiv1::__forced_unwind&) | |
11932 | { | |
11933 | this->_M_setstate(ios_base::badbit); | |
11934 | throw; | |
11935 | } | |
11936 | catch(...) | |
11937 | { this->_M_setstate(ios_base::badbit); } | |
11938 | if (__err) | |
11939 | this->setstate(__err); | |
11940 | } | |
11941 | return _M_gcount; | |
11942 | } | |
11943 | template<typename _CharT, typename _Traits> | |
11944 | basic_istream<_CharT, _Traits>& | |
11945 | basic_istream<_CharT, _Traits>:: | |
11946 | putback(char_type __c) | |
11947 | { | |
11948 | _M_gcount = 0; | |
11949 | sentry __cerb(*this, true); | |
11950 | if (__cerb) | |
11951 | { | |
11952 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11953 | try | |
11954 | { | |
11955 | const int_type __eof = traits_type::eof(); | |
11956 | __streambuf_type* __sb = this->rdbuf(); | |
11957 | if (!__sb | |
11958 | || traits_type::eq_int_type(__sb->sputbackc(__c), __eof)) | |
11959 | __err |= ios_base::badbit; | |
11960 | } | |
11961 | catch(__cxxabiv1::__forced_unwind&) | |
11962 | { | |
11963 | this->_M_setstate(ios_base::badbit); | |
11964 | throw; | |
11965 | } | |
11966 | catch(...) | |
11967 | { this->_M_setstate(ios_base::badbit); } | |
11968 | if (__err) | |
11969 | this->setstate(__err); | |
11970 | } | |
11971 | return *this; | |
11972 | } | |
11973 | template<typename _CharT, typename _Traits> | |
11974 | basic_istream<_CharT, _Traits>& | |
11975 | basic_istream<_CharT, _Traits>:: | |
11976 | unget(void) | |
11977 | { | |
11978 | _M_gcount = 0; | |
11979 | sentry __cerb(*this, true); | |
11980 | if (__cerb) | |
11981 | { | |
11982 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
11983 | try | |
11984 | { | |
11985 | const int_type __eof = traits_type::eof(); | |
11986 | __streambuf_type* __sb = this->rdbuf(); | |
11987 | if (!__sb | |
11988 | || traits_type::eq_int_type(__sb->sungetc(), __eof)) | |
11989 | __err |= ios_base::badbit; | |
11990 | } | |
11991 | catch(__cxxabiv1::__forced_unwind&) | |
11992 | { | |
11993 | this->_M_setstate(ios_base::badbit); | |
11994 | throw; | |
11995 | } | |
11996 | catch(...) | |
11997 | { this->_M_setstate(ios_base::badbit); } | |
11998 | if (__err) | |
11999 | this->setstate(__err); | |
12000 | } | |
12001 | return *this; | |
12002 | } | |
12003 | template<typename _CharT, typename _Traits> | |
12004 | int | |
12005 | basic_istream<_CharT, _Traits>:: | |
12006 | sync(void) | |
12007 | { | |
12008 | int __ret = -1; | |
12009 | sentry __cerb(*this, true); | |
12010 | if (__cerb) | |
12011 | { | |
12012 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
12013 | try | |
12014 | { | |
12015 | __streambuf_type* __sb = this->rdbuf(); | |
12016 | if (__sb) | |
12017 | { | |
12018 | if (__sb->pubsync() == -1) | |
12019 | __err |= ios_base::badbit; | |
12020 | else | |
12021 | __ret = 0; | |
12022 | } | |
12023 | } | |
12024 | catch(__cxxabiv1::__forced_unwind&) | |
12025 | { | |
12026 | this->_M_setstate(ios_base::badbit); | |
12027 | throw; | |
12028 | } | |
12029 | catch(...) | |
12030 | { this->_M_setstate(ios_base::badbit); } | |
12031 | if (__err) | |
12032 | this->setstate(__err); | |
12033 | } | |
12034 | return __ret; | |
12035 | } | |
12036 | template<typename _CharT, typename _Traits> | |
12037 | typename basic_istream<_CharT, _Traits>::pos_type | |
12038 | basic_istream<_CharT, _Traits>:: | |
12039 | tellg(void) | |
12040 | { | |
12041 | pos_type __ret = pos_type(-1); | |
12042 | try | |
12043 | { | |
12044 | if (!this->fail()) | |
12045 | __ret = this->rdbuf()->pubseekoff(0, ios_base::cur, | |
12046 | ios_base::in); | |
12047 | } | |
12048 | catch(__cxxabiv1::__forced_unwind&) | |
12049 | { | |
12050 | this->_M_setstate(ios_base::badbit); | |
12051 | throw; | |
12052 | } | |
12053 | catch(...) | |
12054 | { this->_M_setstate(ios_base::badbit); } | |
12055 | return __ret; | |
12056 | } | |
12057 | template<typename _CharT, typename _Traits> | |
12058 | basic_istream<_CharT, _Traits>& | |
12059 | basic_istream<_CharT, _Traits>:: | |
12060 | seekg(pos_type __pos) | |
12061 | { | |
12062 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
12063 | try | |
12064 | { | |
12065 | if (!this->fail()) | |
12066 | { | |
12067 | const pos_type __p = this->rdbuf()->pubseekpos(__pos, | |
12068 | ios_base::in); | |
12069 | if (__p == pos_type(off_type(-1))) | |
12070 | __err |= ios_base::failbit; | |
12071 | } | |
12072 | } | |
12073 | catch(__cxxabiv1::__forced_unwind&) | |
12074 | { | |
12075 | this->_M_setstate(ios_base::badbit); | |
12076 | throw; | |
12077 | } | |
12078 | catch(...) | |
12079 | { this->_M_setstate(ios_base::badbit); } | |
12080 | if (__err) | |
12081 | this->setstate(__err); | |
12082 | return *this; | |
12083 | } | |
12084 | template<typename _CharT, typename _Traits> | |
12085 | basic_istream<_CharT, _Traits>& | |
12086 | basic_istream<_CharT, _Traits>:: | |
12087 | seekg(off_type __off, ios_base::seekdir __dir) | |
12088 | { | |
12089 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
12090 | try | |
12091 | { | |
12092 | if (!this->fail()) | |
12093 | { | |
12094 | const pos_type __p = this->rdbuf()->pubseekoff(__off, __dir, | |
12095 | ios_base::in); | |
12096 | if (__p == pos_type(off_type(-1))) | |
12097 | __err |= ios_base::failbit; | |
12098 | } | |
12099 | } | |
12100 | catch(__cxxabiv1::__forced_unwind&) | |
12101 | { | |
12102 | this->_M_setstate(ios_base::badbit); | |
12103 | throw; | |
12104 | } | |
12105 | catch(...) | |
12106 | { this->_M_setstate(ios_base::badbit); } | |
12107 | if (__err) | |
12108 | this->setstate(__err); | |
12109 | return *this; | |
12110 | } | |
12111 | template<typename _CharT, typename _Traits> | |
12112 | basic_istream<_CharT, _Traits>& | |
12113 | operator>>(basic_istream<_CharT, _Traits>& __in, _CharT& __c) | |
12114 | { | |
12115 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
12116 | typedef typename __istream_type::int_type __int_type; | |
12117 | typename __istream_type::sentry __cerb(__in, false); | |
12118 | if (__cerb) | |
12119 | { | |
12120 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
12121 | try | |
12122 | { | |
12123 | const __int_type __cb = __in.rdbuf()->sbumpc(); | |
12124 | if (!_Traits::eq_int_type(__cb, _Traits::eof())) | |
12125 | __c = _Traits::to_char_type(__cb); | |
12126 | else | |
12127 | __err |= (ios_base::eofbit | ios_base::failbit); | |
12128 | } | |
12129 | catch(__cxxabiv1::__forced_unwind&) | |
12130 | { | |
12131 | __in._M_setstate(ios_base::badbit); | |
12132 | throw; | |
12133 | } | |
12134 | catch(...) | |
12135 | { __in._M_setstate(ios_base::badbit); } | |
12136 | if (__err) | |
12137 | __in.setstate(__err); | |
12138 | } | |
12139 | return __in; | |
12140 | } | |
12141 | template<typename _CharT, typename _Traits> | |
12142 | basic_istream<_CharT, _Traits>& | |
12143 | operator>>(basic_istream<_CharT, _Traits>& __in, _CharT* __s) | |
12144 | { | |
12145 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
12146 | typedef basic_streambuf<_CharT, _Traits> __streambuf_type; | |
12147 | typedef typename _Traits::int_type int_type; | |
12148 | typedef _CharT char_type; | |
12149 | typedef ctype<_CharT> __ctype_type; | |
12150 | streamsize __extracted = 0; | |
12151 | ios_base::iostate __err = ios_base::iostate(ios_base::goodbit); | |
12152 | typename __istream_type::sentry __cerb(__in, false); | |
12153 | if (__cerb) | |
12154 | { | |
12155 | try | |
12156 | { | |
12157 | streamsize __num = __in.width(); | |
12158 | if (__num <= 0) | |
12159 | __num = __gnu_cxx::__numeric_traits<streamsize>::__max; | |
12160 | const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); | |
12161 | const int_type __eof = _Traits::eof(); | |
12162 | __streambuf_type* __sb = __in.rdbuf(); | |
12163 | int_type __c = __sb->sgetc(); | |
12164 | while (__extracted < __num - 1 | |
12165 | && !_Traits::eq_int_type(__c, __eof) | |
12166 | && !__ct.is(ctype_base::space, | |
12167 | _Traits::to_char_type(__c))) | |
12168 | { | |
12169 | *__s++ = _Traits::to_char_type(__c); | |
12170 | ++__extracted; | |
12171 | __c = __sb->snextc(); | |
12172 | } | |
12173 | if (_Traits::eq_int_type(__c, __eof)) | |
12174 | __err |= ios_base::eofbit; | |
12175 | *__s = char_type(); | |
12176 | __in.width(0); | |
12177 | } | |
12178 | catch(__cxxabiv1::__forced_unwind&) | |
12179 | { | |
12180 | __in._M_setstate(ios_base::badbit); | |
12181 | throw; | |
12182 | } | |
12183 | catch(...) | |
12184 | { __in._M_setstate(ios_base::badbit); } | |
12185 | } | |
12186 | if (!__extracted) | |
12187 | __err |= ios_base::failbit; | |
12188 | if (__err) | |
12189 | __in.setstate(__err); | |
12190 | return __in; | |
12191 | } | |
12192 | template<typename _CharT, typename _Traits> | |
12193 | basic_istream<_CharT, _Traits>& | |
12194 | ws(basic_istream<_CharT, _Traits>& __in) | |
12195 | { | |
12196 | typedef basic_istream<_CharT, _Traits> __istream_type; | |
12197 | typedef basic_streambuf<_CharT, _Traits> __streambuf_type; | |
12198 | typedef typename __istream_type::int_type __int_type; | |
12199 | typedef ctype<_CharT> __ctype_type; | |
12200 | const __ctype_type& __ct = use_facet<__ctype_type>(__in.getloc()); | |
12201 | const __int_type __eof = _Traits::eof(); | |
12202 | __streambuf_type* __sb = __in.rdbuf(); | |
12203 | __int_type __c = __sb->sgetc(); | |
12204 | while (!_Traits::eq_int_type(__c, __eof) | |
12205 | && __ct.is(ctype_base::space, _Traits::to_char_type(__c))) | |
12206 | __c = __sb->snextc(); | |
12207 | if (_Traits::eq_int_type(__c, __eof)) | |
12208 | __in.setstate(ios_base::eofbit); | |
12209 | return __in; | |
12210 | } | |
12211 | extern template class basic_istream<char>; | |
12212 | extern template istream& ws(istream&); | |
12213 | extern template istream& operator>>(istream&, char&); | |
12214 | extern template istream& operator>>(istream&, char*); | |
12215 | extern template istream& operator>>(istream&, unsigned char&); | |
12216 | extern template istream& operator>>(istream&, signed char&); | |
12217 | extern template istream& operator>>(istream&, unsigned char*); | |
12218 | extern template istream& operator>>(istream&, signed char*); | |
12219 | extern template istream& istream::_M_extract(unsigned short&); | |
12220 | extern template istream& istream::_M_extract(unsigned int&); | |
12221 | extern template istream& istream::_M_extract(long&); | |
12222 | extern template istream& istream::_M_extract(unsigned long&); | |
12223 | extern template istream& istream::_M_extract(bool&); | |
12224 | extern template istream& istream::_M_extract(long long&); | |
12225 | extern template istream& istream::_M_extract(unsigned long long&); | |
12226 | extern template istream& istream::_M_extract(float&); | |
12227 | extern template istream& istream::_M_extract(double&); | |
12228 | extern template istream& istream::_M_extract(long double&); | |
12229 | extern template istream& istream::_M_extract(void*&); | |
12230 | extern template class basic_iostream<char>; | |
12231 | } | |
12232 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
12233 | template<typename _Tp, typename _CharT = char, | |
12234 | typename _Traits = char_traits<_CharT>, typename _Dist = ptrdiff_t> | |
12235 | class istream_iterator | |
12236 | : public iterator<input_iterator_tag, _Tp, _Dist, const _Tp*, const _Tp&> | |
12237 | { | |
12238 | public: | |
12239 | typedef _CharT char_type; | |
12240 | typedef _Traits traits_type; | |
12241 | typedef basic_istream<_CharT, _Traits> istream_type; | |
12242 | private: | |
12243 | istream_type* _M_stream; | |
12244 | _Tp _M_value; | |
12245 | bool _M_ok; | |
12246 | public: | |
12247 | istream_iterator() | |
12248 | : _M_stream(0), _M_value(), _M_ok(false) {} | |
12249 | istream_iterator(istream_type& __s) | |
12250 | : _M_stream(&__s) | |
12251 | { _M_read(); } | |
12252 | istream_iterator(const istream_iterator& __obj) | |
12253 | : _M_stream(__obj._M_stream), _M_value(__obj._M_value), | |
12254 | _M_ok(__obj._M_ok) | |
12255 | { } | |
12256 | const _Tp& | |
12257 | operator*() const | |
12258 | { | |
12259 | ; | |
12260 | return _M_value; | |
12261 | } | |
12262 | const _Tp* | |
12263 | operator->() const { return &(operator*()); } | |
12264 | istream_iterator& | |
12265 | operator++() | |
12266 | { | |
12267 | ; | |
12268 | _M_read(); | |
12269 | return *this; | |
12270 | } | |
12271 | istream_iterator | |
12272 | operator++(int) | |
12273 | { | |
12274 | ; | |
12275 | istream_iterator __tmp = *this; | |
12276 | _M_read(); | |
12277 | return __tmp; | |
12278 | } | |
12279 | bool | |
12280 | _M_equal(const istream_iterator& __x) const | |
12281 | { return (_M_ok == __x._M_ok) && (!_M_ok || _M_stream == __x._M_stream); } | |
12282 | private: | |
12283 | void | |
12284 | _M_read() | |
12285 | { | |
12286 | _M_ok = (_M_stream && *_M_stream) ? true : false; | |
12287 | if (_M_ok) | |
12288 | { | |
12289 | *_M_stream >> _M_value; | |
12290 | _M_ok = *_M_stream ? true : false; | |
12291 | } | |
12292 | } | |
12293 | }; | |
12294 | template<typename _Tp, typename _CharT, typename _Traits, typename _Dist> | |
12295 | inline bool | |
12296 | operator==(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, | |
12297 | const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) | |
12298 | { return __x._M_equal(__y); } | |
12299 | template <class _Tp, class _CharT, class _Traits, class _Dist> | |
12300 | inline bool | |
12301 | operator!=(const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __x, | |
12302 | const istream_iterator<_Tp, _CharT, _Traits, _Dist>& __y) | |
12303 | { return !__x._M_equal(__y); } | |
12304 | template<typename _Tp, typename _CharT = char, | |
12305 | typename _Traits = char_traits<_CharT> > | |
12306 | class ostream_iterator | |
12307 | : public iterator<output_iterator_tag, void, void, void, void> | |
12308 | { | |
12309 | public: | |
12310 | typedef _CharT char_type; | |
12311 | typedef _Traits traits_type; | |
12312 | typedef basic_ostream<_CharT, _Traits> ostream_type; | |
12313 | private: | |
12314 | ostream_type* _M_stream; | |
12315 | const _CharT* _M_string; | |
12316 | public: | |
12317 | ostream_iterator(ostream_type& __s) : _M_stream(&__s), _M_string(0) {} | |
12318 | ostream_iterator(ostream_type& __s, const _CharT* __c) | |
12319 | : _M_stream(&__s), _M_string(__c) { } | |
12320 | ostream_iterator(const ostream_iterator& __obj) | |
12321 | : _M_stream(__obj._M_stream), _M_string(__obj._M_string) { } | |
12322 | ostream_iterator& | |
12323 | operator=(const _Tp& __value) | |
12324 | { | |
12325 | ; | |
12326 | *_M_stream << __value; | |
12327 | if (_M_string) *_M_stream << _M_string; | |
12328 | return *this; | |
12329 | } | |
12330 | ostream_iterator& | |
12331 | operator*() | |
12332 | { return *this; } | |
12333 | ostream_iterator& | |
12334 | operator++() | |
12335 | { return *this; } | |
12336 | ostream_iterator& | |
12337 | operator++(int) | |
12338 | { return *this; } | |
12339 | }; | |
12340 | } | |
12341 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
12342 | struct _List_node_base | |
12343 | { | |
12344 | _List_node_base* _M_next; | |
12345 | _List_node_base* _M_prev; | |
12346 | static void | |
12347 | swap(_List_node_base& __x, _List_node_base& __y); | |
12348 | void | |
12349 | transfer(_List_node_base * const __first, | |
12350 | _List_node_base * const __last); | |
12351 | void | |
12352 | reverse(); | |
12353 | void | |
12354 | hook(_List_node_base * const __position); | |
12355 | void | |
12356 | unhook(); | |
12357 | }; | |
12358 | template<typename _Tp> | |
12359 | struct _List_node : public _List_node_base | |
12360 | { | |
12361 | _Tp _M_data; | |
12362 | }; | |
12363 | template<typename _Tp> | |
12364 | struct _List_iterator | |
12365 | { | |
12366 | typedef _List_iterator<_Tp> _Self; | |
12367 | typedef _List_node<_Tp> _Node; | |
12368 | typedef ptrdiff_t difference_type; | |
12369 | typedef std::bidirectional_iterator_tag iterator_category; | |
12370 | typedef _Tp value_type; | |
12371 | typedef _Tp* pointer; | |
12372 | typedef _Tp& reference; | |
12373 | _List_iterator() | |
12374 | : _M_node() { } | |
12375 | explicit | |
12376 | _List_iterator(_List_node_base* __x) | |
12377 | : _M_node(__x) { } | |
12378 | reference | |
12379 | operator*() const | |
12380 | { return static_cast<_Node*>(_M_node)->_M_data; } | |
12381 | pointer | |
12382 | operator->() const | |
12383 | { return &static_cast<_Node*>(_M_node)->_M_data; } | |
12384 | _Self& | |
12385 | operator++() | |
12386 | { | |
12387 | _M_node = _M_node->_M_next; | |
12388 | return *this; | |
12389 | } | |
12390 | _Self | |
12391 | operator++(int) | |
12392 | { | |
12393 | _Self __tmp = *this; | |
12394 | _M_node = _M_node->_M_next; | |
12395 | return __tmp; | |
12396 | } | |
12397 | _Self& | |
12398 | operator--() | |
12399 | { | |
12400 | _M_node = _M_node->_M_prev; | |
12401 | return *this; | |
12402 | } | |
12403 | _Self | |
12404 | operator--(int) | |
12405 | { | |
12406 | _Self __tmp = *this; | |
12407 | _M_node = _M_node->_M_prev; | |
12408 | return __tmp; | |
12409 | } | |
12410 | bool | |
12411 | operator==(const _Self& __x) const | |
12412 | { return _M_node == __x._M_node; } | |
12413 | bool | |
12414 | operator!=(const _Self& __x) const | |
12415 | { return _M_node != __x._M_node; } | |
12416 | _List_node_base* _M_node; | |
12417 | }; | |
12418 | template<typename _Tp> | |
12419 | struct _List_const_iterator | |
12420 | { | |
12421 | typedef _List_const_iterator<_Tp> _Self; | |
12422 | typedef const _List_node<_Tp> _Node; | |
12423 | typedef _List_iterator<_Tp> iterator; | |
12424 | typedef ptrdiff_t difference_type; | |
12425 | typedef std::bidirectional_iterator_tag iterator_category; | |
12426 | typedef _Tp value_type; | |
12427 | typedef const _Tp* pointer; | |
12428 | typedef const _Tp& reference; | |
12429 | _List_const_iterator() | |
12430 | : _M_node() { } | |
12431 | explicit | |
12432 | _List_const_iterator(const _List_node_base* __x) | |
12433 | : _M_node(__x) { } | |
12434 | _List_const_iterator(const iterator& __x) | |
12435 | : _M_node(__x._M_node) { } | |
12436 | reference | |
12437 | operator*() const | |
12438 | { return static_cast<_Node*>(_M_node)->_M_data; } | |
12439 | pointer | |
12440 | operator->() const | |
12441 | { return &static_cast<_Node*>(_M_node)->_M_data; } | |
12442 | _Self& | |
12443 | operator++() | |
12444 | { | |
12445 | _M_node = _M_node->_M_next; | |
12446 | return *this; | |
12447 | } | |
12448 | _Self | |
12449 | operator++(int) | |
12450 | { | |
12451 | _Self __tmp = *this; | |
12452 | _M_node = _M_node->_M_next; | |
12453 | return __tmp; | |
12454 | } | |
12455 | _Self& | |
12456 | operator--() | |
12457 | { | |
12458 | _M_node = _M_node->_M_prev; | |
12459 | return *this; | |
12460 | } | |
12461 | _Self | |
12462 | operator--(int) | |
12463 | { | |
12464 | _Self __tmp = *this; | |
12465 | _M_node = _M_node->_M_prev; | |
12466 | return __tmp; | |
12467 | } | |
12468 | bool | |
12469 | operator==(const _Self& __x) const | |
12470 | { return _M_node == __x._M_node; } | |
12471 | bool | |
12472 | operator!=(const _Self& __x) const | |
12473 | { return _M_node != __x._M_node; } | |
12474 | const _List_node_base* _M_node; | |
12475 | }; | |
12476 | template<typename _Val> | |
12477 | inline bool | |
12478 | operator==(const _List_iterator<_Val>& __x, | |
12479 | const _List_const_iterator<_Val>& __y) | |
12480 | { return __x._M_node == __y._M_node; } | |
12481 | template<typename _Val> | |
12482 | inline bool | |
12483 | operator!=(const _List_iterator<_Val>& __x, | |
12484 | const _List_const_iterator<_Val>& __y) | |
12485 | { return __x._M_node != __y._M_node; } | |
12486 | template<typename _Tp, typename _Alloc> | |
12487 | class _List_base | |
12488 | { | |
12489 | protected: | |
12490 | typedef typename _Alloc::template rebind<_List_node<_Tp> >::other | |
12491 | _Node_alloc_type; | |
12492 | typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; | |
12493 | struct _List_impl | |
12494 | : public _Node_alloc_type | |
12495 | { | |
12496 | _List_node_base _M_node; | |
12497 | _List_impl() | |
12498 | : _Node_alloc_type(), _M_node() | |
12499 | { } | |
12500 | _List_impl(const _Node_alloc_type& __a) | |
12501 | : _Node_alloc_type(__a), _M_node() | |
12502 | { } | |
12503 | }; | |
12504 | _List_impl _M_impl; | |
12505 | _List_node<_Tp>* | |
12506 | _M_get_node() | |
12507 | { return _M_impl._Node_alloc_type::allocate(1); } | |
12508 | void | |
12509 | _M_put_node(_List_node<_Tp>* __p) | |
12510 | { _M_impl._Node_alloc_type::deallocate(__p, 1); } | |
12511 | public: | |
12512 | typedef _Alloc allocator_type; | |
12513 | _Node_alloc_type& | |
12514 | _M_get_Node_allocator() | |
12515 | { return *static_cast<_Node_alloc_type*>(&this->_M_impl); } | |
12516 | const _Node_alloc_type& | |
12517 | _M_get_Node_allocator() const | |
12518 | { return *static_cast<const _Node_alloc_type*>(&this->_M_impl); } | |
12519 | _Tp_alloc_type | |
12520 | _M_get_Tp_allocator() const | |
12521 | { return _Tp_alloc_type(_M_get_Node_allocator()); } | |
12522 | allocator_type | |
12523 | get_allocator() const | |
12524 | { return allocator_type(_M_get_Node_allocator()); } | |
12525 | _List_base() | |
12526 | : _M_impl() | |
12527 | { _M_init(); } | |
12528 | _List_base(const allocator_type& __a) | |
12529 | : _M_impl(__a) | |
12530 | { _M_init(); } | |
12531 | ~_List_base() | |
12532 | { _M_clear(); } | |
12533 | void | |
12534 | _M_clear(); | |
12535 | void | |
12536 | _M_init() | |
12537 | { | |
12538 | this->_M_impl._M_node._M_next = &this->_M_impl._M_node; | |
12539 | this->_M_impl._M_node._M_prev = &this->_M_impl._M_node; | |
12540 | } | |
12541 | }; | |
12542 | template<typename _Tp, typename _Alloc = std::allocator<_Tp> > | |
12543 | class list : protected _List_base<_Tp, _Alloc> | |
12544 | { | |
12545 | typedef typename _Alloc::value_type _Alloc_value_type; | |
12546 | typedef _List_base<_Tp, _Alloc> _Base; | |
12547 | typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; | |
12548 | public: | |
12549 | typedef _Tp value_type; | |
12550 | typedef typename _Tp_alloc_type::pointer pointer; | |
12551 | typedef typename _Tp_alloc_type::const_pointer const_pointer; | |
12552 | typedef typename _Tp_alloc_type::reference reference; | |
12553 | typedef typename _Tp_alloc_type::const_reference const_reference; | |
12554 | typedef _List_iterator<_Tp> iterator; | |
12555 | typedef _List_const_iterator<_Tp> const_iterator; | |
12556 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
12557 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
12558 | typedef size_t size_type; | |
12559 | typedef ptrdiff_t difference_type; | |
12560 | typedef _Alloc allocator_type; | |
12561 | protected: | |
12562 | typedef _List_node<_Tp> _Node; | |
12563 | using _Base::_M_impl; | |
12564 | using _Base::_M_put_node; | |
12565 | using _Base::_M_get_node; | |
12566 | using _Base::_M_get_Tp_allocator; | |
12567 | using _Base::_M_get_Node_allocator; | |
12568 | _Node* | |
12569 | _M_create_node(const value_type& __x) | |
12570 | { | |
12571 | _Node* __p = this->_M_get_node(); | |
12572 | try | |
12573 | { | |
12574 | _M_get_Tp_allocator().construct(&__p->_M_data, __x); | |
12575 | } | |
12576 | catch(...) | |
12577 | { | |
12578 | _M_put_node(__p); | |
12579 | throw; | |
12580 | } | |
12581 | return __p; | |
12582 | } | |
12583 | public: | |
12584 | list() | |
12585 | : _Base() { } | |
12586 | explicit | |
12587 | list(const allocator_type& __a) | |
12588 | : _Base(__a) { } | |
12589 | explicit | |
12590 | list(size_type __n, const value_type& __value = value_type(), | |
12591 | const allocator_type& __a = allocator_type()) | |
12592 | : _Base(__a) | |
12593 | { _M_fill_initialize(__n, __value); } | |
12594 | list(const list& __x) | |
12595 | : _Base(__x._M_get_Node_allocator()) | |
12596 | { _M_initialize_dispatch(__x.begin(), __x.end(), __false_type()); } | |
12597 | template<typename _InputIterator> | |
12598 | list(_InputIterator __first, _InputIterator __last, | |
12599 | const allocator_type& __a = allocator_type()) | |
12600 | : _Base(__a) | |
12601 | { | |
12602 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
12603 | _M_initialize_dispatch(__first, __last, _Integral()); | |
12604 | } | |
12605 | list& | |
12606 | operator=(const list& __x); | |
12607 | void | |
12608 | assign(size_type __n, const value_type& __val) | |
12609 | { _M_fill_assign(__n, __val); } | |
12610 | template<typename _InputIterator> | |
12611 | void | |
12612 | assign(_InputIterator __first, _InputIterator __last) | |
12613 | { | |
12614 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
12615 | _M_assign_dispatch(__first, __last, _Integral()); | |
12616 | } | |
12617 | allocator_type | |
12618 | get_allocator() const | |
12619 | { return _Base::get_allocator(); } | |
12620 | iterator | |
12621 | begin() | |
12622 | { return iterator(this->_M_impl._M_node._M_next); } | |
12623 | const_iterator | |
12624 | begin() const | |
12625 | { return const_iterator(this->_M_impl._M_node._M_next); } | |
12626 | iterator | |
12627 | end() | |
12628 | { return iterator(&this->_M_impl._M_node); } | |
12629 | const_iterator | |
12630 | end() const | |
12631 | { return const_iterator(&this->_M_impl._M_node); } | |
12632 | reverse_iterator | |
12633 | rbegin() | |
12634 | { return reverse_iterator(end()); } | |
12635 | const_reverse_iterator | |
12636 | rbegin() const | |
12637 | { return const_reverse_iterator(end()); } | |
12638 | reverse_iterator | |
12639 | rend() | |
12640 | { return reverse_iterator(begin()); } | |
12641 | const_reverse_iterator | |
12642 | rend() const | |
12643 | { return const_reverse_iterator(begin()); } | |
12644 | bool | |
12645 | empty() const | |
12646 | { return this->_M_impl._M_node._M_next == &this->_M_impl._M_node; } | |
12647 | size_type | |
12648 | size() const | |
12649 | { return std::distance(begin(), end()); } | |
12650 | size_type | |
12651 | max_size() const | |
12652 | { return _M_get_Tp_allocator().max_size(); } | |
12653 | void | |
12654 | resize(size_type __new_size, value_type __x = value_type()); | |
12655 | reference | |
12656 | front() | |
12657 | { return *begin(); } | |
12658 | const_reference | |
12659 | front() const | |
12660 | { return *begin(); } | |
12661 | reference | |
12662 | back() | |
12663 | { | |
12664 | iterator __tmp = end(); | |
12665 | --__tmp; | |
12666 | return *__tmp; | |
12667 | } | |
12668 | const_reference | |
12669 | back() const | |
12670 | { | |
12671 | const_iterator __tmp = end(); | |
12672 | --__tmp; | |
12673 | return *__tmp; | |
12674 | } | |
12675 | void | |
12676 | push_front(const value_type& __x) | |
12677 | { this->_M_insert(begin(), __x); } | |
12678 | void | |
12679 | pop_front() | |
12680 | { this->_M_erase(begin()); } | |
12681 | void | |
12682 | push_back(const value_type& __x) | |
12683 | { this->_M_insert(end(), __x); } | |
12684 | void | |
12685 | pop_back() | |
12686 | { this->_M_erase(iterator(this->_M_impl._M_node._M_prev)); } | |
12687 | iterator | |
12688 | insert(iterator __position, const value_type& __x); | |
12689 | void | |
12690 | insert(iterator __position, size_type __n, const value_type& __x) | |
12691 | { | |
12692 | list __tmp(__n, __x, _M_get_Node_allocator()); | |
12693 | splice(__position, __tmp); | |
12694 | } | |
12695 | template<typename _InputIterator> | |
12696 | void | |
12697 | insert(iterator __position, _InputIterator __first, | |
12698 | _InputIterator __last) | |
12699 | { | |
12700 | list __tmp(__first, __last, _M_get_Node_allocator()); | |
12701 | splice(__position, __tmp); | |
12702 | } | |
12703 | iterator | |
12704 | erase(iterator __position); | |
12705 | iterator | |
12706 | erase(iterator __first, iterator __last) | |
12707 | { | |
12708 | while (__first != __last) | |
12709 | __first = erase(__first); | |
12710 | return __last; | |
12711 | } | |
12712 | void | |
12713 | swap(list& __x) | |
12714 | { | |
12715 | _List_node_base::swap(this->_M_impl._M_node, __x._M_impl._M_node); | |
12716 | std::__alloc_swap<typename _Base::_Node_alloc_type>:: | |
12717 | _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator()); | |
12718 | } | |
12719 | void | |
12720 | clear() | |
12721 | { | |
12722 | _Base::_M_clear(); | |
12723 | _Base::_M_init(); | |
12724 | } | |
12725 | void | |
12726 | splice(iterator __position, list& __x) | |
12727 | { | |
12728 | if (!__x.empty()) | |
12729 | { | |
12730 | _M_check_equal_allocators(__x); | |
12731 | this->_M_transfer(__position, __x.begin(), __x.end()); | |
12732 | } | |
12733 | } | |
12734 | void | |
12735 | splice(iterator __position, list& __x, iterator __i) | |
12736 | { | |
12737 | iterator __j = __i; | |
12738 | ++__j; | |
12739 | if (__position == __i || __position == __j) | |
12740 | return; | |
12741 | if (this != &__x) | |
12742 | _M_check_equal_allocators(__x); | |
12743 | this->_M_transfer(__position, __i, __j); | |
12744 | } | |
12745 | void | |
12746 | splice(iterator __position, list& __x, iterator __first, | |
12747 | iterator __last) | |
12748 | { | |
12749 | if (__first != __last) | |
12750 | { | |
12751 | if (this != &__x) | |
12752 | _M_check_equal_allocators(__x); | |
12753 | this->_M_transfer(__position, __first, __last); | |
12754 | } | |
12755 | } | |
12756 | void | |
12757 | remove(const _Tp& __value); | |
12758 | template<typename _Predicate> | |
12759 | void | |
12760 | remove_if(_Predicate); | |
12761 | void | |
12762 | unique(); | |
12763 | template<typename _BinaryPredicate> | |
12764 | void | |
12765 | unique(_BinaryPredicate); | |
12766 | void | |
12767 | merge(list& __x); | |
12768 | template<typename _StrictWeakOrdering> | |
12769 | void | |
12770 | merge(list&, _StrictWeakOrdering); | |
12771 | void | |
12772 | reverse() | |
12773 | { this->_M_impl._M_node.reverse(); } | |
12774 | void | |
12775 | sort(); | |
12776 | template<typename _StrictWeakOrdering> | |
12777 | void | |
12778 | sort(_StrictWeakOrdering); | |
12779 | protected: | |
12780 | template<typename _Integer> | |
12781 | void | |
12782 | _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) | |
12783 | { _M_fill_initialize(static_cast<size_type>(__n), __x); } | |
12784 | template<typename _InputIterator> | |
12785 | void | |
12786 | _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
12787 | __false_type) | |
12788 | { | |
12789 | for (; __first != __last; ++__first) | |
12790 | push_back(*__first); | |
12791 | } | |
12792 | void | |
12793 | _M_fill_initialize(size_type __n, const value_type& __x) | |
12794 | { | |
12795 | for (; __n > 0; --__n) | |
12796 | push_back(__x); | |
12797 | } | |
12798 | template<typename _Integer> | |
12799 | void | |
12800 | _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
12801 | { _M_fill_assign(__n, __val); } | |
12802 | template<typename _InputIterator> | |
12803 | void | |
12804 | _M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
12805 | __false_type); | |
12806 | void | |
12807 | _M_fill_assign(size_type __n, const value_type& __val); | |
12808 | void | |
12809 | _M_transfer(iterator __position, iterator __first, iterator __last) | |
12810 | { __position._M_node->transfer(__first._M_node, __last._M_node); } | |
12811 | void | |
12812 | _M_insert(iterator __position, const value_type& __x) | |
12813 | { | |
12814 | _Node* __tmp = _M_create_node(__x); | |
12815 | __tmp->hook(__position._M_node); | |
12816 | } | |
12817 | void | |
12818 | _M_erase(iterator __position) | |
12819 | { | |
12820 | __position._M_node->unhook(); | |
12821 | _Node* __n = static_cast<_Node*>(__position._M_node); | |
12822 | _M_get_Tp_allocator().destroy(&__n->_M_data); | |
12823 | _M_put_node(__n); | |
12824 | } | |
12825 | void | |
12826 | _M_check_equal_allocators(list& __x) | |
12827 | { | |
12828 | if (std::__alloc_neq<typename _Base::_Node_alloc_type>:: | |
12829 | _S_do_it(_M_get_Node_allocator(), __x._M_get_Node_allocator())) | |
12830 | __throw_runtime_error(("list::_M_check_equal_allocators")); | |
12831 | } | |
12832 | }; | |
12833 | template<typename _Tp, typename _Alloc> | |
12834 | inline bool | |
12835 | operator==(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
12836 | { | |
12837 | typedef typename list<_Tp, _Alloc>::const_iterator const_iterator; | |
12838 | const_iterator __end1 = __x.end(); | |
12839 | const_iterator __end2 = __y.end(); | |
12840 | const_iterator __i1 = __x.begin(); | |
12841 | const_iterator __i2 = __y.begin(); | |
12842 | while (__i1 != __end1 && __i2 != __end2 && *__i1 == *__i2) | |
12843 | { | |
12844 | ++__i1; | |
12845 | ++__i2; | |
12846 | } | |
12847 | return __i1 == __end1 && __i2 == __end2; | |
12848 | } | |
12849 | template<typename _Tp, typename _Alloc> | |
12850 | inline bool | |
12851 | operator<(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
12852 | { return std::lexicographical_compare(__x.begin(), __x.end(), | |
12853 | __y.begin(), __y.end()); } | |
12854 | template<typename _Tp, typename _Alloc> | |
12855 | inline bool | |
12856 | operator!=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
12857 | { return !(__x == __y); } | |
12858 | template<typename _Tp, typename _Alloc> | |
12859 | inline bool | |
12860 | operator>(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
12861 | { return __y < __x; } | |
12862 | template<typename _Tp, typename _Alloc> | |
12863 | inline bool | |
12864 | operator<=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
12865 | { return !(__y < __x); } | |
12866 | template<typename _Tp, typename _Alloc> | |
12867 | inline bool | |
12868 | operator>=(const list<_Tp, _Alloc>& __x, const list<_Tp, _Alloc>& __y) | |
12869 | { return !(__x < __y); } | |
12870 | template<typename _Tp, typename _Alloc> | |
12871 | inline void | |
12872 | swap(list<_Tp, _Alloc>& __x, list<_Tp, _Alloc>& __y) | |
12873 | { __x.swap(__y); } | |
12874 | } | |
12875 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
12876 | template<typename _Tp, typename _Alloc> | |
12877 | void | |
12878 | _List_base<_Tp, _Alloc>:: | |
12879 | _M_clear() | |
12880 | { | |
12881 | typedef _List_node<_Tp> _Node; | |
12882 | _Node* __cur = static_cast<_Node*>(this->_M_impl._M_node._M_next); | |
12883 | while (__cur != &this->_M_impl._M_node) | |
12884 | { | |
12885 | _Node* __tmp = __cur; | |
12886 | __cur = static_cast<_Node*>(__cur->_M_next); | |
12887 | _M_get_Tp_allocator().destroy(&__tmp->_M_data); | |
12888 | _M_put_node(__tmp); | |
12889 | } | |
12890 | } | |
12891 | template<typename _Tp, typename _Alloc> | |
12892 | typename list<_Tp, _Alloc>::iterator | |
12893 | list<_Tp, _Alloc>:: | |
12894 | insert(iterator __position, const value_type& __x) | |
12895 | { | |
12896 | _Node* __tmp = _M_create_node(__x); | |
12897 | __tmp->hook(__position._M_node); | |
12898 | return iterator(__tmp); | |
12899 | } | |
12900 | template<typename _Tp, typename _Alloc> | |
12901 | typename list<_Tp, _Alloc>::iterator | |
12902 | list<_Tp, _Alloc>:: | |
12903 | erase(iterator __position) | |
12904 | { | |
12905 | iterator __ret = iterator(__position._M_node->_M_next); | |
12906 | _M_erase(__position); | |
12907 | return __ret; | |
12908 | } | |
12909 | template<typename _Tp, typename _Alloc> | |
12910 | void | |
12911 | list<_Tp, _Alloc>:: | |
12912 | resize(size_type __new_size, value_type __x) | |
12913 | { | |
12914 | iterator __i = begin(); | |
12915 | size_type __len = 0; | |
12916 | for (; __i != end() && __len < __new_size; ++__i, ++__len) | |
12917 | ; | |
12918 | if (__len == __new_size) | |
12919 | erase(__i, end()); | |
12920 | else | |
12921 | insert(end(), __new_size - __len, __x); | |
12922 | } | |
12923 | template<typename _Tp, typename _Alloc> | |
12924 | list<_Tp, _Alloc>& | |
12925 | list<_Tp, _Alloc>:: | |
12926 | operator=(const list& __x) | |
12927 | { | |
12928 | if (this != &__x) | |
12929 | { | |
12930 | iterator __first1 = begin(); | |
12931 | iterator __last1 = end(); | |
12932 | const_iterator __first2 = __x.begin(); | |
12933 | const_iterator __last2 = __x.end(); | |
12934 | for (; __first1 != __last1 && __first2 != __last2; | |
12935 | ++__first1, ++__first2) | |
12936 | *__first1 = *__first2; | |
12937 | if (__first2 == __last2) | |
12938 | erase(__first1, __last1); | |
12939 | else | |
12940 | insert(__last1, __first2, __last2); | |
12941 | } | |
12942 | return *this; | |
12943 | } | |
12944 | template<typename _Tp, typename _Alloc> | |
12945 | void | |
12946 | list<_Tp, _Alloc>:: | |
12947 | _M_fill_assign(size_type __n, const value_type& __val) | |
12948 | { | |
12949 | iterator __i = begin(); | |
12950 | for (; __i != end() && __n > 0; ++__i, --__n) | |
12951 | *__i = __val; | |
12952 | if (__n > 0) | |
12953 | insert(end(), __n, __val); | |
12954 | else | |
12955 | erase(__i, end()); | |
12956 | } | |
12957 | template<typename _Tp, typename _Alloc> | |
12958 | template <typename _InputIterator> | |
12959 | void | |
12960 | list<_Tp, _Alloc>:: | |
12961 | _M_assign_dispatch(_InputIterator __first2, _InputIterator __last2, | |
12962 | __false_type) | |
12963 | { | |
12964 | iterator __first1 = begin(); | |
12965 | iterator __last1 = end(); | |
12966 | for (; __first1 != __last1 && __first2 != __last2; | |
12967 | ++__first1, ++__first2) | |
12968 | *__first1 = *__first2; | |
12969 | if (__first2 == __last2) | |
12970 | erase(__first1, __last1); | |
12971 | else | |
12972 | insert(__last1, __first2, __last2); | |
12973 | } | |
12974 | template<typename _Tp, typename _Alloc> | |
12975 | void | |
12976 | list<_Tp, _Alloc>:: | |
12977 | remove(const value_type& __value) | |
12978 | { | |
12979 | iterator __first = begin(); | |
12980 | iterator __last = end(); | |
12981 | iterator __extra = __last; | |
12982 | while (__first != __last) | |
12983 | { | |
12984 | iterator __next = __first; | |
12985 | ++__next; | |
12986 | if (*__first == __value) | |
12987 | { | |
12988 | if (&*__first != &__value) | |
12989 | _M_erase(__first); | |
12990 | else | |
12991 | __extra = __first; | |
12992 | } | |
12993 | __first = __next; | |
12994 | } | |
12995 | if (__extra != __last) | |
12996 | _M_erase(__extra); | |
12997 | } | |
12998 | template<typename _Tp, typename _Alloc> | |
12999 | void | |
13000 | list<_Tp, _Alloc>:: | |
13001 | unique() | |
13002 | { | |
13003 | iterator __first = begin(); | |
13004 | iterator __last = end(); | |
13005 | if (__first == __last) | |
13006 | return; | |
13007 | iterator __next = __first; | |
13008 | while (++__next != __last) | |
13009 | { | |
13010 | if (*__first == *__next) | |
13011 | _M_erase(__next); | |
13012 | else | |
13013 | __first = __next; | |
13014 | __next = __first; | |
13015 | } | |
13016 | } | |
13017 | template<typename _Tp, typename _Alloc> | |
13018 | void | |
13019 | list<_Tp, _Alloc>:: | |
13020 | merge(list& __x) | |
13021 | { | |
13022 | if (this != &__x) | |
13023 | { | |
13024 | _M_check_equal_allocators(__x); | |
13025 | iterator __first1 = begin(); | |
13026 | iterator __last1 = end(); | |
13027 | iterator __first2 = __x.begin(); | |
13028 | iterator __last2 = __x.end(); | |
13029 | while (__first1 != __last1 && __first2 != __last2) | |
13030 | if (*__first2 < *__first1) | |
13031 | { | |
13032 | iterator __next = __first2; | |
13033 | _M_transfer(__first1, __first2, ++__next); | |
13034 | __first2 = __next; | |
13035 | } | |
13036 | else | |
13037 | ++__first1; | |
13038 | if (__first2 != __last2) | |
13039 | _M_transfer(__last1, __first2, __last2); | |
13040 | } | |
13041 | } | |
13042 | template<typename _Tp, typename _Alloc> | |
13043 | template <typename _StrictWeakOrdering> | |
13044 | void | |
13045 | list<_Tp, _Alloc>:: | |
13046 | merge(list& __x, _StrictWeakOrdering __comp) | |
13047 | { | |
13048 | if (this != &__x) | |
13049 | { | |
13050 | _M_check_equal_allocators(__x); | |
13051 | iterator __first1 = begin(); | |
13052 | iterator __last1 = end(); | |
13053 | iterator __first2 = __x.begin(); | |
13054 | iterator __last2 = __x.end(); | |
13055 | while (__first1 != __last1 && __first2 != __last2) | |
13056 | if (__comp(*__first2, *__first1)) | |
13057 | { | |
13058 | iterator __next = __first2; | |
13059 | _M_transfer(__first1, __first2, ++__next); | |
13060 | __first2 = __next; | |
13061 | } | |
13062 | else | |
13063 | ++__first1; | |
13064 | if (__first2 != __last2) | |
13065 | _M_transfer(__last1, __first2, __last2); | |
13066 | } | |
13067 | } | |
13068 | template<typename _Tp, typename _Alloc> | |
13069 | void | |
13070 | list<_Tp, _Alloc>:: | |
13071 | sort() | |
13072 | { | |
13073 | if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node | |
13074 | && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) | |
13075 | { | |
13076 | list __carry; | |
13077 | list __tmp[64]; | |
13078 | list * __fill = &__tmp[0]; | |
13079 | list * __counter; | |
13080 | do | |
13081 | { | |
13082 | __carry.splice(__carry.begin(), *this, begin()); | |
13083 | for(__counter = &__tmp[0]; | |
13084 | __counter != __fill && !__counter->empty(); | |
13085 | ++__counter) | |
13086 | { | |
13087 | __counter->merge(__carry); | |
13088 | __carry.swap(*__counter); | |
13089 | } | |
13090 | __carry.swap(*__counter); | |
13091 | if (__counter == __fill) | |
13092 | ++__fill; | |
13093 | } | |
13094 | while ( !empty() ); | |
13095 | for (__counter = &__tmp[1]; __counter != __fill; ++__counter) | |
13096 | __counter->merge(*(__counter - 1)); | |
13097 | swap( *(__fill - 1) ); | |
13098 | } | |
13099 | } | |
13100 | template<typename _Tp, typename _Alloc> | |
13101 | template <typename _Predicate> | |
13102 | void | |
13103 | list<_Tp, _Alloc>:: | |
13104 | remove_if(_Predicate __pred) | |
13105 | { | |
13106 | iterator __first = begin(); | |
13107 | iterator __last = end(); | |
13108 | while (__first != __last) | |
13109 | { | |
13110 | iterator __next = __first; | |
13111 | ++__next; | |
13112 | if (__pred(*__first)) | |
13113 | _M_erase(__first); | |
13114 | __first = __next; | |
13115 | } | |
13116 | } | |
13117 | template<typename _Tp, typename _Alloc> | |
13118 | template <typename _BinaryPredicate> | |
13119 | void | |
13120 | list<_Tp, _Alloc>:: | |
13121 | unique(_BinaryPredicate __binary_pred) | |
13122 | { | |
13123 | iterator __first = begin(); | |
13124 | iterator __last = end(); | |
13125 | if (__first == __last) | |
13126 | return; | |
13127 | iterator __next = __first; | |
13128 | while (++__next != __last) | |
13129 | { | |
13130 | if (__binary_pred(*__first, *__next)) | |
13131 | _M_erase(__next); | |
13132 | else | |
13133 | __first = __next; | |
13134 | __next = __first; | |
13135 | } | |
13136 | } | |
13137 | template<typename _Tp, typename _Alloc> | |
13138 | template <typename _StrictWeakOrdering> | |
13139 | void | |
13140 | list<_Tp, _Alloc>:: | |
13141 | sort(_StrictWeakOrdering __comp) | |
13142 | { | |
13143 | if (this->_M_impl._M_node._M_next != &this->_M_impl._M_node | |
13144 | && this->_M_impl._M_node._M_next->_M_next != &this->_M_impl._M_node) | |
13145 | { | |
13146 | list __carry; | |
13147 | list __tmp[64]; | |
13148 | list * __fill = &__tmp[0]; | |
13149 | list * __counter; | |
13150 | do | |
13151 | { | |
13152 | __carry.splice(__carry.begin(), *this, begin()); | |
13153 | for(__counter = &__tmp[0]; | |
13154 | __counter != __fill && !__counter->empty(); | |
13155 | ++__counter) | |
13156 | { | |
13157 | __counter->merge(__carry, __comp); | |
13158 | __carry.swap(*__counter); | |
13159 | } | |
13160 | __carry.swap(*__counter); | |
13161 | if (__counter == __fill) | |
13162 | ++__fill; | |
13163 | } | |
13164 | while ( !empty() ); | |
13165 | for (__counter = &__tmp[1]; __counter != __fill; ++__counter) | |
13166 | __counter->merge(*(__counter - 1), __comp); | |
13167 | swap(*(__fill - 1)); | |
13168 | } | |
13169 | } | |
13170 | } | |
13171 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
13172 | template <typename T> class QVector; | |
13173 | template <typename T> class QSet; | |
13174 | struct __attribute__((visibility("default"))) QListData { | |
13175 | struct Data { | |
13176 | QBasicAtomicInt ref; | |
13177 | int alloc, begin, end; | |
13178 | uint sharable : 1; | |
13179 | void *array[1]; | |
13180 | }; | |
13181 | enum { DataHeaderSize = sizeof(Data) - sizeof(void *) }; | |
13182 | Data *detach(); | |
13183 | Data *detach2(); | |
13184 | void realloc(int alloc); | |
13185 | static Data shared_null; | |
13186 | Data *d; | |
13187 | void **erase(void **xi); | |
13188 | void **append(); | |
13189 | void **append(const QListData &l); | |
13190 | void **prepend(); | |
13191 | void **insert(int i); | |
13192 | void remove(int i); | |
13193 | void remove(int i, int n); | |
13194 | void move(int from, int to); | |
13195 | inline int size() const { return d->end - d->begin; } | |
13196 | inline bool isEmpty() const { return d->end == d->begin; } | |
13197 | inline void **at(int i) const { return d->array + d->begin + i; } | |
13198 | inline void **begin() const { return d->array + d->begin; } | |
13199 | inline void **end() const { return d->array + d->end; } | |
13200 | }; | |
13201 | template <typename T> | |
13202 | class QList | |
13203 | { | |
13204 | struct Node { void *v; | |
13205 | inline T &t() | |
13206 | { return *reinterpret_cast<T*>(QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic | |
13207 | ? v : this); } | |
13208 | }; | |
13209 | union { QListData p; QListData::Data *d; }; | |
13210 | public: | |
13211 | inline QList() : d(&QListData::shared_null) { d->ref.ref(); } | |
13212 | inline QList(const QList<T> &l) : d(l.d) { d->ref.ref(); if (!d->sharable) detach_helper(); } | |
13213 | ~QList(); | |
13214 | QList<T> &operator=(const QList<T> &l); | |
13215 | bool operator==(const QList<T> &l) const; | |
13216 | inline bool operator!=(const QList<T> &l) const { return !(*this == l); } | |
13217 | inline int size() const { return p.size(); } | |
13218 | inline void detach() { if (d->ref != 1) detach_helper(); } | |
13219 | inline bool isDetached() const { return d->ref == 1; } | |
13220 | inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } | |
13221 | inline bool isEmpty() const { return p.isEmpty(); } | |
13222 | void clear(); | |
13223 | const T &at(int i) const; | |
13224 | const T &operator[](int i) const; | |
13225 | T &operator[](int i); | |
13226 | void append(const T &t); | |
13227 | void append(const QList<T> &t); | |
13228 | void prepend(const T &t); | |
13229 | void insert(int i, const T &t); | |
13230 | void replace(int i, const T &t); | |
13231 | void removeAt(int i); | |
13232 | int removeAll(const T &t); | |
13233 | bool removeOne(const T &t); | |
13234 | T takeAt(int i); | |
13235 | T takeFirst(); | |
13236 | T takeLast(); | |
13237 | void move(int from, int to); | |
13238 | void swap(int i, int j); | |
13239 | int indexOf(const T &t, int from = 0) const; | |
13240 | int lastIndexOf(const T &t, int from = -1) const; | |
13241 | QBool contains(const T &t) const; | |
13242 | int count(const T &t) const; | |
13243 | class const_iterator; | |
13244 | class iterator { | |
13245 | public: | |
13246 | Node *i; | |
13247 | typedef std::random_access_iterator_tag iterator_category; | |
13248 | typedef ptrdiff_t difference_type; | |
13249 | typedef T value_type; | |
13250 | typedef T *pointer; | |
13251 | typedef T &reference; | |
13252 | inline iterator() : i(0) {} | |
13253 | inline iterator(Node *n) : i(n) {} | |
13254 | inline iterator(const iterator &o): i(o.i){} | |
13255 | inline T &operator*() const { return i->t(); } | |
13256 | inline T *operator->() const { return &i->t(); } | |
13257 | inline T &operator[](int j) const { return i[j].t(); } | |
13258 | inline bool operator==(const iterator &o) const { return i == o.i; } | |
13259 | inline bool operator!=(const iterator &o) const { return i != o.i; } | |
13260 | inline bool operator<(const iterator& other) const { return i < other.i; } | |
13261 | inline bool operator<=(const iterator& other) const { return i <= other.i; } | |
13262 | inline bool operator>(const iterator& other) const { return i > other.i; } | |
13263 | inline bool operator>=(const iterator& other) const { return i >= other.i; } | |
13264 | inline bool operator==(const const_iterator &o) const | |
13265 | { return i == o.i; } | |
13266 | inline bool operator!=(const const_iterator &o) const | |
13267 | { return i != o.i; } | |
13268 | inline bool operator<(const const_iterator& other) const | |
13269 | { return i < other.i; } | |
13270 | inline bool operator<=(const const_iterator& other) const | |
13271 | { return i <= other.i; } | |
13272 | inline bool operator>(const const_iterator& other) const | |
13273 | { return i > other.i; } | |
13274 | inline bool operator>=(const const_iterator& other) const | |
13275 | { return i >= other.i; } | |
13276 | inline iterator &operator++() { ++i; return *this; } | |
13277 | inline iterator operator++(int) { Node *n = i; ++i; return n; } | |
13278 | inline iterator &operator--() { i--; return *this; } | |
13279 | inline iterator operator--(int) { Node *n = i; i--; return n; } | |
13280 | inline iterator &operator+=(int j) { i+=j; return *this; } | |
13281 | inline iterator &operator-=(int j) { i-=j; return *this; } | |
13282 | inline iterator operator+(int j) const { return iterator(i+j); } | |
13283 | inline iterator operator-(int j) const { return iterator(i-j); } | |
13284 | inline int operator-(iterator j) const { return i - j.i; } | |
13285 | }; | |
13286 | friend class iterator; | |
13287 | class const_iterator { | |
13288 | public: | |
13289 | Node *i; | |
13290 | typedef std::random_access_iterator_tag iterator_category; | |
13291 | typedef ptrdiff_t difference_type; | |
13292 | typedef T value_type; | |
13293 | typedef const T *pointer; | |
13294 | typedef const T &reference; | |
13295 | inline const_iterator() : i(0) {} | |
13296 | inline const_iterator(Node *n) : i(n) {} | |
13297 | inline const_iterator(const const_iterator &o): i(o.i) {} | |
13298 | inline const_iterator(const iterator &o): i(o.i) {} | |
13299 | inline const T &operator*() const { return i->t(); } | |
13300 | inline const T *operator->() const { return &i->t(); } | |
13301 | inline const T &operator[](int j) const { return i[j].t(); } | |
13302 | inline bool operator==(const const_iterator &o) const { return i == o.i; } | |
13303 | inline bool operator!=(const const_iterator &o) const { return i != o.i; } | |
13304 | inline bool operator<(const const_iterator& other) const { return i < other.i; } | |
13305 | inline bool operator<=(const const_iterator& other) const { return i <= other.i; } | |
13306 | inline bool operator>(const const_iterator& other) const { return i > other.i; } | |
13307 | inline bool operator>=(const const_iterator& other) const { return i >= other.i; } | |
13308 | inline const_iterator &operator++() { ++i; return *this; } | |
13309 | inline const_iterator operator++(int) { Node *n = i; ++i; return n; } | |
13310 | inline const_iterator &operator--() { i--; return *this; } | |
13311 | inline const_iterator operator--(int) { Node *n = i; i--; return n; } | |
13312 | inline const_iterator &operator+=(int j) { i+=j; return *this; } | |
13313 | inline const_iterator &operator-=(int j) { i-=j; return *this; } | |
13314 | inline const_iterator operator+(int j) const { return const_iterator(i+j); } | |
13315 | inline const_iterator operator-(int j) const { return const_iterator(i-j); } | |
13316 | inline int operator-(const_iterator j) const { return i - j.i; } | |
13317 | }; | |
13318 | friend class const_iterator; | |
13319 | inline iterator begin() { detach(); return reinterpret_cast<Node *>(p.begin()); } | |
13320 | inline const_iterator begin() const { return reinterpret_cast<Node *>(p.begin()); } | |
13321 | inline const_iterator constBegin() const { return reinterpret_cast<Node *>(p.begin()); } | |
13322 | inline iterator end() { detach(); return reinterpret_cast<Node *>(p.end()); } | |
13323 | inline const_iterator end() const { return reinterpret_cast<Node *>(p.end()); } | |
13324 | inline const_iterator constEnd() const { return reinterpret_cast<Node *>(p.end()); } | |
13325 | iterator insert(iterator before, const T &t); | |
13326 | iterator erase(iterator pos); | |
13327 | iterator erase(iterator first, iterator last); | |
13328 | typedef iterator Iterator; | |
13329 | typedef const_iterator ConstIterator; | |
13330 | inline int count() const { return p.size(); } | |
13331 | inline int length() const { return p.size(); } | |
13332 | inline T& first() { qt_noop(); return *begin(); } | |
13333 | inline const T& first() const { qt_noop(); return *begin(); } | |
13334 | T& last() { qt_noop(); return *(--end()); } | |
13335 | const T& last() const { qt_noop(); return *(--end()); } | |
13336 | inline void removeFirst() { qt_noop(); erase(begin()); } | |
13337 | inline void removeLast() { qt_noop(); erase(--end()); } | |
13338 | inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; } | |
13339 | inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; } | |
13340 | QList<T> mid(int pos, int length = -1) const; | |
13341 | T value(int i) const; | |
13342 | T value(int i, const T &defaultValue) const; | |
13343 | inline void push_back(const T &t) { append(t); } | |
13344 | inline void push_front(const T &t) { prepend(t); } | |
13345 | inline T& front() { return first(); } | |
13346 | inline const T& front() const { return first(); } | |
13347 | inline T& back() { return last(); } | |
13348 | inline const T& back() const { return last(); } | |
13349 | inline void pop_front() { removeFirst(); } | |
13350 | inline void pop_back() { removeLast(); } | |
13351 | inline bool empty() const { return isEmpty(); } | |
13352 | typedef int size_type; | |
13353 | typedef T value_type; | |
13354 | typedef value_type *pointer; | |
13355 | typedef const value_type *const_pointer; | |
13356 | typedef value_type &reference; | |
13357 | typedef const value_type &const_reference; | |
13358 | typedef ptrdiff_t difference_type; | |
13359 | QList<T> &operator+=(const QList<T> &l); | |
13360 | inline QList<T> operator+(const QList<T> &l) const | |
13361 | { QList n = *this; n += l; return n; } | |
13362 | inline QList<T> &operator+=(const T &t) | |
13363 | { append(t); return *this; } | |
13364 | inline QList<T> &operator<< (const T &t) | |
13365 | { append(t); return *this; } | |
13366 | inline QList<T> &operator<<(const QList<T> &l) | |
13367 | { *this += l; return *this; } | |
13368 | QVector<T> toVector() const; | |
13369 | QSet<T> toSet() const; | |
13370 | static QList<T> fromVector(const QVector<T> &vector); | |
13371 | static QList<T> fromSet(const QSet<T> &set); | |
13372 | static inline QList<T> fromStdList(const std::list<T> &list) | |
13373 | { QList<T> tmp; qCopy(list.begin(), list.end(), std::back_inserter(tmp)); return tmp; } | |
13374 | inline std::list<T> toStdList() const | |
13375 | { std::list<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; } | |
13376 | private: | |
13377 | void detach_helper(); | |
13378 | void free(QListData::Data *d); | |
13379 | void node_construct(Node *n, const T &t); | |
13380 | void node_destruct(Node *n); | |
13381 | void node_copy(Node *from, Node *to, Node *src); | |
13382 | void node_destruct(Node *from, Node *to); | |
13383 | }; | |
13384 | template <typename T> | |
13385 | inline void QList<T>::node_construct(Node *n, const T &t) | |
13386 | { | |
13387 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) n->v = new T(t); | |
13388 | else if (QTypeInfo<T>::isComplex) new (n) T(t); | |
13389 | else *reinterpret_cast<T*>(n) = t; | |
13390 | } | |
13391 | template <typename T> | |
13392 | inline void QList<T>::node_destruct(Node *n) | |
13393 | { | |
13394 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) delete reinterpret_cast<T*>(n->v); | |
13395 | else if (QTypeInfo<T>::isComplex) reinterpret_cast<T*>(n)->~T(); | |
13396 | } | |
13397 | template <typename T> | |
13398 | inline void QList<T>::node_copy(Node *from, Node *to, Node *src) | |
13399 | { | |
13400 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) | |
13401 | while(from != to) | |
13402 | (from++)->v = new T(*reinterpret_cast<T*>((src++)->v)); | |
13403 | else if (QTypeInfo<T>::isComplex) | |
13404 | while(from != to) | |
13405 | new (from++) T(*reinterpret_cast<T*>(src++)); | |
13406 | } | |
13407 | template <typename T> | |
13408 | inline void QList<T>::node_destruct(Node *from, Node *to) | |
13409 | { | |
13410 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) | |
13411 | while(from != to) --to, delete reinterpret_cast<T*>(to->v); | |
13412 | else if (QTypeInfo<T>::isComplex) | |
13413 | while (from != to) --to, reinterpret_cast<T*>(to)->~T(); | |
13414 | } | |
13415 | template <typename T> | |
13416 | inline QList<T> &QList<T>::operator=(const QList<T> &l) | |
13417 | { | |
13418 | if (d != l.d) { | |
13419 | l.d->ref.ref(); | |
13420 | if (!d->ref.deref()) | |
13421 | free(d); | |
13422 | d = l.d; | |
13423 | if (!d->sharable) | |
13424 | detach_helper(); | |
13425 | } | |
13426 | return *this; | |
13427 | } | |
13428 | template <typename T> | |
13429 | inline typename QList<T>::iterator QList<T>::insert(iterator before, const T &t) | |
13430 | { Node *n = reinterpret_cast<Node *>(p.insert(before.i-reinterpret_cast<Node *>(p.begin()))); | |
13431 | node_construct(n,t); return n; } | |
13432 | template <typename T> | |
13433 | inline typename QList<T>::iterator QList<T>::erase(iterator it) | |
13434 | { node_destruct(it.i); | |
13435 | return reinterpret_cast<Node *>(p.erase(reinterpret_cast<void**>(it.i))); } | |
13436 | template <typename T> | |
13437 | inline const T &QList<T>::at(int i) const | |
13438 | { qt_noop(); | |
13439 | return reinterpret_cast<Node *>(p.at(i))->t(); } | |
13440 | template <typename T> | |
13441 | inline const T &QList<T>::operator[](int i) const | |
13442 | { qt_noop(); | |
13443 | return reinterpret_cast<Node *>(p.at(i))->t(); } | |
13444 | template <typename T> | |
13445 | inline T &QList<T>::operator[](int i) | |
13446 | { qt_noop(); | |
13447 | detach(); return reinterpret_cast<Node *>(p.at(i))->t(); } | |
13448 | template <typename T> | |
13449 | inline void QList<T>::removeAt(int i) | |
13450 | { if(i >= 0 && i < p.size()) { detach(); | |
13451 | node_destruct(reinterpret_cast<Node *>(p.at(i))); p.remove(i); } } | |
13452 | template <typename T> | |
13453 | inline T QList<T>::takeAt(int i) | |
13454 | { qt_noop(); | |
13455 | detach(); Node *n = reinterpret_cast<Node *>(p.at(i)); T t = n->t(); node_destruct(n); | |
13456 | p.remove(i); return t; } | |
13457 | template <typename T> | |
13458 | inline T QList<T>::takeFirst() | |
13459 | { T t = first(); removeFirst(); return t; } | |
13460 | template <typename T> | |
13461 | inline T QList<T>::takeLast() | |
13462 | { T t = last(); removeLast(); return t; } | |
13463 | template <typename T> | |
13464 | void QList<T>::append(const T &t) | |
13465 | { | |
13466 | detach(); | |
13467 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) { | |
13468 | node_construct(reinterpret_cast<Node *>(p.append()), t); | |
13469 | } else { | |
13470 | const T cpy(t); | |
13471 | node_construct(reinterpret_cast<Node *>(p.append()), cpy); | |
13472 | } | |
13473 | } | |
13474 | template <typename T> | |
13475 | inline void QList<T>::prepend(const T &t) | |
13476 | { | |
13477 | detach(); | |
13478 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) { | |
13479 | node_construct(reinterpret_cast<Node *>(p.prepend()), t); | |
13480 | } else { | |
13481 | const T cpy(t); | |
13482 | node_construct(reinterpret_cast<Node *>(p.prepend()), cpy); | |
13483 | } | |
13484 | } | |
13485 | template <typename T> | |
13486 | inline void QList<T>::insert(int i, const T &t) | |
13487 | { | |
13488 | detach(); | |
13489 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) { | |
13490 | node_construct(reinterpret_cast<Node *>(p.insert(i)), t); | |
13491 | } else { | |
13492 | const T cpy(t); | |
13493 | node_construct(reinterpret_cast<Node *>(p.insert(i)), cpy); | |
13494 | } | |
13495 | } | |
13496 | template <typename T> | |
13497 | inline void QList<T>::replace(int i, const T &t) | |
13498 | { | |
13499 | qt_noop(); | |
13500 | detach(); | |
13501 | if (QTypeInfo<T>::isLarge || QTypeInfo<T>::isStatic) { | |
13502 | reinterpret_cast<Node *>(p.at(i))->t() = t; | |
13503 | } else { | |
13504 | const T cpy(t); | |
13505 | reinterpret_cast<Node *>(p.at(i))->t() = cpy; | |
13506 | } | |
13507 | } | |
13508 | template <typename T> | |
13509 | inline void QList<T>::swap(int i, int j) | |
13510 | { | |
13511 | qt_noop(); | |
13512 | detach(); | |
13513 | void *t = d->array[d->begin + i]; | |
13514 | d->array[d->begin + i] = d->array[d->begin + j]; | |
13515 | d->array[d->begin + j] = t; | |
13516 | } | |
13517 | template <typename T> | |
13518 | inline void QList<T>::move(int from, int to) | |
13519 | { | |
13520 | qt_noop(); | |
13521 | detach(); | |
13522 | p.move(from, to); | |
13523 | } | |
13524 | template<typename T> | |
13525 | QList<T> QList<T>::mid(int pos, int alength) const | |
13526 | { | |
13527 | if (alength < 0) | |
13528 | alength = size() - pos; | |
13529 | if (pos == 0 && alength == size()) | |
13530 | return *this; | |
13531 | QList<T> cpy; | |
13532 | if (pos + alength > size()) | |
13533 | alength = size() - pos; | |
13534 | for (int i = pos; i < pos + alength; ++i) | |
13535 | cpy += at(i); | |
13536 | return cpy; | |
13537 | } | |
13538 | template<typename T> | |
13539 | T QList<T>::value(int i) const | |
13540 | { | |
13541 | if (i < 0 || i >= p.size()) { | |
13542 | return T(); | |
13543 | } | |
13544 | return reinterpret_cast<Node *>(p.at(i))->t(); | |
13545 | } | |
13546 | template<typename T> | |
13547 | T QList<T>::value(int i, const T& defaultValue) const | |
13548 | { | |
13549 | return ((i < 0 || i >= p.size()) ? defaultValue : reinterpret_cast<Node *>(p.at(i))->t()); | |
13550 | } | |
13551 | template <typename T> | |
13552 | void QList<T>::detach_helper() | |
13553 | { | |
13554 | Node *n = reinterpret_cast<Node *>(p.begin()); | |
13555 | QListData::Data *x = p.detach2(); | |
13556 | node_copy(reinterpret_cast<Node *>(p.begin()), reinterpret_cast<Node *>(p.end()), n); | |
13557 | if (!x->ref.deref()) | |
13558 | free(x); | |
13559 | } | |
13560 | template <typename T> | |
13561 | QList<T>::~QList() | |
13562 | { | |
13563 | if (d && !d->ref.deref()) | |
13564 | free(d); | |
13565 | } | |
13566 | template <typename T> | |
13567 | bool QList<T>::operator==(const QList<T> &l) const | |
13568 | { | |
13569 | if (p.size() != l.p.size()) | |
13570 | return false; | |
13571 | if (d == l.d) | |
13572 | return true; | |
13573 | Node *i = reinterpret_cast<Node *>(p.end()); | |
13574 | Node *b = reinterpret_cast<Node *>(p.begin()); | |
13575 | Node *li = reinterpret_cast<Node *>(l.p.end()); | |
13576 | while (i != b) { | |
13577 | --i; --li; | |
13578 | if (!(i->t() == li->t())) | |
13579 | return false; | |
13580 | } | |
13581 | return true; | |
13582 | } | |
13583 | template <typename T> | |
13584 | void QList<T>::free(QListData::Data *data) | |
13585 | { | |
13586 | node_destruct(reinterpret_cast<Node *>(data->array + data->begin), | |
13587 | reinterpret_cast<Node *>(data->array + data->end)); | |
13588 | if (data->ref == 0) | |
13589 | qFree(data); | |
13590 | } | |
13591 | template <typename T> | |
13592 | void QList<T>::clear() | |
13593 | { | |
13594 | *this = QList<T>(); | |
13595 | } | |
13596 | template <typename T> | |
13597 | int QList<T>::removeAll(const T &_t) | |
13598 | { | |
13599 | detach(); | |
13600 | const T t = _t; | |
13601 | int removedCount=0, i=0; | |
13602 | Node *n; | |
13603 | while (i < p.size()) | |
13604 | if ((n = reinterpret_cast<Node *>(p.at(i)))->t() == t) { | |
13605 | node_destruct(n); | |
13606 | p.remove(i); | |
13607 | ++removedCount; | |
13608 | } else { | |
13609 | ++i; | |
13610 | } | |
13611 | return removedCount; | |
13612 | } | |
13613 | template <typename T> | |
13614 | bool QList<T>::removeOne(const T &_t) | |
13615 | { | |
13616 | detach(); | |
13617 | int index = indexOf(_t); | |
13618 | if (index != -1) { | |
13619 | removeAt(index); | |
13620 | return true; | |
13621 | } | |
13622 | return false; | |
13623 | } | |
13624 | template <typename T> | |
13625 | typename QList<T>::iterator QList<T>::erase(typename QList<T>::iterator afirst, | |
13626 | typename QList<T>::iterator alast) | |
13627 | { | |
13628 | for (Node *n = afirst.i; n < alast.i; ++n) | |
13629 | node_destruct(n); | |
13630 | int idx = afirst - begin(); | |
13631 | p.remove(idx, alast - afirst); | |
13632 | return begin() + idx; | |
13633 | } | |
13634 | template <typename T> | |
13635 | QList<T> &QList<T>::operator+=(const QList<T> &l) | |
13636 | { | |
13637 | detach(); | |
13638 | Node *n = reinterpret_cast<Node *>(p.append(l.p)); | |
13639 | node_copy(n, reinterpret_cast<Node *>(p.end()), reinterpret_cast<Node *>(l.p.begin())); | |
13640 | return *this; | |
13641 | } | |
13642 | template <typename T> | |
13643 | inline void QList<T>::append(const QList<T> &t) | |
13644 | { | |
13645 | *this += t; | |
13646 | } | |
13647 | template <typename T> | |
13648 | int QList<T>::indexOf(const T &t, int from) const | |
13649 | { | |
13650 | if (from < 0) | |
13651 | from = qMax(from + p.size(), 0); | |
13652 | if (from < p.size()) { | |
13653 | Node *n = reinterpret_cast<Node *>(p.at(from -1)); | |
13654 | Node *e = reinterpret_cast<Node *>(p.end()); | |
13655 | while (++n != e) | |
13656 | if (n->t() == t) | |
13657 | return n - reinterpret_cast<Node *>(p.begin()); | |
13658 | } | |
13659 | return -1; | |
13660 | } | |
13661 | template <typename T> | |
13662 | int QList<T>::lastIndexOf(const T &t, int from) const | |
13663 | { | |
13664 | if (from < 0) | |
13665 | from += p.size(); | |
13666 | else if (from >= p.size()) | |
13667 | from = p.size()-1; | |
13668 | if (from >= 0) { | |
13669 | Node *b = reinterpret_cast<Node *>(p.begin()); | |
13670 | Node *n = reinterpret_cast<Node *>(p.at(from + 1)); | |
13671 | while (n-- != b) { | |
13672 | if (n->t() == t) | |
13673 | return n - b; | |
13674 | } | |
13675 | } | |
13676 | return -1; | |
13677 | } | |
13678 | template <typename T> | |
13679 | QBool QList<T>::contains(const T &t) const | |
13680 | { | |
13681 | Node *b = reinterpret_cast<Node *>(p.begin()); | |
13682 | Node *i = reinterpret_cast<Node *>(p.end()); | |
13683 | while (i-- != b) | |
13684 | if (i->t() == t) | |
13685 | return QBool(true); | |
13686 | return QBool(false); | |
13687 | } | |
13688 | template <typename T> | |
13689 | int QList<T>::count(const T &t) const | |
13690 | { | |
13691 | int c = 0; | |
13692 | Node *b = reinterpret_cast<Node *>(p.begin()); | |
13693 | Node *i = reinterpret_cast<Node *>(p.end()); | |
13694 | while (i-- != b) | |
13695 | if (i->t() == t) | |
13696 | ++c; | |
13697 | return c; | |
13698 | } | |
13699 | template <class T> class QListIterator { typedef typename QList<T>::const_iterator const_iterator; QList<T> c; const_iterator i; public: inline QListIterator(const QList<T> &container) : c(container), i(c.constBegin()) {} inline QListIterator &operator=(const QList<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } }; | |
13700 | template <class T> class QMutableListIterator { typedef typename QList<T>::iterator iterator; typedef typename QList<T>::const_iterator const_iterator; QList<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableListIterator(QList<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableListIterator() { c->setSharable(true); } inline QMutableListIterator &operator=(QList<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } }; | |
13701 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
13702 | namespace | |
13703 | Qt { | |
13704 | enum GlobalColor { | |
13705 | color0, | |
13706 | color1, | |
13707 | black, | |
13708 | white, | |
13709 | darkGray, | |
13710 | gray, | |
13711 | lightGray, | |
13712 | red, | |
13713 | green, | |
13714 | blue, | |
13715 | cyan, | |
13716 | magenta, | |
13717 | yellow, | |
13718 | darkRed, | |
13719 | darkGreen, | |
13720 | darkBlue, | |
13721 | darkCyan, | |
13722 | darkMagenta, | |
13723 | darkYellow, | |
13724 | transparent | |
13725 | }; | |
13726 | enum KeyboardModifier { | |
13727 | NoModifier = 0x00000000, | |
13728 | ShiftModifier = 0x02000000, | |
13729 | ControlModifier = 0x04000000, | |
13730 | AltModifier = 0x08000000, | |
13731 | MetaModifier = 0x10000000, | |
13732 | KeypadModifier = 0x20000000, | |
13733 | GroupSwitchModifier = 0x40000000, | |
13734 | KeyboardModifierMask = 0xfe000000 | |
13735 | }; | |
13736 | typedef QFlags<KeyboardModifier> KeyboardModifiers; | |
13737 | enum Modifier { | |
13738 | META = Qt::MetaModifier, | |
13739 | SHIFT = Qt::ShiftModifier, | |
13740 | CTRL = Qt::ControlModifier, | |
13741 | ALT = Qt::AltModifier, | |
13742 | MODIFIER_MASK = KeyboardModifierMask, | |
13743 | UNICODE_ACCEL = 0x00000000 | |
13744 | }; | |
13745 | enum MouseButton { | |
13746 | NoButton = 0x00000000, | |
13747 | LeftButton = 0x00000001, | |
13748 | RightButton = 0x00000002, | |
13749 | MidButton = 0x00000004, | |
13750 | XButton1 = 0x00000008, | |
13751 | XButton2 = 0x00000010, | |
13752 | MouseButtonMask = 0x000000ff | |
13753 | }; | |
13754 | typedef QFlags<MouseButton> MouseButtons; | |
13755 | enum Orientation { | |
13756 | Horizontal = 0x1, | |
13757 | Vertical = 0x2 | |
13758 | }; | |
13759 | typedef QFlags<Orientation> Orientations; | |
13760 | enum FocusPolicy { | |
13761 | NoFocus = 0, | |
13762 | TabFocus = 0x1, | |
13763 | ClickFocus = 0x2, | |
13764 | StrongFocus = TabFocus | ClickFocus | 0x8, | |
13765 | WheelFocus = StrongFocus | 0x4 | |
13766 | }; | |
13767 | enum SortOrder { | |
13768 | AscendingOrder, | |
13769 | DescendingOrder | |
13770 | }; | |
13771 | enum AlignmentFlag { | |
13772 | AlignLeft = 0x0001, | |
13773 | AlignLeading = AlignLeft, | |
13774 | AlignRight = 0x0002, | |
13775 | AlignTrailing = AlignRight, | |
13776 | AlignHCenter = 0x0004, | |
13777 | AlignJustify = 0x0008, | |
13778 | AlignAbsolute = 0x0010, | |
13779 | AlignHorizontal_Mask = AlignLeft | AlignRight | AlignHCenter | AlignJustify | AlignAbsolute, | |
13780 | AlignTop = 0x0020, | |
13781 | AlignBottom = 0x0040, | |
13782 | AlignVCenter = 0x0080, | |
13783 | AlignVertical_Mask = AlignTop | AlignBottom | AlignVCenter, | |
13784 | AlignCenter = AlignVCenter | AlignHCenter | |
13785 | }; | |
13786 | typedef QFlags<AlignmentFlag> Alignment; | |
13787 | enum TextFlag { | |
13788 | TextSingleLine = 0x0100, | |
13789 | TextDontClip = 0x0200, | |
13790 | TextExpandTabs = 0x0400, | |
13791 | TextShowMnemonic = 0x0800, | |
13792 | TextWordWrap = 0x1000, | |
13793 | TextWrapAnywhere = 0x2000, | |
13794 | TextDontPrint = 0x4000, | |
13795 | TextIncludeTrailingSpaces = 0x08000000, | |
13796 | TextHideMnemonic = 0x8000, | |
13797 | TextJustificationForced = 0x10000, | |
13798 | TextForceLeftToRight = 0x20000, | |
13799 | TextForceRightToLeft = 0x40000 | |
13800 | }; | |
13801 | enum TextElideMode { | |
13802 | ElideLeft, | |
13803 | ElideRight, | |
13804 | ElideMiddle, | |
13805 | ElideNone | |
13806 | }; | |
13807 | enum WindowType { | |
13808 | Widget = 0x00000000, | |
13809 | Window = 0x00000001, | |
13810 | Dialog = 0x00000002 | Window, | |
13811 | Sheet = 0x00000004 | Window, | |
13812 | Drawer = 0x00000006 | Window, | |
13813 | Popup = 0x00000008 | Window, | |
13814 | Tool = 0x0000000a | Window, | |
13815 | ToolTip = 0x0000000c | Window, | |
13816 | SplashScreen = 0x0000000e | Window, | |
13817 | Desktop = 0x00000010 | Window, | |
13818 | SubWindow = 0x00000012, | |
13819 | WindowType_Mask = 0x000000ff, | |
13820 | MSWindowsFixedSizeDialogHint = 0x00000100, | |
13821 | MSWindowsOwnDC = 0x00000200, | |
13822 | X11BypassWindowManagerHint = 0x00000400, | |
13823 | FramelessWindowHint = 0x00000800, | |
13824 | WindowTitleHint = 0x00001000, | |
13825 | WindowSystemMenuHint = 0x00002000, | |
13826 | WindowMinimizeButtonHint = 0x00004000, | |
13827 | WindowMaximizeButtonHint = 0x00008000, | |
13828 | WindowMinMaxButtonsHint = WindowMinimizeButtonHint | WindowMaximizeButtonHint, | |
13829 | WindowContextHelpButtonHint = 0x00010000, | |
13830 | WindowShadeButtonHint = 0x00020000, | |
13831 | WindowStaysOnTopHint = 0x00040000, | |
13832 | CustomizeWindowHint = 0x02000000, | |
13833 | WindowStaysOnBottomHint = 0x04000000, | |
13834 | WindowCloseButtonHint = 0x08000000, | |
13835 | MacWindowToolBarButtonHint = 0x10000000, | |
13836 | BypassGraphicsProxyWidget = 0x20000000, | |
13837 | WindowOkButtonHint = 0x00080000, | |
13838 | WindowCancelButtonHint = 0x00100000 | |
13839 | }; | |
13840 | typedef QFlags<WindowType> WindowFlags; | |
13841 | enum WindowState { | |
13842 | WindowNoState = 0x00000000, | |
13843 | WindowMinimized = 0x00000001, | |
13844 | WindowMaximized = 0x00000002, | |
13845 | WindowFullScreen = 0x00000004, | |
13846 | WindowActive = 0x00000008 | |
13847 | }; | |
13848 | typedef QFlags<WindowState> WindowStates; | |
13849 | enum WidgetAttribute { | |
13850 | WA_Disabled = 0, | |
13851 | WA_UnderMouse = 1, | |
13852 | WA_MouseTracking = 2, | |
13853 | WA_ContentsPropagated = 3, | |
13854 | WA_OpaquePaintEvent = 4, | |
13855 | WA_NoBackground = WA_OpaquePaintEvent, | |
13856 | WA_StaticContents = 5, | |
13857 | WA_LaidOut = 7, | |
13858 | WA_PaintOnScreen = 8, | |
13859 | WA_NoSystemBackground = 9, | |
13860 | WA_UpdatesDisabled = 10, | |
13861 | WA_Mapped = 11, | |
13862 | WA_MacNoClickThrough = 12, | |
13863 | WA_PaintOutsidePaintEvent = 13, | |
13864 | WA_InputMethodEnabled = 14, | |
13865 | WA_WState_Visible = 15, | |
13866 | WA_WState_Hidden = 16, | |
13867 | WA_ForceDisabled = 32, | |
13868 | WA_KeyCompression = 33, | |
13869 | WA_PendingMoveEvent = 34, | |
13870 | WA_PendingResizeEvent = 35, | |
13871 | WA_SetPalette = 36, | |
13872 | WA_SetFont = 37, | |
13873 | WA_SetCursor = 38, | |
13874 | WA_NoChildEventsFromChildren = 39, | |
13875 | WA_WindowModified = 41, | |
13876 | WA_Resized = 42, | |
13877 | WA_Moved = 43, | |
13878 | WA_PendingUpdate = 44, | |
13879 | WA_InvalidSize = 45, | |
13880 | WA_MacBrushedMetal = 46, | |
13881 | WA_MacMetalStyle = WA_MacBrushedMetal, | |
13882 | WA_CustomWhatsThis = 47, | |
13883 | WA_LayoutOnEntireRect = 48, | |
13884 | WA_OutsideWSRange = 49, | |
13885 | WA_GrabbedShortcut = 50, | |
13886 | WA_TransparentForMouseEvents = 51, | |
13887 | WA_PaintUnclipped = 52, | |
13888 | WA_SetWindowIcon = 53, | |
13889 | WA_NoMouseReplay = 54, | |
13890 | WA_DeleteOnClose = 55, | |
13891 | WA_RightToLeft = 56, | |
13892 | WA_SetLayoutDirection = 57, | |
13893 | WA_NoChildEventsForParent = 58, | |
13894 | WA_ForceUpdatesDisabled = 59, | |
13895 | WA_WState_Created = 60, | |
13896 | WA_WState_CompressKeys = 61, | |
13897 | WA_WState_InPaintEvent = 62, | |
13898 | WA_WState_Reparented = 63, | |
13899 | WA_WState_ConfigPending = 64, | |
13900 | WA_WState_Polished = 66, | |
13901 | WA_WState_DND = 67, | |
13902 | WA_WState_OwnSizePolicy = 68, | |
13903 | WA_WState_ExplicitShowHide = 69, | |
13904 | WA_ShowModal = 70, | |
13905 | WA_MouseNoMask = 71, | |
13906 | WA_GroupLeader = 72, | |
13907 | WA_NoMousePropagation = 73, | |
13908 | WA_Hover = 74, | |
13909 | WA_InputMethodTransparent = 75, | |
13910 | WA_QuitOnClose = 76, | |
13911 | WA_KeyboardFocusChange = 77, | |
13912 | WA_AcceptDrops = 78, | |
13913 | WA_DropSiteRegistered = 79, | |
13914 | WA_ForceAcceptDrops = WA_DropSiteRegistered, | |
13915 | WA_WindowPropagation = 80, | |
13916 | WA_NoX11EventCompression = 81, | |
13917 | WA_TintedBackground = 82, | |
13918 | WA_X11OpenGLOverlay = 83, | |
13919 | WA_AlwaysShowToolTips = 84, | |
13920 | WA_MacOpaqueSizeGrip = 85, | |
13921 | WA_SetStyle = 86, | |
13922 | WA_SetLocale = 87, | |
13923 | WA_MacShowFocusRect = 88, | |
13924 | WA_MacNormalSize = 89, | |
13925 | WA_MacSmallSize = 90, | |
13926 | WA_MacMiniSize = 91, | |
13927 | WA_LayoutUsesWidgetRect = 92, | |
13928 | WA_StyledBackground = 93, | |
13929 | WA_MSWindowsUseDirect3D = 94, | |
13930 | WA_CanHostQMdiSubWindowTitleBar = 95, | |
13931 | WA_MacAlwaysShowToolWindow = 96, | |
13932 | WA_StyleSheet = 97, | |
13933 | WA_ShowWithoutActivating = 98, | |
13934 | WA_X11BypassTransientForHint = 99, | |
13935 | WA_NativeWindow = 100, | |
13936 | WA_DontCreateNativeAncestors = 101, | |
13937 | WA_MacVariableSize = 102, | |
13938 | WA_DontShowOnScreen = 103, | |
13939 | WA_X11NetWmWindowTypeDesktop = 104, | |
13940 | WA_X11NetWmWindowTypeDock = 105, | |
13941 | WA_X11NetWmWindowTypeToolBar = 106, | |
13942 | WA_X11NetWmWindowTypeMenu = 107, | |
13943 | WA_X11NetWmWindowTypeUtility = 108, | |
13944 | WA_X11NetWmWindowTypeSplash = 109, | |
13945 | WA_X11NetWmWindowTypeDialog = 110, | |
13946 | WA_X11NetWmWindowTypeDropDownMenu = 111, | |
13947 | WA_X11NetWmWindowTypePopupMenu = 112, | |
13948 | WA_X11NetWmWindowTypeToolTip = 113, | |
13949 | WA_X11NetWmWindowTypeNotification = 114, | |
13950 | WA_X11NetWmWindowTypeCombo = 115, | |
13951 | WA_X11NetWmWindowTypeDND = 116, | |
13952 | WA_MacFrameworkScaled = 117, | |
13953 | WA_SetWindowModality = 118, | |
13954 | WA_WState_WindowOpacitySet = 119, | |
13955 | WA_TranslucentBackground = 120, | |
13956 | WA_AttributeCount | |
13957 | }; | |
13958 | enum ApplicationAttribute | |
13959 | { | |
13960 | AA_ImmediateWidgetCreation = 0, | |
13961 | AA_MSWindowsUseDirect3DByDefault = 1, | |
13962 | AA_DontShowIconsInMenus = 2, | |
13963 | AA_NativeWindows = 3, | |
13964 | AA_DontCreateNativeWidgetSiblings = 4, | |
13965 | AA_MacPluginApplication = 5, | |
13966 | AA_AttributeCount | |
13967 | }; | |
13968 | enum ImageConversionFlag { | |
13969 | ColorMode_Mask = 0x00000003, | |
13970 | AutoColor = 0x00000000, | |
13971 | ColorOnly = 0x00000003, | |
13972 | MonoOnly = 0x00000002, | |
13973 | AlphaDither_Mask = 0x0000000c, | |
13974 | ThresholdAlphaDither = 0x00000000, | |
13975 | OrderedAlphaDither = 0x00000004, | |
13976 | DiffuseAlphaDither = 0x00000008, | |
13977 | NoAlpha = 0x0000000c, | |
13978 | Dither_Mask = 0x00000030, | |
13979 | DiffuseDither = 0x00000000, | |
13980 | OrderedDither = 0x00000010, | |
13981 | ThresholdDither = 0x00000020, | |
13982 | DitherMode_Mask = 0x000000c0, | |
13983 | AutoDither = 0x00000000, | |
13984 | PreferDither = 0x00000040, | |
13985 | AvoidDither = 0x00000080, | |
13986 | NoOpaqueDetection = 0x00000100 | |
13987 | }; | |
13988 | typedef QFlags<ImageConversionFlag> ImageConversionFlags; | |
13989 | enum BGMode { | |
13990 | TransparentMode, | |
13991 | OpaqueMode | |
13992 | }; | |
13993 | enum Key { | |
13994 | Key_Escape = 0x01000000, | |
13995 | Key_Tab = 0x01000001, | |
13996 | Key_Backtab = 0x01000002, | |
13997 | Key_Backspace = 0x01000003, | |
13998 | Key_Return = 0x01000004, | |
13999 | Key_Enter = 0x01000005, | |
14000 | Key_Insert = 0x01000006, | |
14001 | Key_Delete = 0x01000007, | |
14002 | Key_Pause = 0x01000008, | |
14003 | Key_Print = 0x01000009, | |
14004 | Key_SysReq = 0x0100000a, | |
14005 | Key_Clear = 0x0100000b, | |
14006 | Key_Home = 0x01000010, | |
14007 | Key_End = 0x01000011, | |
14008 | Key_Left = 0x01000012, | |
14009 | Key_Up = 0x01000013, | |
14010 | Key_Right = 0x01000014, | |
14011 | Key_Down = 0x01000015, | |
14012 | Key_PageUp = 0x01000016, | |
14013 | Key_PageDown = 0x01000017, | |
14014 | Key_Shift = 0x01000020, | |
14015 | Key_Control = 0x01000021, | |
14016 | Key_Meta = 0x01000022, | |
14017 | Key_Alt = 0x01000023, | |
14018 | Key_CapsLock = 0x01000024, | |
14019 | Key_NumLock = 0x01000025, | |
14020 | Key_ScrollLock = 0x01000026, | |
14021 | Key_F1 = 0x01000030, | |
14022 | Key_F2 = 0x01000031, | |
14023 | Key_F3 = 0x01000032, | |
14024 | Key_F4 = 0x01000033, | |
14025 | Key_F5 = 0x01000034, | |
14026 | Key_F6 = 0x01000035, | |
14027 | Key_F7 = 0x01000036, | |
14028 | Key_F8 = 0x01000037, | |
14029 | Key_F9 = 0x01000038, | |
14030 | Key_F10 = 0x01000039, | |
14031 | Key_F11 = 0x0100003a, | |
14032 | Key_F12 = 0x0100003b, | |
14033 | Key_F13 = 0x0100003c, | |
14034 | Key_F14 = 0x0100003d, | |
14035 | Key_F15 = 0x0100003e, | |
14036 | Key_F16 = 0x0100003f, | |
14037 | Key_F17 = 0x01000040, | |
14038 | Key_F18 = 0x01000041, | |
14039 | Key_F19 = 0x01000042, | |
14040 | Key_F20 = 0x01000043, | |
14041 | Key_F21 = 0x01000044, | |
14042 | Key_F22 = 0x01000045, | |
14043 | Key_F23 = 0x01000046, | |
14044 | Key_F24 = 0x01000047, | |
14045 | Key_F25 = 0x01000048, | |
14046 | Key_F26 = 0x01000049, | |
14047 | Key_F27 = 0x0100004a, | |
14048 | Key_F28 = 0x0100004b, | |
14049 | Key_F29 = 0x0100004c, | |
14050 | Key_F30 = 0x0100004d, | |
14051 | Key_F31 = 0x0100004e, | |
14052 | Key_F32 = 0x0100004f, | |
14053 | Key_F33 = 0x01000050, | |
14054 | Key_F34 = 0x01000051, | |
14055 | Key_F35 = 0x01000052, | |
14056 | Key_Super_L = 0x01000053, | |
14057 | Key_Super_R = 0x01000054, | |
14058 | Key_Menu = 0x01000055, | |
14059 | Key_Hyper_L = 0x01000056, | |
14060 | Key_Hyper_R = 0x01000057, | |
14061 | Key_Help = 0x01000058, | |
14062 | Key_Direction_L = 0x01000059, | |
14063 | Key_Direction_R = 0x01000060, | |
14064 | Key_Space = 0x20, | |
14065 | Key_Any = Key_Space, | |
14066 | Key_Exclam = 0x21, | |
14067 | Key_QuoteDbl = 0x22, | |
14068 | Key_NumberSign = 0x23, | |
14069 | Key_Dollar = 0x24, | |
14070 | Key_Percent = 0x25, | |
14071 | Key_Ampersand = 0x26, | |
14072 | Key_Apostrophe = 0x27, | |
14073 | Key_ParenLeft = 0x28, | |
14074 | Key_ParenRight = 0x29, | |
14075 | Key_Asterisk = 0x2a, | |
14076 | Key_Plus = 0x2b, | |
14077 | Key_Comma = 0x2c, | |
14078 | Key_Minus = 0x2d, | |
14079 | Key_Period = 0x2e, | |
14080 | Key_Slash = 0x2f, | |
14081 | Key_0 = 0x30, | |
14082 | Key_1 = 0x31, | |
14083 | Key_2 = 0x32, | |
14084 | Key_3 = 0x33, | |
14085 | Key_4 = 0x34, | |
14086 | Key_5 = 0x35, | |
14087 | Key_6 = 0x36, | |
14088 | Key_7 = 0x37, | |
14089 | Key_8 = 0x38, | |
14090 | Key_9 = 0x39, | |
14091 | Key_Colon = 0x3a, | |
14092 | Key_Semicolon = 0x3b, | |
14093 | Key_Less = 0x3c, | |
14094 | Key_Equal = 0x3d, | |
14095 | Key_Greater = 0x3e, | |
14096 | Key_Question = 0x3f, | |
14097 | Key_At = 0x40, | |
14098 | Key_A = 0x41, | |
14099 | Key_B = 0x42, | |
14100 | Key_C = 0x43, | |
14101 | Key_D = 0x44, | |
14102 | Key_E = 0x45, | |
14103 | Key_F = 0x46, | |
14104 | Key_G = 0x47, | |
14105 | Key_H = 0x48, | |
14106 | Key_I = 0x49, | |
14107 | Key_J = 0x4a, | |
14108 | Key_K = 0x4b, | |
14109 | Key_L = 0x4c, | |
14110 | Key_M = 0x4d, | |
14111 | Key_N = 0x4e, | |
14112 | Key_O = 0x4f, | |
14113 | Key_P = 0x50, | |
14114 | Key_Q = 0x51, | |
14115 | Key_R = 0x52, | |
14116 | Key_S = 0x53, | |
14117 | Key_T = 0x54, | |
14118 | Key_U = 0x55, | |
14119 | Key_V = 0x56, | |
14120 | Key_W = 0x57, | |
14121 | Key_X = 0x58, | |
14122 | Key_Y = 0x59, | |
14123 | Key_Z = 0x5a, | |
14124 | Key_BracketLeft = 0x5b, | |
14125 | Key_Backslash = 0x5c, | |
14126 | Key_BracketRight = 0x5d, | |
14127 | Key_AsciiCircum = 0x5e, | |
14128 | Key_Underscore = 0x5f, | |
14129 | Key_QuoteLeft = 0x60, | |
14130 | Key_BraceLeft = 0x7b, | |
14131 | Key_Bar = 0x7c, | |
14132 | Key_BraceRight = 0x7d, | |
14133 | Key_AsciiTilde = 0x7e, | |
14134 | Key_nobreakspace = 0x0a0, | |
14135 | Key_exclamdown = 0x0a1, | |
14136 | Key_cent = 0x0a2, | |
14137 | Key_sterling = 0x0a3, | |
14138 | Key_currency = 0x0a4, | |
14139 | Key_yen = 0x0a5, | |
14140 | Key_brokenbar = 0x0a6, | |
14141 | Key_section = 0x0a7, | |
14142 | Key_diaeresis = 0x0a8, | |
14143 | Key_copyright = 0x0a9, | |
14144 | Key_ordfeminine = 0x0aa, | |
14145 | Key_guillemotleft = 0x0ab, | |
14146 | Key_notsign = 0x0ac, | |
14147 | Key_hyphen = 0x0ad, | |
14148 | Key_registered = 0x0ae, | |
14149 | Key_macron = 0x0af, | |
14150 | Key_degree = 0x0b0, | |
14151 | Key_plusminus = 0x0b1, | |
14152 | Key_twosuperior = 0x0b2, | |
14153 | Key_threesuperior = 0x0b3, | |
14154 | Key_acute = 0x0b4, | |
14155 | Key_mu = 0x0b5, | |
14156 | Key_paragraph = 0x0b6, | |
14157 | Key_periodcentered = 0x0b7, | |
14158 | Key_cedilla = 0x0b8, | |
14159 | Key_onesuperior = 0x0b9, | |
14160 | Key_masculine = 0x0ba, | |
14161 | Key_guillemotright = 0x0bb, | |
14162 | Key_onequarter = 0x0bc, | |
14163 | Key_onehalf = 0x0bd, | |
14164 | Key_threequarters = 0x0be, | |
14165 | Key_questiondown = 0x0bf, | |
14166 | Key_Agrave = 0x0c0, | |
14167 | Key_Aacute = 0x0c1, | |
14168 | Key_Acircumflex = 0x0c2, | |
14169 | Key_Atilde = 0x0c3, | |
14170 | Key_Adiaeresis = 0x0c4, | |
14171 | Key_Aring = 0x0c5, | |
14172 | Key_AE = 0x0c6, | |
14173 | Key_Ccedilla = 0x0c7, | |
14174 | Key_Egrave = 0x0c8, | |
14175 | Key_Eacute = 0x0c9, | |
14176 | Key_Ecircumflex = 0x0ca, | |
14177 | Key_Ediaeresis = 0x0cb, | |
14178 | Key_Igrave = 0x0cc, | |
14179 | Key_Iacute = 0x0cd, | |
14180 | Key_Icircumflex = 0x0ce, | |
14181 | Key_Idiaeresis = 0x0cf, | |
14182 | Key_ETH = 0x0d0, | |
14183 | Key_Ntilde = 0x0d1, | |
14184 | Key_Ograve = 0x0d2, | |
14185 | Key_Oacute = 0x0d3, | |
14186 | Key_Ocircumflex = 0x0d4, | |
14187 | Key_Otilde = 0x0d5, | |
14188 | Key_Odiaeresis = 0x0d6, | |
14189 | Key_multiply = 0x0d7, | |
14190 | Key_Ooblique = 0x0d8, | |
14191 | Key_Ugrave = 0x0d9, | |
14192 | Key_Uacute = 0x0da, | |
14193 | Key_Ucircumflex = 0x0db, | |
14194 | Key_Udiaeresis = 0x0dc, | |
14195 | Key_Yacute = 0x0dd, | |
14196 | Key_THORN = 0x0de, | |
14197 | Key_ssharp = 0x0df, | |
14198 | Key_division = 0x0f7, | |
14199 | Key_ydiaeresis = 0x0ff, | |
14200 | Key_AltGr = 0x01001103, | |
14201 | Key_Multi_key = 0x01001120, | |
14202 | Key_Codeinput = 0x01001137, | |
14203 | Key_SingleCandidate = 0x0100113c, | |
14204 | Key_MultipleCandidate = 0x0100113d, | |
14205 | Key_PreviousCandidate = 0x0100113e, | |
14206 | Key_Mode_switch = 0x0100117e, | |
14207 | Key_Kanji = 0x01001121, | |
14208 | Key_Muhenkan = 0x01001122, | |
14209 | Key_Henkan = 0x01001123, | |
14210 | Key_Romaji = 0x01001124, | |
14211 | Key_Hiragana = 0x01001125, | |
14212 | Key_Katakana = 0x01001126, | |
14213 | Key_Hiragana_Katakana = 0x01001127, | |
14214 | Key_Zenkaku = 0x01001128, | |
14215 | Key_Hankaku = 0x01001129, | |
14216 | Key_Zenkaku_Hankaku = 0x0100112a, | |
14217 | Key_Touroku = 0x0100112b, | |
14218 | Key_Massyo = 0x0100112c, | |
14219 | Key_Kana_Lock = 0x0100112d, | |
14220 | Key_Kana_Shift = 0x0100112e, | |
14221 | Key_Eisu_Shift = 0x0100112f, | |
14222 | Key_Eisu_toggle = 0x01001130, | |
14223 | Key_Hangul = 0x01001131, | |
14224 | Key_Hangul_Start = 0x01001132, | |
14225 | Key_Hangul_End = 0x01001133, | |
14226 | Key_Hangul_Hanja = 0x01001134, | |
14227 | Key_Hangul_Jamo = 0x01001135, | |
14228 | Key_Hangul_Romaja = 0x01001136, | |
14229 | Key_Hangul_Jeonja = 0x01001138, | |
14230 | Key_Hangul_Banja = 0x01001139, | |
14231 | Key_Hangul_PreHanja = 0x0100113a, | |
14232 | Key_Hangul_PostHanja = 0x0100113b, | |
14233 | Key_Hangul_Special = 0x0100113f, | |
14234 | Key_Dead_Grave = 0x01001250, | |
14235 | Key_Dead_Acute = 0x01001251, | |
14236 | Key_Dead_Circumflex = 0x01001252, | |
14237 | Key_Dead_Tilde = 0x01001253, | |
14238 | Key_Dead_Macron = 0x01001254, | |
14239 | Key_Dead_Breve = 0x01001255, | |
14240 | Key_Dead_Abovedot = 0x01001256, | |
14241 | Key_Dead_Diaeresis = 0x01001257, | |
14242 | Key_Dead_Abovering = 0x01001258, | |
14243 | Key_Dead_Doubleacute = 0x01001259, | |
14244 | Key_Dead_Caron = 0x0100125a, | |
14245 | Key_Dead_Cedilla = 0x0100125b, | |
14246 | Key_Dead_Ogonek = 0x0100125c, | |
14247 | Key_Dead_Iota = 0x0100125d, | |
14248 | Key_Dead_Voiced_Sound = 0x0100125e, | |
14249 | Key_Dead_Semivoiced_Sound = 0x0100125f, | |
14250 | Key_Dead_Belowdot = 0x01001260, | |
14251 | Key_Dead_Hook = 0x01001261, | |
14252 | Key_Dead_Horn = 0x01001262, | |
14253 | Key_Back = 0x01000061, | |
14254 | Key_Forward = 0x01000062, | |
14255 | Key_Stop = 0x01000063, | |
14256 | Key_Refresh = 0x01000064, | |
14257 | Key_VolumeDown = 0x01000070, | |
14258 | Key_VolumeMute = 0x01000071, | |
14259 | Key_VolumeUp = 0x01000072, | |
14260 | Key_BassBoost = 0x01000073, | |
14261 | Key_BassUp = 0x01000074, | |
14262 | Key_BassDown = 0x01000075, | |
14263 | Key_TrebleUp = 0x01000076, | |
14264 | Key_TrebleDown = 0x01000077, | |
14265 | Key_MediaPlay = 0x01000080, | |
14266 | Key_MediaStop = 0x01000081, | |
14267 | Key_MediaPrevious = 0x01000082, | |
14268 | Key_MediaNext = 0x01000083, | |
14269 | Key_MediaRecord = 0x01000084, | |
14270 | Key_HomePage = 0x01000090, | |
14271 | Key_Favorites = 0x01000091, | |
14272 | Key_Search = 0x01000092, | |
14273 | Key_Standby = 0x01000093, | |
14274 | Key_OpenUrl = 0x01000094, | |
14275 | Key_LaunchMail = 0x010000a0, | |
14276 | Key_LaunchMedia = 0x010000a1, | |
14277 | Key_Launch0 = 0x010000a2, | |
14278 | Key_Launch1 = 0x010000a3, | |
14279 | Key_Launch2 = 0x010000a4, | |
14280 | Key_Launch3 = 0x010000a5, | |
14281 | Key_Launch4 = 0x010000a6, | |
14282 | Key_Launch5 = 0x010000a7, | |
14283 | Key_Launch6 = 0x010000a8, | |
14284 | Key_Launch7 = 0x010000a9, | |
14285 | Key_Launch8 = 0x010000aa, | |
14286 | Key_Launch9 = 0x010000ab, | |
14287 | Key_LaunchA = 0x010000ac, | |
14288 | Key_LaunchB = 0x010000ad, | |
14289 | Key_LaunchC = 0x010000ae, | |
14290 | Key_LaunchD = 0x010000af, | |
14291 | Key_LaunchE = 0x010000b0, | |
14292 | Key_LaunchF = 0x010000b1, | |
14293 | Key_MediaLast = 0x0100ffff, | |
14294 | Key_Select = 0x01010000, | |
14295 | Key_Yes = 0x01010001, | |
14296 | Key_No = 0x01010002, | |
14297 | Key_Cancel = 0x01020001, | |
14298 | Key_Printer = 0x01020002, | |
14299 | Key_Execute = 0x01020003, | |
14300 | Key_Sleep = 0x01020004, | |
14301 | Key_Play = 0x01020005, | |
14302 | Key_Zoom = 0x01020006, | |
14303 | Key_Context1 = 0x01100000, | |
14304 | Key_Context2 = 0x01100001, | |
14305 | Key_Context3 = 0x01100002, | |
14306 | Key_Context4 = 0x01100003, | |
14307 | Key_Call = 0x01100004, | |
14308 | Key_Hangup = 0x01100005, | |
14309 | Key_Flip = 0x01100006, | |
14310 | Key_unknown = 0x01ffffff | |
14311 | }; | |
14312 | enum ArrowType { | |
14313 | NoArrow, | |
14314 | UpArrow, | |
14315 | DownArrow, | |
14316 | LeftArrow, | |
14317 | RightArrow | |
14318 | }; | |
14319 | enum PenStyle { | |
14320 | NoPen, | |
14321 | SolidLine, | |
14322 | DashLine, | |
14323 | DotLine, | |
14324 | DashDotLine, | |
14325 | DashDotDotLine, | |
14326 | CustomDashLine | |
14327 | , MPenStyle = 0x0f | |
14328 | }; | |
14329 | enum PenCapStyle { | |
14330 | FlatCap = 0x00, | |
14331 | SquareCap = 0x10, | |
14332 | RoundCap = 0x20, | |
14333 | MPenCapStyle = 0x30 | |
14334 | }; | |
14335 | enum PenJoinStyle { | |
14336 | MiterJoin = 0x00, | |
14337 | BevelJoin = 0x40, | |
14338 | RoundJoin = 0x80, | |
14339 | SvgMiterJoin = 0x100, | |
14340 | MPenJoinStyle = 0x1c0 | |
14341 | }; | |
14342 | enum BrushStyle { | |
14343 | NoBrush, | |
14344 | SolidPattern, | |
14345 | Dense1Pattern, | |
14346 | Dense2Pattern, | |
14347 | Dense3Pattern, | |
14348 | Dense4Pattern, | |
14349 | Dense5Pattern, | |
14350 | Dense6Pattern, | |
14351 | Dense7Pattern, | |
14352 | HorPattern, | |
14353 | VerPattern, | |
14354 | CrossPattern, | |
14355 | BDiagPattern, | |
14356 | FDiagPattern, | |
14357 | DiagCrossPattern, | |
14358 | LinearGradientPattern, | |
14359 | RadialGradientPattern, | |
14360 | ConicalGradientPattern, | |
14361 | TexturePattern = 24 | |
14362 | }; | |
14363 | enum SizeMode { | |
14364 | AbsoluteSize, | |
14365 | RelativeSize | |
14366 | }; | |
14367 | enum UIEffect { | |
14368 | UI_General, | |
14369 | UI_AnimateMenu, | |
14370 | UI_FadeMenu, | |
14371 | UI_AnimateCombo, | |
14372 | UI_AnimateTooltip, | |
14373 | UI_FadeTooltip, | |
14374 | UI_AnimateToolBox | |
14375 | }; | |
14376 | enum CursorShape { | |
14377 | ArrowCursor, | |
14378 | UpArrowCursor, | |
14379 | CrossCursor, | |
14380 | WaitCursor, | |
14381 | IBeamCursor, | |
14382 | SizeVerCursor, | |
14383 | SizeHorCursor, | |
14384 | SizeBDiagCursor, | |
14385 | SizeFDiagCursor, | |
14386 | SizeAllCursor, | |
14387 | BlankCursor, | |
14388 | SplitVCursor, | |
14389 | SplitHCursor, | |
14390 | PointingHandCursor, | |
14391 | ForbiddenCursor, | |
14392 | WhatsThisCursor, | |
14393 | BusyCursor, | |
14394 | OpenHandCursor, | |
14395 | ClosedHandCursor, | |
14396 | LastCursor = ClosedHandCursor, | |
14397 | BitmapCursor = 24, | |
14398 | CustomCursor = 25 | |
14399 | }; | |
14400 | enum TextFormat { | |
14401 | PlainText, | |
14402 | RichText, | |
14403 | AutoText, | |
14404 | LogText | |
14405 | }; | |
14406 | enum AspectRatioMode { | |
14407 | IgnoreAspectRatio, | |
14408 | KeepAspectRatio, | |
14409 | KeepAspectRatioByExpanding | |
14410 | }; | |
14411 | enum AnchorAttribute { | |
14412 | AnchorName, | |
14413 | AnchorHref | |
14414 | }; | |
14415 | enum DockWidgetArea { | |
14416 | LeftDockWidgetArea = 0x1, | |
14417 | RightDockWidgetArea = 0x2, | |
14418 | TopDockWidgetArea = 0x4, | |
14419 | BottomDockWidgetArea = 0x8, | |
14420 | DockWidgetArea_Mask = 0xf, | |
14421 | AllDockWidgetAreas = DockWidgetArea_Mask, | |
14422 | NoDockWidgetArea = 0 | |
14423 | }; | |
14424 | enum DockWidgetAreaSizes { | |
14425 | NDockWidgetAreas = 4 | |
14426 | }; | |
14427 | typedef QFlags<DockWidgetArea> DockWidgetAreas; | |
14428 | enum ToolBarArea { | |
14429 | LeftToolBarArea = 0x1, | |
14430 | RightToolBarArea = 0x2, | |
14431 | TopToolBarArea = 0x4, | |
14432 | BottomToolBarArea = 0x8, | |
14433 | ToolBarArea_Mask = 0xf, | |
14434 | AllToolBarAreas = ToolBarArea_Mask, | |
14435 | NoToolBarArea = 0 | |
14436 | }; | |
14437 | enum ToolBarAreaSizes { | |
14438 | NToolBarAreas = 4 | |
14439 | }; | |
14440 | typedef QFlags<ToolBarArea> ToolBarAreas; | |
14441 | enum DateFormat { | |
14442 | TextDate, | |
14443 | ISODate, | |
14444 | SystemLocaleDate, | |
14445 | LocalDate = SystemLocaleDate, | |
14446 | LocaleDate, | |
14447 | SystemLocaleShortDate, | |
14448 | SystemLocaleLongDate, | |
14449 | DefaultLocaleShortDate, | |
14450 | DefaultLocaleLongDate | |
14451 | }; | |
14452 | enum TimeSpec { | |
14453 | LocalTime, | |
14454 | UTC, | |
14455 | OffsetFromUTC | |
14456 | }; | |
14457 | enum DayOfWeek { | |
14458 | Monday = 1, | |
14459 | Tuesday = 2, | |
14460 | Wednesday = 3, | |
14461 | Thursday = 4, | |
14462 | Friday = 5, | |
14463 | Saturday = 6, | |
14464 | Sunday = 7 | |
14465 | }; | |
14466 | enum ScrollBarPolicy { | |
14467 | ScrollBarAsNeeded, | |
14468 | ScrollBarAlwaysOff, | |
14469 | ScrollBarAlwaysOn | |
14470 | }; | |
14471 | enum CaseSensitivity { | |
14472 | CaseInsensitive, | |
14473 | CaseSensitive | |
14474 | }; | |
14475 | enum Corner { | |
14476 | TopLeftCorner = 0x00000, | |
14477 | TopRightCorner = 0x00001, | |
14478 | BottomLeftCorner = 0x00002, | |
14479 | BottomRightCorner = 0x00003 | |
14480 | }; | |
14481 | enum ConnectionType { | |
14482 | AutoConnection, | |
14483 | DirectConnection, | |
14484 | QueuedConnection, | |
14485 | AutoCompatConnection, | |
14486 | BlockingQueuedConnection | |
14487 | }; | |
14488 | enum ShortcutContext { | |
14489 | WidgetShortcut, | |
14490 | WindowShortcut, | |
14491 | ApplicationShortcut, | |
14492 | WidgetWithChildrenShortcut | |
14493 | }; | |
14494 | enum FillRule { | |
14495 | OddEvenFill, | |
14496 | WindingFill | |
14497 | }; | |
14498 | enum MaskMode { | |
14499 | MaskInColor, | |
14500 | MaskOutColor | |
14501 | }; | |
14502 | enum ClipOperation { | |
14503 | NoClip, | |
14504 | ReplaceClip, | |
14505 | IntersectClip, | |
14506 | UniteClip | |
14507 | }; | |
14508 | enum ItemSelectionMode { | |
14509 | ContainsItemShape = 0x0, | |
14510 | IntersectsItemShape = 0x1, | |
14511 | ContainsItemBoundingRect = 0x2, | |
14512 | IntersectsItemBoundingRect = 0x3 | |
14513 | }; | |
14514 | enum TransformationMode { | |
14515 | FastTransformation, | |
14516 | SmoothTransformation | |
14517 | }; | |
14518 | enum Axis { | |
14519 | XAxis, | |
14520 | YAxis, | |
14521 | ZAxis | |
14522 | }; | |
14523 | enum FocusReason { | |
14524 | MouseFocusReason, | |
14525 | TabFocusReason, | |
14526 | BacktabFocusReason, | |
14527 | ActiveWindowFocusReason, | |
14528 | PopupFocusReason, | |
14529 | ShortcutFocusReason, | |
14530 | MenuBarFocusReason, | |
14531 | OtherFocusReason, | |
14532 | NoFocusReason | |
14533 | }; | |
14534 | enum ContextMenuPolicy { | |
14535 | NoContextMenu, | |
14536 | DefaultContextMenu, | |
14537 | ActionsContextMenu, | |
14538 | CustomContextMenu, | |
14539 | PreventContextMenu | |
14540 | }; | |
14541 | enum InputMethodQuery { | |
14542 | ImMicroFocus, | |
14543 | ImFont, | |
14544 | ImCursorPosition, | |
14545 | ImSurroundingText, | |
14546 | ImCurrentSelection | |
14547 | }; | |
14548 | enum ToolButtonStyle { | |
14549 | ToolButtonIconOnly, | |
14550 | ToolButtonTextOnly, | |
14551 | ToolButtonTextBesideIcon, | |
14552 | ToolButtonTextUnderIcon | |
14553 | }; | |
14554 | enum LayoutDirection { | |
14555 | LeftToRight, | |
14556 | RightToLeft | |
14557 | }; | |
14558 | enum DropAction { | |
14559 | CopyAction = 0x1, | |
14560 | MoveAction = 0x2, | |
14561 | LinkAction = 0x4, | |
14562 | ActionMask = 0xff, | |
14563 | TargetMoveAction = 0x8002, | |
14564 | IgnoreAction = 0x0 | |
14565 | }; | |
14566 | typedef QFlags<DropAction> DropActions; | |
14567 | enum CheckState { | |
14568 | Unchecked, | |
14569 | PartiallyChecked, | |
14570 | Checked | |
14571 | }; | |
14572 | enum ItemDataRole { | |
14573 | DisplayRole = 0, | |
14574 | DecorationRole = 1, | |
14575 | EditRole = 2, | |
14576 | ToolTipRole = 3, | |
14577 | StatusTipRole = 4, | |
14578 | WhatsThisRole = 5, | |
14579 | FontRole = 6, | |
14580 | TextAlignmentRole = 7, | |
14581 | BackgroundColorRole = 8, | |
14582 | BackgroundRole = 8, | |
14583 | TextColorRole = 9, | |
14584 | ForegroundRole = 9, | |
14585 | CheckStateRole = 10, | |
14586 | AccessibleTextRole = 11, | |
14587 | AccessibleDescriptionRole = 12, | |
14588 | SizeHintRole = 13, | |
14589 | DisplayPropertyRole = 27, | |
14590 | DecorationPropertyRole = 28, | |
14591 | ToolTipPropertyRole = 29, | |
14592 | StatusTipPropertyRole = 30, | |
14593 | WhatsThisPropertyRole = 31, | |
14594 | UserRole = 32 | |
14595 | }; | |
14596 | enum ItemFlag { | |
14597 | NoItemFlags = 0, | |
14598 | ItemIsSelectable = 1, | |
14599 | ItemIsEditable = 2, | |
14600 | ItemIsDragEnabled = 4, | |
14601 | ItemIsDropEnabled = 8, | |
14602 | ItemIsUserCheckable = 16, | |
14603 | ItemIsEnabled = 32, | |
14604 | ItemIsTristate = 64 | |
14605 | }; | |
14606 | typedef QFlags<ItemFlag> ItemFlags; | |
14607 | enum MatchFlag { | |
14608 | MatchExactly = 0, | |
14609 | MatchContains = 1, | |
14610 | MatchStartsWith = 2, | |
14611 | MatchEndsWith = 3, | |
14612 | MatchRegExp = 4, | |
14613 | MatchWildcard = 5, | |
14614 | MatchFixedString = 8, | |
14615 | MatchCaseSensitive = 16, | |
14616 | MatchWrap = 32, | |
14617 | MatchRecursive = 64 | |
14618 | }; | |
14619 | typedef QFlags<MatchFlag> MatchFlags; | |
14620 | typedef void * HANDLE; | |
14621 | typedef WindowFlags WFlags; | |
14622 | enum WindowModality { | |
14623 | NonModal, | |
14624 | WindowModal, | |
14625 | ApplicationModal | |
14626 | }; | |
14627 | enum TextInteractionFlag { | |
14628 | NoTextInteraction = 0, | |
14629 | TextSelectableByMouse = 1, | |
14630 | TextSelectableByKeyboard = 2, | |
14631 | LinksAccessibleByMouse = 4, | |
14632 | LinksAccessibleByKeyboard = 8, | |
14633 | TextEditable = 16, | |
14634 | TextEditorInteraction = TextSelectableByMouse | TextSelectableByKeyboard | TextEditable, | |
14635 | TextBrowserInteraction = TextSelectableByMouse | LinksAccessibleByMouse | LinksAccessibleByKeyboard | |
14636 | }; | |
14637 | typedef QFlags<TextInteractionFlag> TextInteractionFlags; | |
14638 | enum EventPriority { | |
14639 | HighEventPriority = 1, | |
14640 | NormalEventPriority = 0, | |
14641 | LowEventPriority = -1 | |
14642 | }; | |
14643 | enum SizeHint { | |
14644 | MinimumSize, | |
14645 | PreferredSize, | |
14646 | MaximumSize, | |
14647 | MinimumDescent, | |
14648 | NSizeHints | |
14649 | }; | |
14650 | enum WindowFrameSection { | |
14651 | NoSection, | |
14652 | LeftSection, | |
14653 | TopLeftSection, | |
14654 | TopSection, | |
14655 | TopRightSection, | |
14656 | RightSection, | |
14657 | BottomRightSection, | |
14658 | BottomSection, | |
14659 | BottomLeftSection, | |
14660 | TitleBarArea | |
14661 | }; | |
14662 | } | |
14663 | inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, Qt::MouseButtons::enum_type f2) { return QFlags<Qt::MouseButtons::enum_type>(f1) | f2; } inline QFlags<Qt::MouseButtons::enum_type> operator|(Qt::MouseButtons::enum_type f1, QFlags<Qt::MouseButtons::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MouseButtons::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14664 | inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, Qt::Orientations::enum_type f2) { return QFlags<Qt::Orientations::enum_type>(f1) | f2; } inline QFlags<Qt::Orientations::enum_type> operator|(Qt::Orientations::enum_type f1, QFlags<Qt::Orientations::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Orientations::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14665 | inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, Qt::KeyboardModifiers::enum_type f2) { return QFlags<Qt::KeyboardModifiers::enum_type>(f1) | f2; } inline QFlags<Qt::KeyboardModifiers::enum_type> operator|(Qt::KeyboardModifiers::enum_type f1, QFlags<Qt::KeyboardModifiers::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::KeyboardModifiers::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14666 | inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, Qt::WindowFlags::enum_type f2) { return QFlags<Qt::WindowFlags::enum_type>(f1) | f2; } inline QFlags<Qt::WindowFlags::enum_type> operator|(Qt::WindowFlags::enum_type f1, QFlags<Qt::WindowFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14667 | inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, Qt::Alignment::enum_type f2) { return QFlags<Qt::Alignment::enum_type>(f1) | f2; } inline QFlags<Qt::Alignment::enum_type> operator|(Qt::Alignment::enum_type f1, QFlags<Qt::Alignment::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::Alignment::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14668 | inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, Qt::ImageConversionFlags::enum_type f2) { return QFlags<Qt::ImageConversionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ImageConversionFlags::enum_type> operator|(Qt::ImageConversionFlags::enum_type f1, QFlags<Qt::ImageConversionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ImageConversionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14669 | inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, Qt::DockWidgetAreas::enum_type f2) { return QFlags<Qt::DockWidgetAreas::enum_type>(f1) | f2; } inline QFlags<Qt::DockWidgetAreas::enum_type> operator|(Qt::DockWidgetAreas::enum_type f1, QFlags<Qt::DockWidgetAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DockWidgetAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14670 | inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, Qt::ToolBarAreas::enum_type f2) { return QFlags<Qt::ToolBarAreas::enum_type>(f1) | f2; } inline QFlags<Qt::ToolBarAreas::enum_type> operator|(Qt::ToolBarAreas::enum_type f1, QFlags<Qt::ToolBarAreas::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ToolBarAreas::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14671 | inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, Qt::WindowStates::enum_type f2) { return QFlags<Qt::WindowStates::enum_type>(f1) | f2; } inline QFlags<Qt::WindowStates::enum_type> operator|(Qt::WindowStates::enum_type f1, QFlags<Qt::WindowStates::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::WindowStates::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14672 | inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, Qt::DropActions::enum_type f2) { return QFlags<Qt::DropActions::enum_type>(f1) | f2; } inline QFlags<Qt::DropActions::enum_type> operator|(Qt::DropActions::enum_type f1, QFlags<Qt::DropActions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::DropActions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14673 | inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, Qt::ItemFlags::enum_type f2) { return QFlags<Qt::ItemFlags::enum_type>(f1) | f2; } inline QFlags<Qt::ItemFlags::enum_type> operator|(Qt::ItemFlags::enum_type f1, QFlags<Qt::ItemFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::ItemFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14674 | inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, Qt::MatchFlags::enum_type f2) { return QFlags<Qt::MatchFlags::enum_type>(f1) | f2; } inline QFlags<Qt::MatchFlags::enum_type> operator|(Qt::MatchFlags::enum_type f1, QFlags<Qt::MatchFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::MatchFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14675 | inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, Qt::TextInteractionFlags::enum_type f2) { return QFlags<Qt::TextInteractionFlags::enum_type>(f1) | f2; } inline QFlags<Qt::TextInteractionFlags::enum_type> operator|(Qt::TextInteractionFlags::enum_type f1, QFlags<Qt::TextInteractionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(Qt::TextInteractionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
14676 | typedef bool (*qInternalCallback)(void **); | |
14677 | class __attribute__((visibility("default"))) QInternal { | |
14678 | public: | |
14679 | enum PaintDeviceFlags { | |
14680 | UnknownDevice = 0x00, | |
14681 | Widget = 0x01, | |
14682 | Pixmap = 0x02, | |
14683 | Image = 0x03, | |
14684 | Printer = 0x04, | |
14685 | Picture = 0x05, | |
14686 | Pbuffer = 0x06, | |
14687 | FramebufferObject = 0x07, | |
14688 | CustomRaster = 0x08, | |
14689 | MacQuartz = 0x09 | |
14690 | }; | |
14691 | enum RelayoutType { | |
14692 | RelayoutNormal, | |
14693 | RelayoutDragging, | |
14694 | RelayoutDropped | |
14695 | }; | |
14696 | enum Callback { | |
14697 | ConnectCallback, | |
14698 | DisconnectCallback, | |
14699 | AdoptCurrentThread, | |
14700 | EventNotifyCallback, | |
14701 | LastCallback | |
14702 | }; | |
14703 | enum InternalFunction { | |
14704 | CreateThreadForAdoption, | |
14705 | RefAdoptedThread, | |
14706 | DerefAdoptedThread, | |
14707 | SetCurrentThreadToMainThread, | |
14708 | SetQObjectSender, | |
14709 | GetQObjectSender, | |
14710 | ResetQObjectSender, | |
14711 | LastInternalFunction | |
14712 | }; | |
14713 | enum DockPosition { | |
14714 | LeftDock, | |
14715 | RightDock, | |
14716 | TopDock, | |
14717 | BottomDock, | |
14718 | DockCount | |
14719 | }; | |
14720 | static bool registerCallback(Callback, qInternalCallback); | |
14721 | static bool unregisterCallback(Callback, qInternalCallback); | |
14722 | static bool activateCallbacks(Callback, void **); | |
14723 | static bool callFunction(InternalFunction func, void **); | |
14724 | }; | |
14725 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
14726 | class QByteArray; | |
14727 | class QString; | |
14728 | template <typename T> | |
14729 | inline int qYouForgotTheQ_OBJECT_Macro(T, T) { return 0; } | |
14730 | template <typename T1, typename T2> | |
14731 | inline void qYouForgotTheQ_OBJECT_Macro(T1, T2) {} | |
14732 | __attribute__((visibility("default"))) const char *qFlagLocation(const char *method); | |
14733 | class QObject; | |
14734 | class QMetaMethod; | |
14735 | class QMetaEnum; | |
14736 | class QMetaProperty; | |
14737 | class QMetaClassInfo; | |
14738 | class __attribute__((visibility("default"))) QGenericArgument | |
14739 | { | |
14740 | public: | |
14741 | inline QGenericArgument(const char *aName = 0, const void *aData = 0) | |
14742 | : _data(aData), _name(aName) {} | |
14743 | inline void *data() const { return const_cast<void *>(_data); } | |
14744 | inline const char *name() const { return _name; } | |
14745 | private: | |
14746 | const void *_data; | |
14747 | const char *_name; | |
14748 | }; | |
14749 | class __attribute__((visibility("default"))) QGenericReturnArgument: public QGenericArgument | |
14750 | { | |
14751 | public: | |
14752 | inline QGenericReturnArgument(const char *aName = 0, void *aData = 0) | |
14753 | : QGenericArgument(aName, aData) | |
14754 | {} | |
14755 | }; | |
14756 | template <class T> | |
14757 | class QArgument: public QGenericArgument | |
14758 | { | |
14759 | public: | |
14760 | inline QArgument(const char *aName, const T &aData) | |
14761 | : QGenericArgument(aName, static_cast<const void *>(&aData)) | |
14762 | {} | |
14763 | }; | |
14764 | template <typename T> | |
14765 | class QReturnArgument: public QGenericReturnArgument | |
14766 | { | |
14767 | public: | |
14768 | inline QReturnArgument(const char *aName, T &aData) | |
14769 | : QGenericReturnArgument(aName, static_cast<void *>(&aData)) | |
14770 | {} | |
14771 | }; | |
14772 | struct __attribute__((visibility("default"))) QMetaObject | |
14773 | { | |
14774 | const char *className() const; | |
14775 | const QMetaObject *superClass() const; | |
14776 | QObject *cast(QObject *obj) const; | |
14777 | QString tr(const char *s, const char *c) const; | |
14778 | QString trUtf8(const char *s, const char *c) const; | |
14779 | QString tr(const char *s, const char *c, int n) const; | |
14780 | QString trUtf8(const char *s, const char *c, int n) const; | |
14781 | int methodOffset() const; | |
14782 | int enumeratorOffset() const; | |
14783 | int propertyOffset() const; | |
14784 | int classInfoOffset() const; | |
14785 | int constructorCount() const; | |
14786 | int methodCount() const; | |
14787 | int enumeratorCount() const; | |
14788 | int propertyCount() const; | |
14789 | int classInfoCount() const; | |
14790 | int indexOfConstructor(const char *constructor) const; | |
14791 | int indexOfMethod(const char *method) const; | |
14792 | int indexOfSignal(const char *signal) const; | |
14793 | int indexOfSlot(const char *slot) const; | |
14794 | int indexOfEnumerator(const char *name) const; | |
14795 | int indexOfProperty(const char *name) const; | |
14796 | int indexOfClassInfo(const char *name) const; | |
14797 | QMetaMethod constructor(int index) const; | |
14798 | QMetaMethod method(int index) const; | |
14799 | QMetaEnum enumerator(int index) const; | |
14800 | QMetaProperty property(int index) const; | |
14801 | QMetaClassInfo classInfo(int index) const; | |
14802 | QMetaProperty userProperty() const; | |
14803 | static bool checkConnectArgs(const char *signal, const char *method); | |
14804 | static QByteArray normalizedSignature(const char *method); | |
14805 | static QByteArray normalizedType(const char *type); | |
14806 | static bool connect(const QObject *sender, int signal_index, | |
14807 | const QObject *receiver, int method_index, | |
14808 | int type = 0, int *types = 0); | |
14809 | static bool disconnect(const QObject *sender, int signal_index, | |
14810 | const QObject *receiver, int method_index); | |
14811 | static void connectSlotsByName(QObject *o); | |
14812 | static void activate(QObject *sender, int signal_index, void **argv); | |
14813 | static void activate(QObject *sender, int from_signal_index, int to_signal_index, void **argv); | |
14814 | static void activate(QObject *sender, const QMetaObject *, int local_signal_index, void **argv); | |
14815 | static void activate(QObject *sender, const QMetaObject *, int from_local_signal_index, int to_local_signal_index, void **argv); | |
14816 | static void addGuard(QObject **ptr); | |
14817 | static void removeGuard(QObject **ptr); | |
14818 | static void changeGuard(QObject **ptr, QObject *o); | |
14819 | static bool invokeMethod(QObject *obj, const char *member, | |
14820 | Qt::ConnectionType, | |
14821 | QGenericReturnArgument ret, | |
14822 | QGenericArgument val0 = QGenericArgument(0), | |
14823 | QGenericArgument val1 = QGenericArgument(), | |
14824 | QGenericArgument val2 = QGenericArgument(), | |
14825 | QGenericArgument val3 = QGenericArgument(), | |
14826 | QGenericArgument val4 = QGenericArgument(), | |
14827 | QGenericArgument val5 = QGenericArgument(), | |
14828 | QGenericArgument val6 = QGenericArgument(), | |
14829 | QGenericArgument val7 = QGenericArgument(), | |
14830 | QGenericArgument val8 = QGenericArgument(), | |
14831 | QGenericArgument val9 = QGenericArgument()); | |
14832 | static inline bool invokeMethod(QObject *obj, const char *member, | |
14833 | QGenericReturnArgument ret, | |
14834 | QGenericArgument val0 = QGenericArgument(0), | |
14835 | QGenericArgument val1 = QGenericArgument(), | |
14836 | QGenericArgument val2 = QGenericArgument(), | |
14837 | QGenericArgument val3 = QGenericArgument(), | |
14838 | QGenericArgument val4 = QGenericArgument(), | |
14839 | QGenericArgument val5 = QGenericArgument(), | |
14840 | QGenericArgument val6 = QGenericArgument(), | |
14841 | QGenericArgument val7 = QGenericArgument(), | |
14842 | QGenericArgument val8 = QGenericArgument(), | |
14843 | QGenericArgument val9 = QGenericArgument()) | |
14844 | { | |
14845 | return invokeMethod(obj, member, Qt::AutoConnection, ret, val0, val1, val2, val3, | |
14846 | val4, val5, val6, val7, val8, val9); | |
14847 | } | |
14848 | static inline bool invokeMethod(QObject *obj, const char *member, | |
14849 | Qt::ConnectionType type, | |
14850 | QGenericArgument val0 = QGenericArgument(0), | |
14851 | QGenericArgument val1 = QGenericArgument(), | |
14852 | QGenericArgument val2 = QGenericArgument(), | |
14853 | QGenericArgument val3 = QGenericArgument(), | |
14854 | QGenericArgument val4 = QGenericArgument(), | |
14855 | QGenericArgument val5 = QGenericArgument(), | |
14856 | QGenericArgument val6 = QGenericArgument(), | |
14857 | QGenericArgument val7 = QGenericArgument(), | |
14858 | QGenericArgument val8 = QGenericArgument(), | |
14859 | QGenericArgument val9 = QGenericArgument()) | |
14860 | { | |
14861 | return invokeMethod(obj, member, type, QGenericReturnArgument(), val0, val1, val2, | |
14862 | val3, val4, val5, val6, val7, val8, val9); | |
14863 | } | |
14864 | static inline bool invokeMethod(QObject *obj, const char *member, | |
14865 | QGenericArgument val0 = QGenericArgument(0), | |
14866 | QGenericArgument val1 = QGenericArgument(), | |
14867 | QGenericArgument val2 = QGenericArgument(), | |
14868 | QGenericArgument val3 = QGenericArgument(), | |
14869 | QGenericArgument val4 = QGenericArgument(), | |
14870 | QGenericArgument val5 = QGenericArgument(), | |
14871 | QGenericArgument val6 = QGenericArgument(), | |
14872 | QGenericArgument val7 = QGenericArgument(), | |
14873 | QGenericArgument val8 = QGenericArgument(), | |
14874 | QGenericArgument val9 = QGenericArgument()) | |
14875 | { | |
14876 | return invokeMethod(obj, member, Qt::AutoConnection, QGenericReturnArgument(), val0, | |
14877 | val1, val2, val3, val4, val5, val6, val7, val8, val9); | |
14878 | } | |
14879 | QObject *newInstance(QGenericArgument val0 = QGenericArgument(0), | |
14880 | QGenericArgument val1 = QGenericArgument(), | |
14881 | QGenericArgument val2 = QGenericArgument(), | |
14882 | QGenericArgument val3 = QGenericArgument(), | |
14883 | QGenericArgument val4 = QGenericArgument(), | |
14884 | QGenericArgument val5 = QGenericArgument(), | |
14885 | QGenericArgument val6 = QGenericArgument(), | |
14886 | QGenericArgument val7 = QGenericArgument(), | |
14887 | QGenericArgument val8 = QGenericArgument(), | |
14888 | QGenericArgument val9 = QGenericArgument()) const; | |
14889 | enum Call { | |
14890 | InvokeMetaMethod, | |
14891 | ReadProperty, | |
14892 | WriteProperty, | |
14893 | ResetProperty, | |
14894 | QueryPropertyDesignable, | |
14895 | QueryPropertyScriptable, | |
14896 | QueryPropertyStored, | |
14897 | QueryPropertyEditable, | |
14898 | QueryPropertyUser, | |
14899 | CreateInstance | |
14900 | }; | |
14901 | int static_metacall(Call, int, void **) const; | |
14902 | struct { | |
14903 | const QMetaObject *superdata; | |
14904 | const char *stringdata; | |
14905 | const uint *data; | |
14906 | const void *extradata; | |
14907 | } d; | |
14908 | }; | |
14909 | struct QMetaObjectExtraData | |
14910 | { | |
14911 | const QMetaObject **objects; | |
14912 | int (*static_metacall)(QMetaObject::Call, int, void **); | |
14913 | }; | |
14914 | inline const char *QMetaObject::className() const | |
14915 | { return d.stringdata; } | |
14916 | inline const QMetaObject *QMetaObject::superClass() const | |
14917 | { return d.superdata; } | |
14918 | extern "C" { | |
14919 | extern void *memcpy (void *__restrict __dest, | |
14920 | __const void *__restrict __src, size_t __n) | |
14921 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14922 | extern void *memmove (void *__dest, __const void *__src, size_t __n) | |
14923 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14924 | extern void *memccpy (void *__restrict __dest, __const void *__restrict __src, | |
14925 | int __c, size_t __n) | |
14926 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14927 | extern void *memset (void *__s, int __c, size_t __n) throw () __attribute__ ((__nonnull__ (1))); | |
14928 | extern int memcmp (__const void *__s1, __const void *__s2, size_t __n) | |
14929 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14930 | extern void *memchr (__const void *__s, int __c, size_t __n) | |
14931 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14932 | extern void *rawmemchr (__const void *__s, int __c) | |
14933 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14934 | extern void *memrchr (__const void *__s, int __c, size_t __n) | |
14935 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14936 | extern char *strcpy (char *__restrict __dest, __const char *__restrict __src) | |
14937 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14938 | extern char *strncpy (char *__restrict __dest, | |
14939 | __const char *__restrict __src, size_t __n) | |
14940 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14941 | extern char *strcat (char *__restrict __dest, __const char *__restrict __src) | |
14942 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14943 | extern char *strncat (char *__restrict __dest, __const char *__restrict __src, | |
14944 | size_t __n) throw () __attribute__ ((__nonnull__ (1, 2))); | |
14945 | extern int strcmp (__const char *__s1, __const char *__s2) | |
14946 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14947 | extern int strncmp (__const char *__s1, __const char *__s2, size_t __n) | |
14948 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14949 | extern int strcoll (__const char *__s1, __const char *__s2) | |
14950 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14951 | extern size_t strxfrm (char *__restrict __dest, | |
14952 | __const char *__restrict __src, size_t __n) | |
14953 | throw () __attribute__ ((__nonnull__ (2))); | |
14954 | extern char *strdup (__const char *__s) | |
14955 | throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); | |
14956 | extern char *strndup (__const char *__string, size_t __n) | |
14957 | throw () __attribute__ ((__malloc__)) __attribute__ ((__nonnull__ (1))); | |
14958 | extern char *strchr (__const char *__s, int __c) | |
14959 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14960 | extern char *strrchr (__const char *__s, int __c) | |
14961 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14962 | extern char *strchrnul (__const char *__s, int __c) | |
14963 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14964 | extern size_t strcspn (__const char *__s, __const char *__reject) | |
14965 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14966 | extern size_t strspn (__const char *__s, __const char *__accept) | |
14967 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14968 | extern char *strpbrk (__const char *__s, __const char *__accept) | |
14969 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14970 | extern char *strstr (__const char *__haystack, __const char *__needle) | |
14971 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14972 | extern char *strtok (char *__restrict __s, __const char *__restrict __delim) | |
14973 | throw () __attribute__ ((__nonnull__ (2))); | |
14974 | extern char *strtok_r (char *__restrict __s, __const char *__restrict __delim, | |
14975 | char **__restrict __save_ptr) | |
14976 | throw () __attribute__ ((__nonnull__ (2, 3))); | |
14977 | extern char *strcasestr (__const char *__haystack, __const char *__needle) | |
14978 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14979 | extern void *memmem (__const void *__haystack, size_t __haystacklen, | |
14980 | __const void *__needle, size_t __needlelen) | |
14981 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 3))); | |
14982 | extern void *mempcpy (void *__restrict __dest, | |
14983 | __const void *__restrict __src, size_t __n) | |
14984 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14985 | extern size_t strlen (__const char *__s) | |
14986 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14987 | extern size_t strnlen (__const char *__string, size_t __maxlen) | |
14988 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
14989 | extern char *strerror (int __errnum) throw (); | |
14990 | extern char *__glibc_strerror_r (int __errnum, char *__buf, size_t __buflen) | |
14991 | throw () __attribute__ ((__nonnull__ (2))); | |
14992 | extern char * strerror_r (int __errnum, char *__buf, size_t __buflen) throw () __asm__ ("_" "__glibc_strerror_r") __attribute__ ((__nonnull__ (2))); | |
14993 | extern void bcopy (__const void *__src, void *__dest, size_t __n) | |
14994 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
14995 | extern void bzero (void *__s, size_t __n) throw () __attribute__ ((__nonnull__ (1))); | |
14996 | extern int bcmp (__const void *__s1, __const void *__s2, size_t __n) | |
14997 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
14998 | extern char *index (__const char *__s, int __c) | |
14999 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
15000 | extern char *rindex (__const char *__s, int __c) | |
15001 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))); | |
15002 | extern int ffs (int __i) throw () __attribute__ ((__const__)); | |
15003 | extern int strcasecmp (__const char *__s1, __const char *__s2) | |
15004 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
15005 | extern int strncasecmp (__const char *__s1, __const char *__s2, size_t __n) | |
15006 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1, 2))); | |
15007 | extern char *strsep (char **__restrict __stringp, | |
15008 | __const char *__restrict __delim) | |
15009 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
15010 | extern char *strsignal (int __sig) throw (); | |
15011 | extern char *stpcpy (char *__restrict __dest, __const char *__restrict __src) | |
15012 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
15013 | extern char *stpncpy (char *__restrict __dest, | |
15014 | __const char *__restrict __src, size_t __n) | |
15015 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
15016 | extern char *basename (__const char *__filename) throw () __attribute__ ((__nonnull__ (1))); | |
15017 | extern size_t strlcat(char *__restrict dst, const char *__restrict src, | |
15018 | size_t n) throw () __attribute__ ((__nonnull__ (1, 2))); | |
15019 | extern size_t strlcpy(char *__restrict dst, const char *__restrict src, | |
15020 | size_t n) throw () __attribute__ ((__nonnull__ (1, 2))); | |
15021 | } | |
15022 | typedef __gnuc_va_list va_list; | |
15023 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
15024 | __attribute__((visibility("default"))) char *qstrdup(const char *); | |
15025 | inline uint qstrlen(const char *str) | |
15026 | { return str ? uint(strlen(str)) : 0; } | |
15027 | inline uint qstrnlen(const char *str, uint maxlen) | |
15028 | { | |
15029 | uint length = 0; | |
15030 | if (str) { | |
15031 | while (length < maxlen && *str++) | |
15032 | length++; | |
15033 | } | |
15034 | return length; | |
15035 | } | |
15036 | __attribute__((visibility("default"))) char *qstrcpy(char *dst, const char *src); | |
15037 | __attribute__((visibility("default"))) char *qstrncpy(char *dst, const char *src, uint len); | |
15038 | __attribute__((visibility("default"))) int qstrcmp(const char *str1, const char *str2); | |
15039 | __attribute__((visibility("default"))) int qstrcmp(const QByteArray &str1, const QByteArray &str2); | |
15040 | __attribute__((visibility("default"))) int qstrcmp(const QByteArray &str1, const char *str2); | |
15041 | static inline int qstrcmp(const char *str1, const QByteArray &str2) | |
15042 | { return -qstrcmp(str2, str1); } | |
15043 | inline int qstrncmp(const char *str1, const char *str2, uint len) | |
15044 | { | |
15045 | return (str1 && str2) ? strncmp(str1, str2, len) | |
15046 | : (str1 ? 1 : (str2 ? -1 : 0)); | |
15047 | } | |
15048 | __attribute__((visibility("default"))) int qstricmp(const char *, const char *); | |
15049 | __attribute__((visibility("default"))) int qstrnicmp(const char *, const char *, uint len); | |
15050 | __attribute__((visibility("default"))) int qvsnprintf(char *str, size_t n, const char *fmt, va_list ap); | |
15051 | __attribute__((visibility("default"))) int qsnprintf(char *str, size_t n, const char *fmt, ...); | |
15052 | __attribute__((visibility("default"))) quint16 qChecksum(const char *s, uint len); | |
15053 | class QByteRef; | |
15054 | class QString; | |
15055 | class QDataStream; | |
15056 | template <typename T> class QList; | |
15057 | class __attribute__((visibility("default"))) QByteArray | |
15058 | { | |
15059 | public: | |
15060 | inline QByteArray(); | |
15061 | QByteArray(const char *); | |
15062 | QByteArray(const char *, int size); | |
15063 | QByteArray(int size, char c); | |
15064 | inline QByteArray(const QByteArray &); | |
15065 | inline ~QByteArray(); | |
15066 | QByteArray &operator=(const QByteArray &); | |
15067 | QByteArray &operator=(const char *str); | |
15068 | inline int size() const; | |
15069 | bool isEmpty() const; | |
15070 | void resize(int size); | |
15071 | QByteArray &fill(char c, int size = -1); | |
15072 | int capacity() const; | |
15073 | void reserve(int size); | |
15074 | void squeeze(); | |
15075 | operator const char *() const; | |
15076 | operator const void *() const; | |
15077 | char *data(); | |
15078 | const char *data() const; | |
15079 | inline const char *constData() const; | |
15080 | inline void detach(); | |
15081 | bool isDetached() const; | |
15082 | void clear(); | |
15083 | char at(int i) const; | |
15084 | char operator[](int i) const; | |
15085 | char operator[](uint i) const; | |
15086 | QByteRef operator[](int i); | |
15087 | QByteRef operator[](uint i); | |
15088 | int indexOf(char c, int from = 0) const; | |
15089 | int indexOf(const char *c, int from = 0) const; | |
15090 | int indexOf(const QByteArray &a, int from = 0) const; | |
15091 | int lastIndexOf(char c, int from = -1) const; | |
15092 | int lastIndexOf(const char *c, int from = -1) const; | |
15093 | int lastIndexOf(const QByteArray &a, int from = -1) const; | |
15094 | QBool contains(char c) const; | |
15095 | QBool contains(const char *a) const; | |
15096 | QBool contains(const QByteArray &a) const; | |
15097 | int count(char c) const; | |
15098 | int count(const char *a) const; | |
15099 | int count(const QByteArray &a) const; | |
15100 | QByteArray left(int len) const; | |
15101 | QByteArray right(int len) const; | |
15102 | QByteArray mid(int index, int len = -1) const; | |
15103 | bool startsWith(const QByteArray &a) const; | |
15104 | bool startsWith(char c) const; | |
15105 | bool startsWith(const char *c) const; | |
15106 | bool endsWith(const QByteArray &a) const; | |
15107 | bool endsWith(char c) const; | |
15108 | bool endsWith(const char *c) const; | |
15109 | void truncate(int pos); | |
15110 | void chop(int n); | |
15111 | QByteArray toLower() const; | |
15112 | QByteArray toUpper() const; | |
15113 | QByteArray trimmed() const; | |
15114 | QByteArray simplified() const; | |
15115 | QByteArray leftJustified(int width, char fill = ' ', bool truncate = false) const; | |
15116 | QByteArray rightJustified(int width, char fill = ' ', bool truncate = false) const; | |
15117 | QByteArray &prepend(char c); | |
15118 | QByteArray &prepend(const char *s); | |
15119 | QByteArray &prepend(const QByteArray &a); | |
15120 | QByteArray &append(char c); | |
15121 | QByteArray &append(const char *s); | |
15122 | QByteArray &append(const char *s, int len); | |
15123 | QByteArray &append(const QByteArray &a); | |
15124 | QByteArray &insert(int i, char c); | |
15125 | QByteArray &insert(int i, const char *s); | |
15126 | QByteArray &insert(int i, const QByteArray &a); | |
15127 | QByteArray &remove(int index, int len); | |
15128 | QByteArray &replace(int index, int len, const char *s); | |
15129 | QByteArray &replace(int index, int len, const QByteArray &s); | |
15130 | QByteArray &replace(char before, const char *after); | |
15131 | QByteArray &replace(char before, const QByteArray &after); | |
15132 | QByteArray &replace(const char *before, const char *after); | |
15133 | QByteArray &replace(const char *before, int bsize, const char *after, int asize); | |
15134 | QByteArray &replace(const QByteArray &before, const QByteArray &after); | |
15135 | QByteArray &replace(const QByteArray &before, const char *after); | |
15136 | QByteArray &replace(const char *before, const QByteArray &after); | |
15137 | QByteArray &replace(char before, char after); | |
15138 | QByteArray &operator+=(char c); | |
15139 | QByteArray &operator+=(const char *s); | |
15140 | QByteArray &operator+=(const QByteArray &a); | |
15141 | QList<QByteArray> split(char sep) const; | |
15142 | QByteArray repeated(int times) const; | |
15143 | inline __attribute__ ((__deprecated__)) bool operator==(const QString &s2) const; | |
15144 | inline __attribute__ ((__deprecated__)) bool operator!=(const QString &s2) const; | |
15145 | inline __attribute__ ((__deprecated__)) bool operator<(const QString &s2) const; | |
15146 | inline __attribute__ ((__deprecated__)) bool operator>(const QString &s2) const; | |
15147 | inline __attribute__ ((__deprecated__)) bool operator<=(const QString &s2) const; | |
15148 | inline __attribute__ ((__deprecated__)) bool operator>=(const QString &s2) const; | |
15149 | short toShort(bool *ok = 0, int base = 10) const; | |
15150 | ushort toUShort(bool *ok = 0, int base = 10) const; | |
15151 | int toInt(bool *ok = 0, int base = 10) const; | |
15152 | uint toUInt(bool *ok = 0, int base = 10) const; | |
15153 | long toLong(bool *ok = 0, int base = 10) const; | |
15154 | ulong toULong(bool *ok = 0, int base = 10) const; | |
15155 | qlonglong toLongLong(bool *ok = 0, int base = 10) const; | |
15156 | qulonglong toULongLong(bool *ok = 0, int base = 10) const; | |
15157 | float toFloat(bool *ok = 0) const; | |
15158 | double toDouble(bool *ok = 0) const; | |
15159 | QByteArray toBase64() const; | |
15160 | QByteArray toHex() const; | |
15161 | QByteArray toPercentEncoding(const QByteArray &exclude = QByteArray(), | |
15162 | const QByteArray &include = QByteArray(), | |
15163 | char percent = '%') const; | |
15164 | QByteArray &setNum(short, int base = 10); | |
15165 | QByteArray &setNum(ushort, int base = 10); | |
15166 | QByteArray &setNum(int, int base = 10); | |
15167 | QByteArray &setNum(uint, int base = 10); | |
15168 | QByteArray &setNum(qlonglong, int base = 10); | |
15169 | QByteArray &setNum(qulonglong, int base = 10); | |
15170 | QByteArray &setNum(float, char f = 'g', int prec = 6); | |
15171 | QByteArray &setNum(double, char f = 'g', int prec = 6); | |
15172 | static QByteArray number(int, int base = 10); | |
15173 | static QByteArray number(uint, int base = 10); | |
15174 | static QByteArray number(qlonglong, int base = 10); | |
15175 | static QByteArray number(qulonglong, int base = 10); | |
15176 | static QByteArray number(double, char f = 'g', int prec = 6); | |
15177 | static QByteArray fromRawData(const char *, int size); | |
15178 | static QByteArray fromBase64(const QByteArray &base64); | |
15179 | static QByteArray fromHex(const QByteArray &hexEncoded); | |
15180 | static QByteArray fromPercentEncoding(const QByteArray &pctEncoded, char percent = '%'); | |
15181 | typedef char *iterator; | |
15182 | typedef const char *const_iterator; | |
15183 | typedef iterator Iterator; | |
15184 | typedef const_iterator ConstIterator; | |
15185 | iterator begin(); | |
15186 | const_iterator begin() const; | |
15187 | const_iterator constBegin() const; | |
15188 | iterator end(); | |
15189 | const_iterator end() const; | |
15190 | const_iterator constEnd() const; | |
15191 | typedef const char & const_reference; | |
15192 | typedef char & reference; | |
15193 | void push_back(char c); | |
15194 | void push_back(const char *c); | |
15195 | void push_back(const QByteArray &a); | |
15196 | void push_front(char c); | |
15197 | void push_front(const char *c); | |
15198 | void push_front(const QByteArray &a); | |
15199 | inline int count() const { return d->size; } | |
15200 | int length() const { return d->size; } | |
15201 | bool isNull() const; | |
15202 | private: | |
15203 | operator QNoImplicitBoolCast() const; | |
15204 | struct Data { | |
15205 | QBasicAtomicInt ref; | |
15206 | int alloc, size; | |
15207 | char *data; | |
15208 | char array[1]; | |
15209 | }; | |
15210 | static Data shared_null; | |
15211 | static Data shared_empty; | |
15212 | Data *d; | |
15213 | QByteArray(Data *dd, int , int ) : d(dd) {} | |
15214 | void realloc(int alloc); | |
15215 | void expand(int i); | |
15216 | QByteArray nulTerminated() const; | |
15217 | friend class QByteRef; | |
15218 | friend class QString; | |
15219 | public: | |
15220 | typedef Data * DataPtr; | |
15221 | inline DataPtr &data_ptr() { return d; } | |
15222 | }; | |
15223 | inline QByteArray::QByteArray(): d(&shared_null) { d->ref.ref(); } | |
15224 | inline QByteArray::~QByteArray() { if (!d->ref.deref()) qFree(d); } | |
15225 | inline int QByteArray::size() const | |
15226 | { return d->size; } | |
15227 | inline char QByteArray::at(int i) const | |
15228 | { qt_noop(); return d->data[i]; } | |
15229 | inline char QByteArray::operator[](int i) const | |
15230 | { qt_noop(); return d->data[i]; } | |
15231 | inline char QByteArray::operator[](uint i) const | |
15232 | { qt_noop(); return d->data[i]; } | |
15233 | inline bool QByteArray::isEmpty() const | |
15234 | { return d->size == 0; } | |
15235 | inline QByteArray::operator const char *() const | |
15236 | { return d->data; } | |
15237 | inline QByteArray::operator const void *() const | |
15238 | { return d->data; } | |
15239 | inline char *QByteArray::data() | |
15240 | { detach(); return d->data; } | |
15241 | inline const char *QByteArray::data() const | |
15242 | { return d->data; } | |
15243 | inline const char *QByteArray::constData() const | |
15244 | { return d->data; } | |
15245 | inline void QByteArray::detach() | |
15246 | { if (d->ref != 1 || d->data != d->array) realloc(d->size); } | |
15247 | inline bool QByteArray::isDetached() const | |
15248 | { return d->ref == 1; } | |
15249 | inline QByteArray::QByteArray(const QByteArray &a) : d(a.d) | |
15250 | { d->ref.ref(); } | |
15251 | inline int QByteArray::capacity() const | |
15252 | { return d->alloc; } | |
15253 | inline void QByteArray::reserve(int asize) | |
15254 | { if (d->ref != 1 || asize > d->alloc) realloc(asize); } | |
15255 | inline void QByteArray::squeeze() | |
15256 | { if (d->size < d->alloc) realloc(d->size); } | |
15257 | class __attribute__((visibility("default"))) QByteRef { | |
15258 | QByteArray &a; | |
15259 | int i; | |
15260 | inline QByteRef(QByteArray &array, int idx) | |
15261 | : a(array),i(idx) {} | |
15262 | friend class QByteArray; | |
15263 | public: | |
15264 | inline operator char() const | |
15265 | { return i < a.d->size ? a.d->data[i] : 0; } | |
15266 | inline QByteRef &operator=(char c) | |
15267 | { if (i >= a.d->size) a.expand(i); else a.detach(); | |
15268 | a.d->data[i] = c; return *this; } | |
15269 | inline QByteRef &operator=(const QByteRef &c) | |
15270 | { if (i >= a.d->size) a.expand(i); else a.detach(); | |
15271 | a.d->data[i] = c.a.d->data[c.i]; return *this; } | |
15272 | inline bool operator==(char c) const | |
15273 | { return a.d->data[i] == c; } | |
15274 | inline bool operator!=(char c) const | |
15275 | { return a.d->data[i] != c; } | |
15276 | inline bool operator>(char c) const | |
15277 | { return a.d->data[i] > c; } | |
15278 | inline bool operator>=(char c) const | |
15279 | { return a.d->data[i] >= c; } | |
15280 | inline bool operator<(char c) const | |
15281 | { return a.d->data[i] < c; } | |
15282 | inline bool operator<=(char c) const | |
15283 | { return a.d->data[i] <= c; } | |
15284 | }; | |
15285 | inline QByteRef QByteArray::operator[](int i) | |
15286 | { qt_noop(); return QByteRef(*this, i); } | |
15287 | inline QByteRef QByteArray::operator[](uint i) | |
15288 | { return QByteRef(*this, i); } | |
15289 | inline QByteArray::iterator QByteArray::begin() | |
15290 | { detach(); return d->data; } | |
15291 | inline QByteArray::const_iterator QByteArray::begin() const | |
15292 | { return d->data; } | |
15293 | inline QByteArray::const_iterator QByteArray::constBegin() const | |
15294 | { return d->data; } | |
15295 | inline QByteArray::iterator QByteArray::end() | |
15296 | { detach(); return d->data + d->size; } | |
15297 | inline QByteArray::const_iterator QByteArray::end() const | |
15298 | { return d->data + d->size; } | |
15299 | inline QByteArray::const_iterator QByteArray::constEnd() const | |
15300 | { return d->data + d->size; } | |
15301 | inline QByteArray &QByteArray::operator+=(char c) | |
15302 | { return append(c); } | |
15303 | inline QByteArray &QByteArray::operator+=(const char *s) | |
15304 | { return append(s); } | |
15305 | inline QByteArray &QByteArray::operator+=(const QByteArray &a) | |
15306 | { return append(a); } | |
15307 | inline void QByteArray::push_back(char c) | |
15308 | { append(c); } | |
15309 | inline void QByteArray::push_back(const char *c) | |
15310 | { append(c); } | |
15311 | inline void QByteArray::push_back(const QByteArray &a) | |
15312 | { append(a); } | |
15313 | inline void QByteArray::push_front(char c) | |
15314 | { prepend(c); } | |
15315 | inline void QByteArray::push_front(const char *c) | |
15316 | { prepend(c); } | |
15317 | inline void QByteArray::push_front(const QByteArray &a) | |
15318 | { prepend(a); } | |
15319 | inline QBool QByteArray::contains(const QByteArray &a) const | |
15320 | { return QBool(indexOf(a) != -1); } | |
15321 | inline QBool QByteArray::contains(char c) const | |
15322 | { return QBool(indexOf(c) != -1); } | |
15323 | inline bool operator==(const QByteArray &a1, const QByteArray &a2) | |
15324 | { return (a1.size() == a2.size()) && (memcmp(a1.constData(), a2.constData(), a1.size())==0); } | |
15325 | inline bool operator==(const QByteArray &a1, const char *a2) | |
15326 | { return a2 ? qstrcmp(a1,a2) == 0 : a1.isEmpty(); } | |
15327 | inline bool operator==(const char *a1, const QByteArray &a2) | |
15328 | { return a1 ? qstrcmp(a1,a2) == 0 : a2.isEmpty(); } | |
15329 | inline bool operator!=(const QByteArray &a1, const QByteArray &a2) | |
15330 | { return !(a1==a2); } | |
15331 | inline bool operator!=(const QByteArray &a1, const char *a2) | |
15332 | { return a2 ? qstrcmp(a1,a2) != 0 : !a1.isEmpty(); } | |
15333 | inline bool operator!=(const char *a1, const QByteArray &a2) | |
15334 | { return a1 ? qstrcmp(a1,a2) != 0 : !a2.isEmpty(); } | |
15335 | inline bool operator<(const QByteArray &a1, const QByteArray &a2) | |
15336 | { return qstrcmp(a1, a2) < 0; } | |
15337 | inline bool operator<(const QByteArray &a1, const char *a2) | |
15338 | { return qstrcmp(a1, a2) < 0; } | |
15339 | inline bool operator<(const char *a1, const QByteArray &a2) | |
15340 | { return qstrcmp(a1, a2) < 0; } | |
15341 | inline bool operator<=(const QByteArray &a1, const QByteArray &a2) | |
15342 | { return qstrcmp(a1, a2) <= 0; } | |
15343 | inline bool operator<=(const QByteArray &a1, const char *a2) | |
15344 | { return qstrcmp(a1, a2) <= 0; } | |
15345 | inline bool operator<=(const char *a1, const QByteArray &a2) | |
15346 | { return qstrcmp(a1, a2) <= 0; } | |
15347 | inline bool operator>(const QByteArray &a1, const QByteArray &a2) | |
15348 | { return qstrcmp(a1, a2) > 0; } | |
15349 | inline bool operator>(const QByteArray &a1, const char *a2) | |
15350 | { return qstrcmp(a1, a2) > 0; } | |
15351 | inline bool operator>(const char *a1, const QByteArray &a2) | |
15352 | { return qstrcmp(a1, a2) > 0; } | |
15353 | inline bool operator>=(const QByteArray &a1, const QByteArray &a2) | |
15354 | { return qstrcmp(a1, a2) >= 0; } | |
15355 | inline bool operator>=(const QByteArray &a1, const char *a2) | |
15356 | { return qstrcmp(a1, a2) >= 0; } | |
15357 | inline bool operator>=(const char *a1, const QByteArray &a2) | |
15358 | { return qstrcmp(a1, a2) >= 0; } | |
15359 | inline const QByteArray operator+(const QByteArray &a1, const QByteArray &a2) | |
15360 | { return QByteArray(a1) += a2; } | |
15361 | inline const QByteArray operator+(const QByteArray &a1, const char *a2) | |
15362 | { return QByteArray(a1) += a2; } | |
15363 | inline const QByteArray operator+(const QByteArray &a1, char a2) | |
15364 | { return QByteArray(a1) += a2; } | |
15365 | inline const QByteArray operator+(const char *a1, const QByteArray &a2) | |
15366 | { return QByteArray(a1) += a2; } | |
15367 | inline const QByteArray operator+(char a1, const QByteArray &a2) | |
15368 | { return QByteArray(&a1, 1) += a2; } | |
15369 | inline QBool QByteArray::contains(const char *c) const | |
15370 | { return QBool(indexOf(c) != -1); } | |
15371 | inline QByteArray &QByteArray::replace(char before, const char *c) | |
15372 | { return replace(&before, 1, c, qstrlen(c)); } | |
15373 | inline QByteArray &QByteArray::replace(const QByteArray &before, const char *c) | |
15374 | { return replace(before.constData(), before.size(), c, qstrlen(c)); } | |
15375 | inline QByteArray &QByteArray::replace(const char *before, const char *after) | |
15376 | { return replace(before, qstrlen(before), after, qstrlen(after)); } | |
15377 | inline QByteArray &QByteArray::setNum(short n, int base) | |
15378 | { return setNum(qlonglong(n), base); } | |
15379 | inline QByteArray &QByteArray::setNum(ushort n, int base) | |
15380 | { return setNum(qulonglong(n), base); } | |
15381 | inline QByteArray &QByteArray::setNum(int n, int base) | |
15382 | { return setNum(qlonglong(n), base); } | |
15383 | inline QByteArray &QByteArray::setNum(uint n, int base) | |
15384 | { return setNum(qulonglong(n), base); } | |
15385 | inline QByteArray &QByteArray::setNum(float n, char f, int prec) | |
15386 | { return setNum(double(n),f,prec); } | |
15387 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QByteArray &); | |
15388 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QByteArray &); | |
15389 | __attribute__((visibility("default"))) QByteArray qCompress(const uchar* data, int nbytes, int compressionLevel = -1); | |
15390 | __attribute__((visibility("default"))) QByteArray qUncompress(const uchar* data, int nbytes); | |
15391 | inline QByteArray qCompress(const QByteArray& data, int compressionLevel = -1) | |
15392 | { return qCompress(reinterpret_cast<const uchar *>(data.constData()), data.size(), compressionLevel); } | |
15393 | inline QByteArray qUncompress(const QByteArray& data) | |
15394 | { return qUncompress(reinterpret_cast<const uchar*>(data.constData()), data.size()); } | |
15395 | template <> class QTypeInfo<QByteArray> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QByteArray)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QByteArray"; } }; | |
15396 | template <> inline bool qIsDetached<QByteArray>(QByteArray &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QByteArray>(QByteArray &value1, QByteArray &value2) { const QByteArray::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
15397 | typedef std::basic_string<wchar_t> QStdWString; | |
15398 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
15399 | class QCharRef; | |
15400 | class QRegExp; | |
15401 | class QStringList; | |
15402 | class QTextCodec; | |
15403 | class QLatin1String; | |
15404 | class QStringRef; | |
15405 | template <typename T> class QVector; | |
15406 | class __attribute__((visibility("default"))) QString | |
15407 | { | |
15408 | public: | |
15409 | inline QString(); | |
15410 | QString(const QChar *unicode, int size); | |
15411 | QString(QChar c); | |
15412 | QString(int size, QChar c); | |
15413 | inline QString(const QLatin1String &latin1); | |
15414 | inline QString(const QString &); | |
15415 | inline ~QString(); | |
15416 | QString &operator=(QChar c); | |
15417 | QString &operator=(const QString &); | |
15418 | inline QString &operator=(const QLatin1String &); | |
15419 | inline int size() const { return d->size; } | |
15420 | inline int count() const { return d->size; } | |
15421 | inline int length() const; | |
15422 | inline bool isEmpty() const; | |
15423 | void resize(int size); | |
15424 | QString &fill(QChar c, int size = -1); | |
15425 | void truncate(int pos); | |
15426 | void chop(int n); | |
15427 | int capacity() const; | |
15428 | inline void reserve(int size); | |
15429 | inline void squeeze() { if (d->size < d->alloc) realloc(); d->capacity = 0;} | |
15430 | inline const QChar *unicode() const; | |
15431 | inline QChar *data(); | |
15432 | inline const QChar *data() const; | |
15433 | inline const QChar *constData() const; | |
15434 | inline void detach(); | |
15435 | inline bool isDetached() const; | |
15436 | void clear(); | |
15437 | inline const QChar at(int i) const; | |
15438 | const QChar operator[](int i) const; | |
15439 | QCharRef operator[](int i); | |
15440 | const QChar operator[](uint i) const; | |
15441 | QCharRef operator[](uint i); | |
15442 | QString arg(qlonglong a, int fieldwidth=0, int base=10, | |
15443 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15444 | QString arg(qulonglong a, int fieldwidth=0, int base=10, | |
15445 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15446 | QString arg(long a, int fieldwidth=0, int base=10, | |
15447 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15448 | QString arg(ulong a, int fieldwidth=0, int base=10, | |
15449 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15450 | QString arg(int a, int fieldWidth = 0, int base = 10, | |
15451 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15452 | QString arg(uint a, int fieldWidth = 0, int base = 10, | |
15453 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15454 | QString arg(short a, int fieldWidth = 0, int base = 10, | |
15455 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15456 | QString arg(ushort a, int fieldWidth = 0, int base = 10, | |
15457 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15458 | QString arg(double a, int fieldWidth = 0, char fmt = 'g', int prec = -1, | |
15459 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15460 | QString arg(char a, int fieldWidth = 0, | |
15461 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15462 | QString arg(QChar a, int fieldWidth = 0, | |
15463 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15464 | QString arg(const QString &a, int fieldWidth = 0, | |
15465 | const QChar &fillChar = QLatin1Char(' ')) const __attribute__ ((warn_unused_result)); | |
15466 | QString arg(const QString &a1, const QString &a2) const __attribute__ ((warn_unused_result)); | |
15467 | QString arg(const QString &a1, const QString &a2, const QString &a3) const __attribute__ ((warn_unused_result)); | |
15468 | QString arg(const QString &a1, const QString &a2, const QString &a3, | |
15469 | const QString &a4) const __attribute__ ((warn_unused_result)); | |
15470 | QString arg(const QString &a1, const QString &a2, const QString &a3, | |
15471 | const QString &a4, const QString &a5) const __attribute__ ((warn_unused_result)); | |
15472 | QString arg(const QString &a1, const QString &a2, const QString &a3, | |
15473 | const QString &a4, const QString &a5, const QString &a6) const __attribute__ ((warn_unused_result)); | |
15474 | QString arg(const QString &a1, const QString &a2, const QString &a3, | |
15475 | const QString &a4, const QString &a5, const QString &a6, | |
15476 | const QString &a7) const __attribute__ ((warn_unused_result)); | |
15477 | QString arg(const QString &a1, const QString &a2, const QString &a3, | |
15478 | const QString &a4, const QString &a5, const QString &a6, | |
15479 | const QString &a7, const QString &a8) const __attribute__ ((warn_unused_result)); | |
15480 | QString arg(const QString &a1, const QString &a2, const QString &a3, | |
15481 | const QString &a4, const QString &a5, const QString &a6, | |
15482 | const QString &a7, const QString &a8, const QString &a9) const __attribute__ ((warn_unused_result)); | |
15483 | QString &vsprintf(const char *format, va_list ap) | |
15484 | __attribute__ ((format (printf, 2, 0))) | |
15485 | ; | |
15486 | QString &sprintf(const char *format, ...) | |
15487 | __attribute__ ((format (printf, 2, 3))) | |
15488 | ; | |
15489 | int indexOf(QChar c, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15490 | int indexOf(const QString &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15491 | int indexOf(const QLatin1String &s, int from = 0, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15492 | int lastIndexOf(QChar c, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15493 | int lastIndexOf(const QString &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15494 | int lastIndexOf(const QLatin1String &s, int from = -1, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15495 | inline QBool contains(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15496 | inline QBool contains(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15497 | int count(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15498 | int count(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15499 | int indexOf(const QRegExp &, int from = 0) const; | |
15500 | int lastIndexOf(const QRegExp &, int from = -1) const; | |
15501 | inline QBool contains(const QRegExp &rx) const { return QBool(indexOf(rx) != -1); } | |
15502 | int count(const QRegExp &) const; | |
15503 | int indexOf(QRegExp &, int from = 0) const; | |
15504 | int lastIndexOf(QRegExp &, int from = -1) const; | |
15505 | inline QBool contains(QRegExp &rx) const { return QBool(indexOf(rx) != -1); } | |
15506 | enum SectionFlag { | |
15507 | SectionDefault = 0x00, | |
15508 | SectionSkipEmpty = 0x01, | |
15509 | SectionIncludeLeadingSep = 0x02, | |
15510 | SectionIncludeTrailingSep = 0x04, | |
15511 | SectionCaseInsensitiveSeps = 0x08 | |
15512 | }; | |
15513 | typedef QFlags<SectionFlag> SectionFlags; | |
15514 | QString section(QChar sep, int start, int end = -1, SectionFlags flags = SectionDefault) const; | |
15515 | QString section(const QString &in_sep, int start, int end = -1, SectionFlags flags = SectionDefault) const; | |
15516 | QString section(const QRegExp ®, int start, int end = -1, SectionFlags flags = SectionDefault) const; | |
15517 | QString left(int n) const __attribute__ ((warn_unused_result)); | |
15518 | QString right(int n) const __attribute__ ((warn_unused_result)); | |
15519 | QString mid(int position, int n = -1) const __attribute__ ((warn_unused_result)); | |
15520 | QStringRef leftRef(int n) const __attribute__ ((warn_unused_result)); | |
15521 | QStringRef rightRef(int n) const __attribute__ ((warn_unused_result)); | |
15522 | QStringRef midRef(int position, int n = -1) const __attribute__ ((warn_unused_result)); | |
15523 | bool startsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15524 | bool startsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15525 | bool startsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15526 | bool endsWith(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15527 | bool endsWith(const QLatin1String &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15528 | bool endsWith(const QChar &c, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15529 | QString leftJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result)); | |
15530 | QString rightJustified(int width, QChar fill = QLatin1Char(' '), bool trunc = false) const __attribute__ ((warn_unused_result)); | |
15531 | QString toLower() const __attribute__ ((warn_unused_result)); | |
15532 | QString toUpper() const __attribute__ ((warn_unused_result)); | |
15533 | QString toCaseFolded() const __attribute__ ((warn_unused_result)); | |
15534 | QString trimmed() const __attribute__ ((warn_unused_result)); | |
15535 | QString simplified() const __attribute__ ((warn_unused_result)); | |
15536 | QString &insert(int i, QChar c); | |
15537 | QString &insert(int i, const QChar *uc, int len); | |
15538 | inline QString &insert(int i, const QString &s) { return insert(i, s.constData(), s.length()); } | |
15539 | QString &insert(int i, const QLatin1String &s); | |
15540 | QString &append(QChar c); | |
15541 | QString &append(const QString &s); | |
15542 | QString &append(const QStringRef &s); | |
15543 | QString &append(const QLatin1String &s); | |
15544 | inline QString &prepend(QChar c) { return insert(0, c); } | |
15545 | inline QString &prepend(const QString &s) { return insert(0, s); } | |
15546 | inline QString &prepend(const QLatin1String &s) { return insert(0, s); } | |
15547 | inline QString &operator+=(QChar c) { | |
15548 | if (d->ref != 1 || d->size + 1 > d->alloc) | |
15549 | realloc(grow(d->size + 1)); | |
15550 | d->data[d->size++] = c.unicode(); | |
15551 | d->data[d->size] = '\0'; | |
15552 | return *this; | |
15553 | } | |
15554 | inline QString &operator+=(QChar::SpecialCharacter c) { return append(QChar(c)); } | |
15555 | inline QString &operator+=(const QString &s) { return append(s); } | |
15556 | inline QString &operator+=(const QStringRef &s) { return append(s); } | |
15557 | inline QString &operator+=(const QLatin1String &s) { return append(s); } | |
15558 | QString &remove(int i, int len); | |
15559 | QString &remove(QChar c, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15560 | QString &remove(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15561 | QString &replace(int i, int len, QChar after); | |
15562 | QString &replace(int i, int len, const QChar *s, int slen); | |
15563 | QString &replace(int i, int len, const QString &after); | |
15564 | QString &replace(QChar before, QChar after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15565 | QString &replace(const QChar *before, int blen, const QChar *after, int alen, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15566 | QString &replace(const QLatin1String &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15567 | QString &replace(const QLatin1String &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15568 | QString &replace(const QString &before, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15569 | QString &replace(const QString &before, const QString &after, | |
15570 | Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15571 | QString &replace(QChar c, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15572 | QString &replace(QChar c, const QLatin1String &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15573 | QString &replace(const QRegExp &rx, const QString &after); | |
15574 | inline QString &remove(const QRegExp &rx) | |
15575 | { return replace(rx, QString()); } | |
15576 | enum SplitBehavior { KeepEmptyParts, SkipEmptyParts }; | |
15577 | QStringList split(const QString &sep, SplitBehavior behavior = KeepEmptyParts, | |
15578 | Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result)); | |
15579 | QStringList split(const QChar &sep, SplitBehavior behavior = KeepEmptyParts, | |
15580 | Qt::CaseSensitivity cs = Qt::CaseSensitive) const __attribute__ ((warn_unused_result)); | |
15581 | QStringList split(const QRegExp &sep, SplitBehavior behavior = KeepEmptyParts) const __attribute__ ((warn_unused_result)); | |
15582 | enum NormalizationForm { | |
15583 | NormalizationForm_D, | |
15584 | NormalizationForm_C, | |
15585 | NormalizationForm_KD, | |
15586 | NormalizationForm_KC | |
15587 | }; | |
15588 | QString normalized(NormalizationForm mode) const __attribute__ ((warn_unused_result)); | |
15589 | QString normalized(NormalizationForm mode, QChar::UnicodeVersion version) const __attribute__ ((warn_unused_result)); | |
15590 | QString repeated(int times) const; | |
15591 | const ushort *utf16() const; | |
15592 | QByteArray toAscii() const __attribute__ ((warn_unused_result)); | |
15593 | QByteArray toLatin1() const __attribute__ ((warn_unused_result)); | |
15594 | QByteArray toUtf8() const __attribute__ ((warn_unused_result)); | |
15595 | QByteArray toLocal8Bit() const __attribute__ ((warn_unused_result)); | |
15596 | QVector<uint> toUcs4() const __attribute__ ((warn_unused_result)); | |
15597 | static QString fromAscii(const char *, int size = -1); | |
15598 | static QString fromLatin1(const char *, int size = -1); | |
15599 | static QString fromUtf8(const char *, int size = -1); | |
15600 | static QString fromLocal8Bit(const char *, int size = -1); | |
15601 | static QString fromUtf16(const ushort *, int size = -1); | |
15602 | static QString fromUcs4(const uint *, int size = -1); | |
15603 | static QString fromRawData(const QChar *, int size); | |
15604 | int toWCharArray(wchar_t *array) const; | |
15605 | static QString fromWCharArray(const wchar_t *, int size = -1); | |
15606 | QString &setUnicode(const QChar *unicode, int size); | |
15607 | inline QString &setUtf16(const ushort *utf16, int size); | |
15608 | int compare(const QString &s) const; | |
15609 | int compare(const QString &s, Qt::CaseSensitivity cs) const; | |
15610 | int compare(const QLatin1String &other, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15611 | static inline int compare(const QString &s1, const QString &s2) | |
15612 | { return s1.compare(s2); } | |
15613 | static inline int compare(const QString &s1, const QString &s2, Qt::CaseSensitivity cs) | |
15614 | { return s1.compare(s2, cs); } | |
15615 | static inline int compare(const QString& s1, const QLatin1String &s2, | |
15616 | Qt::CaseSensitivity cs = Qt::CaseSensitive) | |
15617 | { return s1.compare(s2, cs); } | |
15618 | static inline int compare(const QLatin1String& s1, const QString &s2, | |
15619 | Qt::CaseSensitivity cs = Qt::CaseSensitive) | |
15620 | { return -s2.compare(s1, cs); } | |
15621 | int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
15622 | static int compare(const QString &s1, const QStringRef &s2, | |
15623 | Qt::CaseSensitivity = Qt::CaseSensitive); | |
15624 | int localeAwareCompare(const QString& s) const; | |
15625 | static int localeAwareCompare(const QString& s1, const QString& s2) | |
15626 | { return s1.localeAwareCompare(s2); } | |
15627 | int localeAwareCompare(const QStringRef &s) const; | |
15628 | static int localeAwareCompare(const QString& s1, const QStringRef& s2); | |
15629 | short toShort(bool *ok=0, int base=10) const; | |
15630 | ushort toUShort(bool *ok=0, int base=10) const; | |
15631 | int toInt(bool *ok=0, int base=10) const; | |
15632 | uint toUInt(bool *ok=0, int base=10) const; | |
15633 | long toLong(bool *ok=0, int base=10) const; | |
15634 | ulong toULong(bool *ok=0, int base=10) const; | |
15635 | qlonglong toLongLong(bool *ok=0, int base=10) const; | |
15636 | qulonglong toULongLong(bool *ok=0, int base=10) const; | |
15637 | float toFloat(bool *ok=0) const; | |
15638 | double toDouble(bool *ok=0) const; | |
15639 | QString &setNum(short, int base=10); | |
15640 | QString &setNum(ushort, int base=10); | |
15641 | QString &setNum(int, int base=10); | |
15642 | QString &setNum(uint, int base=10); | |
15643 | QString &setNum(long, int base=10); | |
15644 | QString &setNum(ulong, int base=10); | |
15645 | QString &setNum(qlonglong, int base=10); | |
15646 | QString &setNum(qulonglong, int base=10); | |
15647 | QString &setNum(float, char f='g', int prec=6); | |
15648 | QString &setNum(double, char f='g', int prec=6); | |
15649 | static QString number(int, int base=10); | |
15650 | static QString number(uint, int base=10); | |
15651 | static QString number(long, int base=10); | |
15652 | static QString number(ulong, int base=10); | |
15653 | static QString number(qlonglong, int base=10); | |
15654 | static QString number(qulonglong, int base=10); | |
15655 | static QString number(double, char f='g', int prec=6); | |
15656 | bool operator==(const QString &s) const; | |
15657 | bool operator<(const QString &s) const; | |
15658 | inline bool operator>(const QString &s) const { return s < *this; } | |
15659 | inline bool operator!=(const QString &s) const { return !operator==(s); } | |
15660 | inline bool operator<=(const QString &s) const { return !operator>(s); } | |
15661 | inline bool operator>=(const QString &s) const { return !operator<(s); } | |
15662 | bool operator==(const QLatin1String &s) const; | |
15663 | bool operator<(const QLatin1String &s) const; | |
15664 | bool operator>(const QLatin1String &s) const; | |
15665 | inline bool operator!=(const QLatin1String &s) const { return !operator==(s); } | |
15666 | inline bool operator<=(const QLatin1String &s) const { return !operator>(s); } | |
15667 | inline bool operator>=(const QLatin1String &s) const { return !operator<(s); } | |
15668 | inline __attribute__ ((__deprecated__)) QString(const char *ch) : d(fromAscii_helper(ch)) | |
15669 | {} | |
15670 | inline __attribute__ ((__deprecated__)) QString(const QByteArray &a) | |
15671 | : d(fromAscii_helper(a.constData(), qstrnlen(a.constData(), a.size()))) | |
15672 | {} | |
15673 | inline __attribute__ ((__deprecated__)) QString &operator=(const char *ch) | |
15674 | { return (*this = fromAscii(ch)); } | |
15675 | inline __attribute__ ((__deprecated__)) QString &operator=(const QByteArray &a) | |
15676 | { return (*this = fromAscii(a.constData(), qstrnlen(a.constData(), a.size()))); } | |
15677 | inline __attribute__ ((__deprecated__)) QString &operator=(char c) | |
15678 | { return (*this = QChar::fromAscii(c)); } | |
15679 | inline __attribute__ ((__deprecated__)) QString &prepend(const char *s) | |
15680 | { return prepend(QString::fromAscii(s)); } | |
15681 | inline __attribute__ ((__deprecated__)) QString &prepend(const QByteArray &s) | |
15682 | { return prepend(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); } | |
15683 | inline __attribute__ ((__deprecated__)) QString &append(const char *s) | |
15684 | { return append(QString::fromAscii(s)); } | |
15685 | inline __attribute__ ((__deprecated__)) QString &append(const QByteArray &s) | |
15686 | { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); } | |
15687 | inline __attribute__ ((__deprecated__)) QString &operator+=(const char *s) | |
15688 | { return append(QString::fromAscii(s)); } | |
15689 | inline __attribute__ ((__deprecated__)) QString &operator+=(const QByteArray &s) | |
15690 | { return append(QString::fromAscii(s.constData(), qstrnlen(s.constData(), s.size()))); } | |
15691 | inline __attribute__ ((__deprecated__)) QString &operator+=(char c) | |
15692 | { return append(QChar::fromAscii(c)); } | |
15693 | inline __attribute__ ((__deprecated__)) bool operator==(const char *s) const; | |
15694 | inline __attribute__ ((__deprecated__)) bool operator!=(const char *s) const; | |
15695 | inline __attribute__ ((__deprecated__)) bool operator<(const char *s) const; | |
15696 | inline __attribute__ ((__deprecated__)) bool operator<=(const char *s2) const; | |
15697 | inline __attribute__ ((__deprecated__)) bool operator>(const char *s2) const; | |
15698 | inline __attribute__ ((__deprecated__)) bool operator>=(const char *s2) const; | |
15699 | inline __attribute__ ((__deprecated__)) bool operator==(const QByteArray &s) const; | |
15700 | inline __attribute__ ((__deprecated__)) bool operator!=(const QByteArray &s) const; | |
15701 | inline __attribute__ ((__deprecated__)) bool operator<(const QByteArray &s) const | |
15702 | { return *this < QString::fromAscii(s.constData(), s.size()); } | |
15703 | inline __attribute__ ((__deprecated__)) bool operator>(const QByteArray &s) const | |
15704 | { return *this > QString::fromAscii(s.constData(), s.size()); } | |
15705 | inline __attribute__ ((__deprecated__)) bool operator<=(const QByteArray &s) const | |
15706 | { return *this <= QString::fromAscii(s.constData(), s.size()); } | |
15707 | inline __attribute__ ((__deprecated__)) bool operator>=(const QByteArray &s) const | |
15708 | { return *this >= QString::fromAscii(s.constData(), s.size()); } | |
15709 | typedef QChar *iterator; | |
15710 | typedef const QChar *const_iterator; | |
15711 | typedef iterator Iterator; | |
15712 | typedef const_iterator ConstIterator; | |
15713 | iterator begin(); | |
15714 | const_iterator begin() const; | |
15715 | const_iterator constBegin() const; | |
15716 | iterator end(); | |
15717 | const_iterator end() const; | |
15718 | const_iterator constEnd() const; | |
15719 | inline void push_back(QChar c) { append(c); } | |
15720 | inline void push_back(const QString &s) { append(s); } | |
15721 | inline void push_front(QChar c) { prepend(c); } | |
15722 | inline void push_front(const QString &s) { prepend(s); } | |
15723 | static inline QString fromStdString(const std::string &s); | |
15724 | inline std::string toStdString() const; | |
15725 | static inline QString fromStdWString(const QStdWString &s); | |
15726 | inline QStdWString toStdWString() const; | |
15727 | struct Null { }; | |
15728 | static const Null null; | |
15729 | inline QString(const Null &): d(&shared_null) { d->ref.ref(); } | |
15730 | inline QString &operator=(const Null &) { *this = QString(); return *this; } | |
15731 | inline bool isNull() const { return d == &shared_null; } | |
15732 | bool isSimpleText() const { if (!d->clean) updateProperties(); return d->simpletext; } | |
15733 | bool isRightToLeft() const { if (!d->clean) updateProperties(); return d->righttoleft; } | |
15734 | private: | |
15735 | struct Data { | |
15736 | QBasicAtomicInt ref; | |
15737 | int alloc, size; | |
15738 | ushort *data; | |
15739 | ushort clean : 1; | |
15740 | ushort simpletext : 1; | |
15741 | ushort righttoleft : 1; | |
15742 | ushort asciiCache : 1; | |
15743 | ushort capacity : 1; | |
15744 | ushort reserved : 11; | |
15745 | ushort array[1]; | |
15746 | }; | |
15747 | static Data shared_null; | |
15748 | static Data shared_empty; | |
15749 | Data *d; | |
15750 | QString(Data *dd, int ) : d(dd) {} | |
15751 | static QTextCodec *codecForCStrings; | |
15752 | static int grow(int); | |
15753 | static void free(Data *); | |
15754 | void realloc(); | |
15755 | void realloc(int alloc); | |
15756 | void expand(int i); | |
15757 | void updateProperties() const; | |
15758 | QString multiArg(int numArgs, const QString **args) const; | |
15759 | static int compare_helper(const QChar *data1, int length1, | |
15760 | const QChar *data2, int length2, | |
15761 | Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15762 | static int compare_helper(const QChar *data1, int length1, | |
15763 | QLatin1String s2, | |
15764 | Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
15765 | static int localeAwareCompare_helper(const QChar *data1, int length1, | |
15766 | const QChar *data2, int length2); | |
15767 | static Data *fromLatin1_helper(const char *str, int size = -1); | |
15768 | static Data *fromAscii_helper(const char *str, int size = -1); | |
15769 | void replace_helper(uint *indices, int nIndices, int blen, const QChar *after, int alen); | |
15770 | friend class QCharRef; | |
15771 | friend class QTextCodec; | |
15772 | friend class QStringRef; | |
15773 | friend inline bool qStringComparisonHelper(const QString &s1, const char *s2); | |
15774 | friend inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2); | |
15775 | public: | |
15776 | typedef Data * DataPtr; | |
15777 | inline DataPtr &data_ptr() { return d; } | |
15778 | }; | |
15779 | class __attribute__((visibility("default"))) QLatin1String | |
15780 | { | |
15781 | public: | |
15782 | inline explicit QLatin1String(const char *s) : chars(s) {} | |
15783 | inline QLatin1String &operator=(const QLatin1String &other) | |
15784 | { chars = other.chars; return *this; } | |
15785 | inline const char *latin1() const { return chars; } | |
15786 | inline bool operator==(const QString &s) const | |
15787 | { return s == *this; } | |
15788 | inline bool operator!=(const QString &s) const | |
15789 | { return s != *this; } | |
15790 | inline bool operator>(const QString &s) const | |
15791 | { return s < *this; } | |
15792 | inline bool operator<(const QString &s) const | |
15793 | { return s > *this; } | |
15794 | inline bool operator>=(const QString &s) const | |
15795 | { return s <= *this; } | |
15796 | inline bool operator<=(const QString &s) const | |
15797 | { return s >= *this; } | |
15798 | inline __attribute__ ((__deprecated__)) bool operator==(const char *s) const | |
15799 | { return QString::fromAscii(s) == *this; } | |
15800 | inline __attribute__ ((__deprecated__)) bool operator!=(const char *s) const | |
15801 | { return QString::fromAscii(s) != *this; } | |
15802 | inline __attribute__ ((__deprecated__)) bool operator<(const char *s) const | |
15803 | { return QString::fromAscii(s) > *this; } | |
15804 | inline __attribute__ ((__deprecated__)) bool operator>(const char *s) const | |
15805 | { return QString::fromAscii(s) < *this; } | |
15806 | inline __attribute__ ((__deprecated__)) bool operator<=(const char *s) const | |
15807 | { return QString::fromAscii(s) >= *this; } | |
15808 | inline __attribute__ ((__deprecated__)) bool operator>=(const char *s) const | |
15809 | { return QString::fromAscii(s) <= *this; } | |
15810 | private: | |
15811 | const char *chars; | |
15812 | }; | |
15813 | inline QString::QString(const QLatin1String &aLatin1) : d(fromLatin1_helper(aLatin1.latin1())) | |
15814 | { } | |
15815 | inline int QString::length() const | |
15816 | { return d->size; } | |
15817 | inline const QChar QString::at(int i) const | |
15818 | { qt_noop(); return d->data[i]; } | |
15819 | inline const QChar QString::operator[](int i) const | |
15820 | { qt_noop(); return d->data[i]; } | |
15821 | inline const QChar QString::operator[](uint i) const | |
15822 | { qt_noop(); return d->data[i]; } | |
15823 | inline bool QString::isEmpty() const | |
15824 | { return d->size == 0; } | |
15825 | inline const QChar *QString::unicode() const | |
15826 | { return reinterpret_cast<const QChar*>(d->data); } | |
15827 | inline const QChar *QString::data() const | |
15828 | { return reinterpret_cast<const QChar*>(d->data); } | |
15829 | inline QChar *QString::data() | |
15830 | { detach(); return reinterpret_cast<QChar*>(d->data); } | |
15831 | inline const QChar *QString::constData() const | |
15832 | { return reinterpret_cast<const QChar*>(d->data); } | |
15833 | inline void QString::detach() | |
15834 | { if (d->ref != 1 || d->data != d->array) realloc(); } | |
15835 | inline bool QString::isDetached() const | |
15836 | { return d->ref == 1; } | |
15837 | inline QString &QString::operator=(const QLatin1String &s) | |
15838 | { | |
15839 | *this = fromLatin1(s.latin1()); | |
15840 | return *this; | |
15841 | } | |
15842 | inline void QString::clear() | |
15843 | { if (!isNull()) *this = QString(); } | |
15844 | inline QString::QString(const QString &other) : d(other.d) | |
15845 | { qt_noop(); d->ref.ref(); } | |
15846 | inline int QString::capacity() const | |
15847 | { return d->alloc; } | |
15848 | inline QString &QString::setNum(short n, int base) | |
15849 | { return setNum(qlonglong(n), base); } | |
15850 | inline QString &QString::setNum(ushort n, int base) | |
15851 | { return setNum(qulonglong(n), base); } | |
15852 | inline QString &QString::setNum(int n, int base) | |
15853 | { return setNum(qlonglong(n), base); } | |
15854 | inline QString &QString::setNum(uint n, int base) | |
15855 | { return setNum(qulonglong(n), base); } | |
15856 | inline QString &QString::setNum(long n, int base) | |
15857 | { return setNum(qlonglong(n), base); } | |
15858 | inline QString &QString::setNum(ulong n, int base) | |
15859 | { return setNum(qulonglong(n), base); } | |
15860 | inline QString &QString::setNum(float n, char f, int prec) | |
15861 | { return setNum(double(n),f,prec); } | |
15862 | inline QString QString::arg(int a, int fieldWidth, int base, const QChar &fillChar) const | |
15863 | { return arg(qlonglong(a), fieldWidth, base, fillChar); } | |
15864 | inline QString QString::arg(uint a, int fieldWidth, int base, const QChar &fillChar) const | |
15865 | { return arg(qulonglong(a), fieldWidth, base, fillChar); } | |
15866 | inline QString QString::arg(long a, int fieldWidth, int base, const QChar &fillChar) const | |
15867 | { return arg(qlonglong(a), fieldWidth, base, fillChar); } | |
15868 | inline QString QString::arg(ulong a, int fieldWidth, int base, const QChar &fillChar) const | |
15869 | { return arg(qulonglong(a), fieldWidth, base, fillChar); } | |
15870 | inline QString QString::arg(short a, int fieldWidth, int base, const QChar &fillChar) const | |
15871 | { return arg(qlonglong(a), fieldWidth, base, fillChar); } | |
15872 | inline QString QString::arg(ushort a, int fieldWidth, int base, const QChar &fillChar) const | |
15873 | { return arg(qulonglong(a), fieldWidth, base, fillChar); } | |
15874 | inline QString QString::arg(const QString &a1, const QString &a2) const | |
15875 | { const QString *args[2] = { &a1, &a2 }; return multiArg(2, args); } | |
15876 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3) const | |
15877 | { const QString *args[3] = { &a1, &a2, &a3 }; return multiArg(3, args); } | |
15878 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, | |
15879 | const QString &a4) const | |
15880 | { const QString *args[4] = { &a1, &a2, &a3, &a4 }; return multiArg(4, args); } | |
15881 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, | |
15882 | const QString &a4, const QString &a5) const | |
15883 | { const QString *args[5] = { &a1, &a2, &a3, &a4, &a5 }; return multiArg(5, args); } | |
15884 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, | |
15885 | const QString &a4, const QString &a5, const QString &a6) const | |
15886 | { const QString *args[6] = { &a1, &a2, &a3, &a4, &a5, &a6 }; return multiArg(6, args); } | |
15887 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, | |
15888 | const QString &a4, const QString &a5, const QString &a6, | |
15889 | const QString &a7) const | |
15890 | { const QString *args[7] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7 }; return multiArg(7, args); } | |
15891 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, | |
15892 | const QString &a4, const QString &a5, const QString &a6, | |
15893 | const QString &a7, const QString &a8) const | |
15894 | { const QString *args[8] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8 }; return multiArg(8, args); } | |
15895 | inline QString QString::arg(const QString &a1, const QString &a2, const QString &a3, | |
15896 | const QString &a4, const QString &a5, const QString &a6, | |
15897 | const QString &a7, const QString &a8, const QString &a9) const | |
15898 | { const QString *args[9] = { &a1, &a2, &a3, &a4, &a5, &a6, &a7, &a8, &a9 }; return multiArg(9, args); } | |
15899 | inline QString QString::section(QChar asep, int astart, int aend, SectionFlags aflags) const | |
15900 | { return section(QString(asep), astart, aend, aflags); } | |
15901 | class __attribute__((visibility("default"))) QCharRef { | |
15902 | QString &s; | |
15903 | int i; | |
15904 | inline QCharRef(QString &str, int idx) | |
15905 | : s(str),i(idx) {} | |
15906 | friend class QString; | |
15907 | public: | |
15908 | inline operator QChar() const | |
15909 | { return i < s.d->size ? s.d->data[i] : 0; } | |
15910 | inline QCharRef &operator=(const QChar &c) | |
15911 | { if (i >= s.d->size) s.expand(i); else s.detach(); | |
15912 | s.d->data[i] = c.unicode(); return *this; } | |
15913 | inline __attribute__ ((__deprecated__)) QCharRef &operator=(char c) | |
15914 | { return operator=(QChar::fromAscii(c)); } | |
15915 | inline __attribute__ ((__deprecated__)) QCharRef &operator=(uchar c) | |
15916 | { return operator=(QChar::fromAscii(c)); } | |
15917 | inline QCharRef &operator=(const QCharRef &c) { return operator=(QChar(c)); } | |
15918 | inline QCharRef &operator=(ushort rc) { return operator=(QChar(rc)); } | |
15919 | inline QCharRef &operator=(short rc) { return operator=(QChar(rc)); } | |
15920 | inline QCharRef &operator=(uint rc) { return operator=(QChar(rc)); } | |
15921 | inline QCharRef &operator=(int rc) { return operator=(QChar(rc)); } | |
15922 | inline bool isNull() const { return QChar(*this).isNull(); } | |
15923 | inline bool isPrint() const { return QChar(*this).isPrint(); } | |
15924 | inline bool isPunct() const { return QChar(*this).isPunct(); } | |
15925 | inline bool isSpace() const { return QChar(*this).isSpace(); } | |
15926 | inline bool isMark() const { return QChar(*this).isMark(); } | |
15927 | inline bool isLetter() const { return QChar(*this).isLetter(); } | |
15928 | inline bool isNumber() const { return QChar(*this).isNumber(); } | |
15929 | inline bool isLetterOrNumber() { return QChar(*this).isLetterOrNumber(); } | |
15930 | inline bool isDigit() const { return QChar(*this).isDigit(); } | |
15931 | inline bool isLower() const { return QChar(*this).isLower(); } | |
15932 | inline bool isUpper() const { return QChar(*this).isUpper(); } | |
15933 | inline bool isTitleCase() const { return QChar(*this).isTitleCase(); } | |
15934 | inline int digitValue() const { return QChar(*this).digitValue(); } | |
15935 | QChar toLower() const { return QChar(*this).toLower(); } | |
15936 | QChar toUpper() const { return QChar(*this).toUpper(); } | |
15937 | QChar toTitleCase () const { return QChar(*this).toTitleCase(); } | |
15938 | QChar::Category category() const { return QChar(*this).category(); } | |
15939 | QChar::Direction direction() const { return QChar(*this).direction(); } | |
15940 | QChar::Joining joining() const { return QChar(*this).joining(); } | |
15941 | bool hasMirrored() const { return QChar(*this).hasMirrored(); } | |
15942 | QChar mirroredChar() const { return QChar(*this).mirroredChar(); } | |
15943 | QString decomposition() const { return QChar(*this).decomposition(); } | |
15944 | QChar::Decomposition decompositionTag() const { return QChar(*this).decompositionTag(); } | |
15945 | uchar combiningClass() const { return QChar(*this).combiningClass(); } | |
15946 | QChar::UnicodeVersion unicodeVersion() const { return QChar(*this).unicodeVersion(); } | |
15947 | inline uchar cell() const { return QChar(*this).cell(); } | |
15948 | inline uchar row() const { return QChar(*this).row(); } | |
15949 | inline void setCell(uchar cell); | |
15950 | inline void setRow(uchar row); | |
15951 | char toAscii() const { return QChar(*this).toAscii(); } | |
15952 | char toLatin1() const { return QChar(*this).toLatin1(); } | |
15953 | ushort unicode() const { return QChar(*this).unicode(); } | |
15954 | ushort& unicode() { return s.data()[i].unicode(); } | |
15955 | }; | |
15956 | inline void QCharRef::setRow(uchar arow) { QChar(*this).setRow(arow); } | |
15957 | inline void QCharRef::setCell(uchar acell) { QChar(*this).setCell(acell); } | |
15958 | inline QString::QString() : d(&shared_null) { d->ref.ref(); } | |
15959 | inline QString::~QString() { if (!d->ref.deref()) free(d); } | |
15960 | inline void QString::reserve(int asize) { if (d->ref != 1 || asize > d->alloc) realloc(asize); d->capacity = 1;} | |
15961 | inline QString &QString::setUtf16(const ushort *autf16, int asize) | |
15962 | { return setUnicode(reinterpret_cast<const QChar *>(autf16), asize); } | |
15963 | inline QCharRef QString::operator[](int i) | |
15964 | { qt_noop(); return QCharRef(*this, i); } | |
15965 | inline QCharRef QString::operator[](uint i) | |
15966 | { return QCharRef(*this, i); } | |
15967 | inline QString::iterator QString::begin() | |
15968 | { detach(); return reinterpret_cast<QChar*>(d->data); } | |
15969 | inline QString::const_iterator QString::begin() const | |
15970 | { return reinterpret_cast<const QChar*>(d->data); } | |
15971 | inline QString::const_iterator QString::constBegin() const | |
15972 | { return reinterpret_cast<const QChar*>(d->data); } | |
15973 | inline QString::iterator QString::end() | |
15974 | { detach(); return reinterpret_cast<QChar*>(d->data + d->size); } | |
15975 | inline QString::const_iterator QString::end() const | |
15976 | { return reinterpret_cast<const QChar*>(d->data + d->size); } | |
15977 | inline QString::const_iterator QString::constEnd() const | |
15978 | { return reinterpret_cast<const QChar*>(d->data + d->size); } | |
15979 | inline QBool QString::contains(const QString &s, Qt::CaseSensitivity cs) const | |
15980 | { return QBool(indexOf(s, 0, cs) != -1); } | |
15981 | inline QBool QString::contains(QChar c, Qt::CaseSensitivity cs) const | |
15982 | { return QBool(indexOf(c, 0, cs) != -1); } | |
15983 | inline bool operator==(QString::Null, QString::Null) { return true; } | |
15984 | inline bool operator==(QString::Null, const QString &s) { return s.isNull(); } | |
15985 | inline bool operator==(const QString &s, QString::Null) { return s.isNull(); } | |
15986 | inline bool operator!=(QString::Null, QString::Null) { return false; } | |
15987 | inline bool operator!=(QString::Null, const QString &s) { return !s.isNull(); } | |
15988 | inline bool operator!=(const QString &s, QString::Null) { return !s.isNull(); } | |
15989 | inline bool qStringComparisonHelper(const QString &s1, const char *s2) | |
15990 | { | |
15991 | if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2)); | |
15992 | return (s1 == QLatin1String(s2)); | |
15993 | } | |
15994 | inline bool QString::operator==(const char *s) const | |
15995 | { return qStringComparisonHelper(*this, s); } | |
15996 | inline bool QString::operator!=(const char *s) const | |
15997 | { return !qStringComparisonHelper(*this, s); } | |
15998 | inline bool QString::operator<(const char *s) const | |
15999 | { return *this < QString::fromAscii(s); } | |
16000 | inline bool QString::operator>(const char *s) const | |
16001 | { return *this > QString::fromAscii(s); } | |
16002 | inline bool QString::operator<=(const char *s) const | |
16003 | { return *this <= QString::fromAscii(s); } | |
16004 | inline bool QString::operator>=(const char *s) const | |
16005 | { return *this >= QString::fromAscii(s); } | |
16006 | inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QString &s2) | |
16007 | { return qStringComparisonHelper(s2, s1); } | |
16008 | inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QString &s2) | |
16009 | { return !qStringComparisonHelper(s2, s1); } | |
16010 | inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, const QString &s2) | |
16011 | { return (QString::fromAscii(s1) < s2); } | |
16012 | inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, const QString &s2) | |
16013 | { return (QString::fromAscii(s1) > s2); } | |
16014 | inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, const QString &s2) | |
16015 | { return (QString::fromAscii(s1) <= s2); } | |
16016 | inline __attribute__ ((__deprecated__)) bool operator>=(const char *s1, const QString &s2) | |
16017 | { return (QString::fromAscii(s1) >= s2); } | |
16018 | inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QLatin1String &s2) | |
16019 | { return QString::fromAscii(s1) == s2; } | |
16020 | inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QLatin1String &s2) | |
16021 | { return QString::fromAscii(s1) != s2; } | |
16022 | inline __attribute__ ((__deprecated__)) bool operator<(const char *s1, const QLatin1String &s2) | |
16023 | { return (QString::fromAscii(s1) < s2); } | |
16024 | inline __attribute__ ((__deprecated__)) bool operator>(const char *s1, const QLatin1String &s2) | |
16025 | { return (QString::fromAscii(s1) > s2); } | |
16026 | inline __attribute__ ((__deprecated__)) bool operator<=(const char *s1, const QLatin1String &s2) | |
16027 | { return (QString::fromAscii(s1) <= s2); } | |
16028 | inline __attribute__ ((__deprecated__)) bool operator>=(const char *s1, const QLatin1String &s2) | |
16029 | { return (QString::fromAscii(s1) >= s2); } | |
16030 | inline bool operator==(const QLatin1String &s1, const QLatin1String &s2) | |
16031 | { return (qstrcmp(s1.latin1(), s2.latin1()) == 0); } | |
16032 | inline bool operator!=(const QLatin1String &s1, const QLatin1String &s2) | |
16033 | { return (qstrcmp(s1.latin1(), s2.latin1()) != 0); } | |
16034 | inline bool operator<(const QLatin1String &s1, const QLatin1String &s2) | |
16035 | { return (qstrcmp(s1.latin1(), s2.latin1()) < 0); } | |
16036 | inline bool operator<=(const QLatin1String &s1, const QLatin1String &s2) | |
16037 | { return (qstrcmp(s1.latin1(), s2.latin1()) <= 0); } | |
16038 | inline bool operator>(const QLatin1String &s1, const QLatin1String &s2) | |
16039 | { return (qstrcmp(s1.latin1(), s2.latin1()) > 0); } | |
16040 | inline bool operator>=(const QLatin1String &s1, const QLatin1String &s2) | |
16041 | { return (qstrcmp(s1.latin1(), s2.latin1()) >= 0); } | |
16042 | inline bool QString::operator==(const QByteArray &s) const | |
16043 | { return qStringComparisonHelper(*this, s.constData()); } | |
16044 | inline bool QString::operator!=(const QByteArray &s) const | |
16045 | { return !qStringComparisonHelper(*this, s.constData()); } | |
16046 | inline bool QByteArray::operator==(const QString &s) const | |
16047 | { return qStringComparisonHelper(s, constData()); } | |
16048 | inline bool QByteArray::operator!=(const QString &s) const | |
16049 | { return !qStringComparisonHelper(s, constData()); } | |
16050 | inline bool QByteArray::operator<(const QString &s) const | |
16051 | { return QString::fromAscii(constData(), size()) < s; } | |
16052 | inline bool QByteArray::operator>(const QString &s) const | |
16053 | { return QString::fromAscii(constData(), size()) > s; } | |
16054 | inline bool QByteArray::operator<=(const QString &s) const | |
16055 | { return QString::fromAscii(constData(), size()) <= s; } | |
16056 | inline bool QByteArray::operator>=(const QString &s) const | |
16057 | { return QString::fromAscii(constData(), size()) >= s; } | |
16058 | inline const QString operator+(const QString &s1, const QString &s2) | |
16059 | { QString t(s1); t += s2; return t; } | |
16060 | inline const QString operator+(const QString &s1, QChar s2) | |
16061 | { QString t(s1); t += s2; return t; } | |
16062 | inline const QString operator+(QChar s1, const QString &s2) | |
16063 | { QString t(s1); t += s2; return t; } | |
16064 | inline __attribute__ ((__deprecated__)) const QString operator+(const QString &s1, const char *s2) | |
16065 | { QString t(s1); t += QString::fromAscii(s2); return t; } | |
16066 | inline __attribute__ ((__deprecated__)) const QString operator+(const char *s1, const QString &s2) | |
16067 | { QString t = QString::fromAscii(s1); t += s2; return t; } | |
16068 | inline __attribute__ ((__deprecated__)) const QString operator+(char c, const QString &s) | |
16069 | { QString t = s; t.prepend(QChar::fromAscii(c)); return t; } | |
16070 | inline __attribute__ ((__deprecated__)) const QString operator+(const QString &s, char c) | |
16071 | { QString t = s; t += QChar::fromAscii(c); return t; } | |
16072 | inline __attribute__ ((__deprecated__)) const QString operator+(const QByteArray &ba, const QString &s) | |
16073 | { QString t = QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); t += s; return t; } | |
16074 | inline __attribute__ ((__deprecated__)) const QString operator+(const QString &s, const QByteArray &ba) | |
16075 | { QString t(s); t += QString::fromAscii(ba.constData(), qstrnlen(ba.constData(), ba.size())); return t; } | |
16076 | inline std::string QString::toStdString() const | |
16077 | { const QByteArray asc = toAscii(); return std::string(asc.constData(), asc.length()); } | |
16078 | inline QString QString::fromStdString(const std::string &s) | |
16079 | { return fromAscii(s.data(), int(s.size())); } | |
16080 | inline QStdWString QString::toStdWString() const | |
16081 | { | |
16082 | QStdWString str; | |
16083 | str.resize(length()); | |
16084 | str.resize(toWCharArray(&(*str.begin()))); | |
16085 | return str; | |
16086 | } | |
16087 | inline QString QString::fromStdWString(const QStdWString &s) | |
16088 | { return fromWCharArray(s.data(), int(s.size())); } | |
16089 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QString &); | |
16090 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QString &); | |
16091 | template <> class QTypeInfo<QString> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QString)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QString"; } }; | |
16092 | template <> inline bool qIsDetached<QString>(QString &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QString>(QString &value1, QString &value2) { const QString::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
16093 | inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QString::SectionFlags::enum_type f2) { return QFlags<QString::SectionFlags::enum_type>(f1) | f2; } inline QFlags<QString::SectionFlags::enum_type> operator|(QString::SectionFlags::enum_type f1, QFlags<QString::SectionFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QString::SectionFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
16094 | class __attribute__((visibility("default"))) QStringRef { | |
16095 | const QString *m_string; | |
16096 | int m_position; | |
16097 | int m_size; | |
16098 | public: | |
16099 | inline QStringRef():m_string(0), m_position(0), m_size(0){} | |
16100 | inline QStringRef(const QString *string, int position, int size); | |
16101 | inline QStringRef(const QString *string); | |
16102 | inline QStringRef(const QStringRef &other) | |
16103 | :m_string(other.m_string), m_position(other.m_position), m_size(other.m_size) | |
16104 | {} | |
16105 | inline ~QStringRef(){} | |
16106 | inline const QString *string() const { return m_string; } | |
16107 | inline int position() const { return m_position; } | |
16108 | inline int size() const { return m_size; } | |
16109 | inline int count() const { return m_size; } | |
16110 | inline int length() const { return m_size; } | |
16111 | inline QStringRef &operator=(const QStringRef &other) { | |
16112 | m_string = other.m_string; m_position = other.m_position; | |
16113 | m_size = other.m_size; return *this; | |
16114 | } | |
16115 | inline QStringRef &operator=(const QString *string); | |
16116 | inline const QChar *unicode() const { | |
16117 | if (!m_string) | |
16118 | return reinterpret_cast<const QChar *>(QString::shared_null.data); | |
16119 | return m_string->unicode() + m_position; | |
16120 | } | |
16121 | inline const QChar *data() const { return unicode(); } | |
16122 | inline const QChar *constData() const { return unicode(); } | |
16123 | inline void clear() { m_string = 0; m_position = m_size = 0; } | |
16124 | QString toString() const; | |
16125 | inline bool isEmpty() const { return m_size == 0; } | |
16126 | inline bool isNull() const { return m_string == 0 || m_string->isNull(); } | |
16127 | QStringRef appendTo(QString *string) const; | |
16128 | inline const QChar at(int i) const | |
16129 | { qt_noop(); return m_string->at(i + m_position); } | |
16130 | int compare(const QString &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
16131 | int compare(const QStringRef &s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
16132 | int compare(QLatin1String s, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
16133 | static int compare(const QStringRef &s1, const QString &s2, | |
16134 | Qt::CaseSensitivity = Qt::CaseSensitive); | |
16135 | static int compare(const QStringRef &s1, const QStringRef &s2, | |
16136 | Qt::CaseSensitivity = Qt::CaseSensitive); | |
16137 | static int compare(const QStringRef &s1, QLatin1String s2, | |
16138 | Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
16139 | int localeAwareCompare(const QString &s) const; | |
16140 | int localeAwareCompare(const QStringRef &s) const; | |
16141 | static int localeAwareCompare(const QStringRef &s1, const QString &s2); | |
16142 | static int localeAwareCompare(const QStringRef &s1, const QStringRef &s2); | |
16143 | }; | |
16144 | inline QStringRef &QStringRef::operator=(const QString *aString) | |
16145 | { m_string = aString; m_position = 0; m_size = aString?aString->size():0; return *this; } | |
16146 | inline QStringRef::QStringRef(const QString *aString, int aPosition, int aSize) | |
16147 | :m_string(aString), m_position(aPosition), m_size(aSize){} | |
16148 | inline QStringRef::QStringRef(const QString *aString) | |
16149 | :m_string(aString), m_position(0), m_size(aString?aString->size() : 0){} | |
16150 | __attribute__((visibility("default"))) bool operator==(const QStringRef &s1,const QStringRef &s2); | |
16151 | inline bool operator!=(const QStringRef &s1,const QStringRef &s2) | |
16152 | { return !(s1 == s2); } | |
16153 | __attribute__((visibility("default"))) bool operator==(const QString &s1,const QStringRef &s2); | |
16154 | inline bool operator!=(const QString &s1,const QStringRef &s2) | |
16155 | { return !(s1 == s2); } | |
16156 | inline bool operator==(const QStringRef &s1,const QString &s2) | |
16157 | { return s2 == s1; } | |
16158 | inline bool operator!=(const QStringRef &s1,const QString &s2) | |
16159 | { return s2 != s1; } | |
16160 | __attribute__((visibility("default"))) bool operator==(const QLatin1String &s1, const QStringRef &s2); | |
16161 | inline bool operator!=(const QLatin1String &s1,const QStringRef &s2) | |
16162 | { return !(s1 == s2); } | |
16163 | inline bool operator==(const QStringRef &s1,const QLatin1String &s2) | |
16164 | { return s2 == s1; } | |
16165 | inline bool operator!=(const QStringRef &s1,const QLatin1String &s2) | |
16166 | { return s2 != s1; } | |
16167 | __attribute__((visibility("default"))) bool operator<(const QStringRef &s1,const QStringRef &s2); | |
16168 | inline bool operator>(const QStringRef &s1, const QStringRef &s2) | |
16169 | { return s2 < s1; } | |
16170 | inline bool operator<=(const QStringRef &s1, const QStringRef &s2) | |
16171 | { return !(s1 > s2); } | |
16172 | inline bool operator>=(const QStringRef &s1, const QStringRef &s2) | |
16173 | { return !(s1 < s2); } | |
16174 | inline bool qStringComparisonHelper(const QStringRef &s1, const char *s2) | |
16175 | { | |
16176 | if (QString::codecForCStrings) return (s1 == QString::fromAscii(s2)); | |
16177 | return (s1 == QLatin1String(s2)); | |
16178 | } | |
16179 | inline __attribute__ ((__deprecated__)) bool operator==(const char *s1, const QStringRef &s2) | |
16180 | { return qStringComparisonHelper(s2, s1); } | |
16181 | inline __attribute__ ((__deprecated__)) bool operator==(const QStringRef &s1, const char *s2) | |
16182 | { return qStringComparisonHelper(s1, s2); } | |
16183 | inline __attribute__ ((__deprecated__)) bool operator!=(const char *s1, const QStringRef &s2) | |
16184 | { return !qStringComparisonHelper(s2, s1); } | |
16185 | inline __attribute__ ((__deprecated__)) bool operator!=(const QStringRef &s1, const char *s2) | |
16186 | { return !qStringComparisonHelper(s1, s2); } | |
16187 | inline int QString::compare(const QStringRef &s, Qt::CaseSensitivity cs) const | |
16188 | { return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); } | |
16189 | inline int QString::compare(const QString &s1, const QStringRef &s2, Qt::CaseSensitivity cs) | |
16190 | { return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); } | |
16191 | inline int QStringRef::compare(const QString &s, Qt::CaseSensitivity cs) const | |
16192 | { return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); } | |
16193 | inline int QStringRef::compare(const QStringRef &s, Qt::CaseSensitivity cs) const | |
16194 | { return QString::compare_helper(constData(), length(), s.constData(), s.length(), cs); } | |
16195 | inline int QStringRef::compare(QLatin1String s, Qt::CaseSensitivity cs) const | |
16196 | { return QString::compare_helper(constData(), length(), s, cs); } | |
16197 | inline int QStringRef::compare(const QStringRef &s1, const QString &s2, Qt::CaseSensitivity cs) | |
16198 | { return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); } | |
16199 | inline int QStringRef::compare(const QStringRef &s1, const QStringRef &s2, Qt::CaseSensitivity cs) | |
16200 | { return QString::compare_helper(s1.constData(), s1.length(), s2.constData(), s2.length(), cs); } | |
16201 | inline int QStringRef::compare(const QStringRef &s1, QLatin1String s2, Qt::CaseSensitivity cs) | |
16202 | { return QString::compare_helper(s1.constData(), s1.length(), s2, cs); } | |
16203 | inline int QString::localeAwareCompare(const QStringRef &s) const | |
16204 | { return localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); } | |
16205 | inline int QString::localeAwareCompare(const QString& s1, const QStringRef& s2) | |
16206 | { return localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); } | |
16207 | inline int QStringRef::localeAwareCompare(const QString &s) const | |
16208 | { return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); } | |
16209 | inline int QStringRef::localeAwareCompare(const QStringRef &s) const | |
16210 | { return QString::localeAwareCompare_helper(constData(), length(), s.constData(), s.length()); } | |
16211 | inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QString &s2) | |
16212 | { return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); } | |
16213 | inline int QStringRef::localeAwareCompare(const QStringRef &s1, const QStringRef &s2) | |
16214 | { return QString::localeAwareCompare_helper(s1.constData(), s1.length(), s2.constData(), s2.length()); } | |
16215 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
16216 | class QEvent; | |
16217 | class QTimerEvent; | |
16218 | class QChildEvent; | |
16219 | struct QMetaObject; | |
16220 | class QVariant; | |
16221 | class QObjectPrivate; | |
16222 | class QObject; | |
16223 | class QThread; | |
16224 | class QWidget; | |
16225 | class QRegExp; | |
16226 | class QObjectUserData; | |
16227 | typedef QList<QObject*> QObjectList; | |
16228 | template<typename T> inline T qFindChild(const QObject *, const QString & = QString()); | |
16229 | template<typename T> inline QList<T> qFindChildren(const QObject *, const QString & = QString()); | |
16230 | template<typename T> inline QList<T> qFindChildren(const QObject *, const QRegExp &); | |
16231 | class QObjectData { | |
16232 | public: | |
16233 | virtual ~QObjectData() = 0; | |
16234 | QObject *q_ptr; | |
16235 | QObject *parent; | |
16236 | QObjectList children; | |
16237 | uint isWidget : 1; | |
16238 | uint pendTimer : 1; | |
16239 | uint blockSig : 1; | |
16240 | uint wasDeleted : 1; | |
16241 | uint ownObjectName : 1; | |
16242 | uint sendChildEvents : 1; | |
16243 | uint receiveChildEvents : 1; | |
16244 | uint inEventHandler : 1; | |
16245 | uint inThreadChangeEvent : 1; | |
16246 | uint unused : 23; | |
16247 | int postedEvents; | |
16248 | }; | |
16249 | class __attribute__((visibility("default"))) QObject | |
16250 | { | |
16251 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
16252 | inline QObjectPrivate* d_func() { return reinterpret_cast<QObjectPrivate *>(d_ptr); } inline const QObjectPrivate* d_func() const { return reinterpret_cast<const QObjectPrivate *>(d_ptr); } friend class QObjectPrivate; | |
16253 | public: | |
16254 | explicit QObject(QObject *parent=0); | |
16255 | virtual ~QObject(); | |
16256 | virtual bool event(QEvent *); | |
16257 | virtual bool eventFilter(QObject *, QEvent *); | |
16258 | QString objectName() const; | |
16259 | void setObjectName(const QString &name); | |
16260 | inline bool isWidgetType() const { return d_ptr->isWidget; } | |
16261 | inline bool signalsBlocked() const { return d_ptr->blockSig; } | |
16262 | bool blockSignals(bool b); | |
16263 | QThread *thread() const; | |
16264 | void moveToThread(QThread *thread); | |
16265 | int startTimer(int interval); | |
16266 | void killTimer(int id); | |
16267 | template<typename T> | |
16268 | inline T findChild(const QString &aName = QString()) const | |
16269 | { return qFindChild<T>(this, aName); } | |
16270 | template<typename T> | |
16271 | inline QList<T> findChildren(const QString &aName = QString()) const | |
16272 | { return qFindChildren<T>(this, aName); } | |
16273 | template<typename T> | |
16274 | inline QList<T> findChildren(const QRegExp &re) const | |
16275 | { return qFindChildren<T>(this, re); } | |
16276 | inline const QObjectList &children() const { return d_ptr->children; } | |
16277 | void setParent(QObject *); | |
16278 | void installEventFilter(QObject *); | |
16279 | void removeEventFilter(QObject *); | |
16280 | static bool connect(const QObject *sender, const char *signal, | |
16281 | const QObject *receiver, const char *member, Qt::ConnectionType = | |
16282 | Qt::AutoConnection | |
16283 | ); | |
16284 | inline bool connect(const QObject *sender, const char *signal, | |
16285 | const char *member, Qt::ConnectionType type = | |
16286 | Qt::AutoConnection | |
16287 | ) const; | |
16288 | static bool disconnect(const QObject *sender, const char *signal, | |
16289 | const QObject *receiver, const char *member); | |
16290 | inline bool disconnect(const char *signal = 0, | |
16291 | const QObject *receiver = 0, const char *member = 0) | |
16292 | { return disconnect(this, signal, receiver, member); } | |
16293 | inline bool disconnect(const QObject *receiver, const char *member = 0) | |
16294 | { return disconnect(this, 0, receiver, member); } | |
16295 | void dumpObjectTree(); | |
16296 | void dumpObjectInfo(); | |
16297 | bool setProperty(const char *name, const QVariant &value); | |
16298 | QVariant property(const char *name) const; | |
16299 | QList<QByteArray> dynamicPropertyNames() const; | |
16300 | static uint registerUserData(); | |
16301 | void setUserData(uint id, QObjectUserData* data); | |
16302 | QObjectUserData* userData(uint id) const; | |
16303 | protected: | |
16304 | void destroyed(QObject * = 0); | |
16305 | public: | |
16306 | inline QObject *parent() const { return d_ptr->parent; } | |
16307 | inline bool inherits(const char *classname) const | |
16308 | { return const_cast<QObject *>(this)->qt_metacast(classname) != 0; } | |
16309 | public : | |
16310 | void deleteLater(); | |
16311 | protected: | |
16312 | QObject *sender() const; | |
16313 | int receivers(const char* signal) const; | |
16314 | virtual void timerEvent(QTimerEvent *); | |
16315 | virtual void childEvent(QChildEvent *); | |
16316 | virtual void customEvent(QEvent *); | |
16317 | virtual void connectNotify(const char *signal); | |
16318 | virtual void disconnectNotify(const char *signal); | |
16319 | protected: | |
16320 | QObject(QObjectPrivate &dd, QObject *parent = 0); | |
16321 | protected: | |
16322 | QObjectData *d_ptr; | |
16323 | static const QMetaObject staticQtMetaObject; | |
16324 | friend struct QMetaObject; | |
16325 | friend class QApplication; | |
16326 | friend class QApplicationPrivate; | |
16327 | friend class QCoreApplication; | |
16328 | friend class QCoreApplicationPrivate; | |
16329 | friend class QWidget; | |
16330 | friend class QThreadData; | |
16331 | private: | |
16332 | QObject(const QObject &); QObject &operator=(const QObject &); | |
16333 | }; | |
16334 | inline bool QObject::connect(const QObject *asender, const char *asignal, | |
16335 | const char *amember, Qt::ConnectionType atype) const | |
16336 | { return connect(asender, asignal, this, amember, atype); } | |
16337 | class __attribute__((visibility("default"))) QObjectUserData { | |
16338 | public: | |
16339 | virtual ~QObjectUserData(); | |
16340 | }; | |
16341 | __attribute__((visibility("default"))) void qt_qFindChildren_helper(const QObject *parent, const QString &name, const QRegExp *re, | |
16342 | const QMetaObject &mo, QList<void *> *list); | |
16343 | __attribute__((visibility("default"))) QObject *qt_qFindChild_helper(const QObject *parent, const QString &name, const QMetaObject &mo); | |
16344 | template<typename T> | |
16345 | inline T qFindChild(const QObject *o, const QString &name) | |
16346 | { return static_cast<T>(qt_qFindChild_helper(o, name, reinterpret_cast<T>(0)->staticMetaObject)); } | |
16347 | template<typename T> | |
16348 | inline QList<T> qFindChildren(const QObject *o, const QString &name) | |
16349 | { | |
16350 | QList<T> list; | |
16351 | union { | |
16352 | QList<T> *typedList; | |
16353 | QList<void *> *voidList; | |
16354 | } u; | |
16355 | u.typedList = &list; | |
16356 | qt_qFindChildren_helper(o, name, 0, reinterpret_cast<T>(0)->staticMetaObject, u.voidList); | |
16357 | return list; | |
16358 | } | |
16359 | template<typename T> | |
16360 | inline QList<T> qFindChildren(const QObject *o, const QRegExp &re) | |
16361 | { | |
16362 | QList<T> list; | |
16363 | union { | |
16364 | QList<T> *typedList; | |
16365 | QList<void *> *voidList; | |
16366 | } u; | |
16367 | u.typedList = &list; | |
16368 | qt_qFindChildren_helper(o, QString(), &re, reinterpret_cast<T>(0)->staticMetaObject, u.voidList); | |
16369 | return list; | |
16370 | } | |
16371 | template <class T> | |
16372 | inline T qobject_cast(QObject *object) | |
16373 | { | |
16374 | reinterpret_cast<T>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(object)); | |
16375 | return static_cast<T>(reinterpret_cast<T>(0)->staticMetaObject.cast(object)); | |
16376 | } | |
16377 | template <class T> | |
16378 | inline T qobject_cast(const QObject *object) | |
16379 | { | |
16380 | register T ptr = static_cast<T>(object); | |
16381 | (void)ptr;; | |
16382 | reinterpret_cast<T>(0)->qt_check_for_QOBJECT_macro(*reinterpret_cast<T>(const_cast<QObject *>(object))); | |
16383 | return static_cast<T>(const_cast<QObject *>(reinterpret_cast<T>(0)->staticMetaObject.cast(const_cast<QObject *>(object)))); | |
16384 | } | |
16385 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QObject *); | |
16386 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
16387 | class QByteArray; | |
16388 | class QIODevicePrivate; | |
16389 | class __attribute__((visibility("default"))) QIODevice | |
16390 | : public QObject | |
16391 | { | |
16392 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
16393 | public: | |
16394 | enum OpenModeFlag { | |
16395 | NotOpen = 0x0000, | |
16396 | ReadOnly = 0x0001, | |
16397 | WriteOnly = 0x0002, | |
16398 | ReadWrite = ReadOnly | WriteOnly, | |
16399 | Append = 0x0004, | |
16400 | Truncate = 0x0008, | |
16401 | Text = 0x0010, | |
16402 | Unbuffered = 0x0020 | |
16403 | }; | |
16404 | typedef QFlags<OpenModeFlag> OpenMode; | |
16405 | QIODevice(); | |
16406 | explicit QIODevice(QObject *parent); | |
16407 | virtual ~QIODevice(); | |
16408 | OpenMode openMode() const; | |
16409 | void setTextModeEnabled(bool enabled); | |
16410 | bool isTextModeEnabled() const; | |
16411 | bool isOpen() const; | |
16412 | bool isReadable() const; | |
16413 | bool isWritable() const; | |
16414 | virtual bool isSequential() const; | |
16415 | virtual bool open(OpenMode mode); | |
16416 | virtual void close(); | |
16417 | virtual qint64 pos() const; | |
16418 | virtual qint64 size() const; | |
16419 | virtual bool seek(qint64 pos); | |
16420 | virtual bool atEnd() const; | |
16421 | virtual bool reset(); | |
16422 | virtual qint64 bytesAvailable() const; | |
16423 | virtual qint64 bytesToWrite() const; | |
16424 | qint64 read(char *data, qint64 maxlen); | |
16425 | QByteArray read(qint64 maxlen); | |
16426 | QByteArray readAll(); | |
16427 | qint64 readLine(char *data, qint64 maxlen); | |
16428 | QByteArray readLine(qint64 maxlen = 0); | |
16429 | virtual bool canReadLine() const; | |
16430 | qint64 write(const char *data, qint64 len); | |
16431 | qint64 write(const char *data); | |
16432 | inline qint64 write(const QByteArray &data) | |
16433 | { return write(data.constData(), data.size()); } | |
16434 | qint64 peek(char *data, qint64 maxlen); | |
16435 | QByteArray peek(qint64 maxlen); | |
16436 | virtual bool waitForReadyRead(int msecs); | |
16437 | virtual bool waitForBytesWritten(int msecs); | |
16438 | void ungetChar(char c); | |
16439 | bool putChar(char c); | |
16440 | bool getChar(char *c); | |
16441 | QString errorString() const; | |
16442 | protected: | |
16443 | void readyRead(); | |
16444 | void bytesWritten(qint64 bytes); | |
16445 | void aboutToClose(); | |
16446 | void readChannelFinished(); | |
16447 | protected: | |
16448 | QIODevice(QIODevicePrivate &dd, QObject *parent = 0); | |
16449 | virtual qint64 readData(char *data, qint64 maxlen) = 0; | |
16450 | virtual qint64 readLineData(char *data, qint64 maxlen); | |
16451 | virtual qint64 writeData(const char *data, qint64 len) = 0; | |
16452 | void setOpenMode(OpenMode openMode); | |
16453 | void setErrorString(const QString &errorString); | |
16454 | private: | |
16455 | inline QIODevicePrivate* d_func() { return reinterpret_cast<QIODevicePrivate *>(d_ptr); } inline const QIODevicePrivate* d_func() const { return reinterpret_cast<const QIODevicePrivate *>(d_ptr); } friend class QIODevicePrivate; | |
16456 | QIODevice(const QIODevice &); QIODevice &operator=(const QIODevice &); | |
16457 | }; | |
16458 | inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QIODevice::OpenMode::enum_type f2) { return QFlags<QIODevice::OpenMode::enum_type>(f1) | f2; } inline QFlags<QIODevice::OpenMode::enum_type> operator|(QIODevice::OpenMode::enum_type f1, QFlags<QIODevice::OpenMode::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QIODevice::OpenMode::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
16459 | class QDebug; | |
16460 | __attribute__((visibility("default"))) QDebug operator<<(QDebug debug, QIODevice::OpenMode modes); | |
16461 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
16462 | class QByteArray; | |
16463 | class QIODevice; | |
16464 | template <typename T> class QList; | |
16465 | template <typename T> class QLinkedList; | |
16466 | template <typename T> class QVector; | |
16467 | template <typename T> class QSet; | |
16468 | template <class Key, class T> class QHash; | |
16469 | template <class Key, class T> class QMap; | |
16470 | class QDataStreamPrivate; | |
16471 | class __attribute__((visibility("default"))) QDataStream | |
16472 | { | |
16473 | public: | |
16474 | enum Version { | |
16475 | Qt_1_0 = 1, | |
16476 | Qt_2_0 = 2, | |
16477 | Qt_2_1 = 3, | |
16478 | Qt_3_0 = 4, | |
16479 | Qt_3_1 = 5, | |
16480 | Qt_3_3 = 6, | |
16481 | Qt_4_0 = 7, | |
16482 | Qt_4_1 = Qt_4_0, | |
16483 | Qt_4_2 = 8, | |
16484 | Qt_4_3 = 9, | |
16485 | Qt_4_4 = 10, | |
16486 | Qt_4_5 = 11 | |
16487 | }; | |
16488 | enum ByteOrder { | |
16489 | BigEndian = QSysInfo::BigEndian, | |
16490 | LittleEndian = QSysInfo::LittleEndian | |
16491 | }; | |
16492 | enum Status { | |
16493 | Ok, | |
16494 | ReadPastEnd, | |
16495 | ReadCorruptData | |
16496 | }; | |
16497 | QDataStream(); | |
16498 | explicit QDataStream(QIODevice *); | |
16499 | QDataStream(QByteArray *, QIODevice::OpenMode flags); | |
16500 | QDataStream(const QByteArray &); | |
16501 | virtual ~QDataStream(); | |
16502 | QIODevice *device() const; | |
16503 | void setDevice(QIODevice *); | |
16504 | void unsetDevice(); | |
16505 | bool atEnd() const; | |
16506 | Status status() const; | |
16507 | void setStatus(Status status); | |
16508 | void resetStatus(); | |
16509 | ByteOrder byteOrder() const; | |
16510 | void setByteOrder(ByteOrder); | |
16511 | int version() const; | |
16512 | void setVersion(int); | |
16513 | QDataStream &operator>>(qint8 &i); | |
16514 | QDataStream &operator>>(quint8 &i); | |
16515 | QDataStream &operator>>(qint16 &i); | |
16516 | QDataStream &operator>>(quint16 &i); | |
16517 | QDataStream &operator>>(qint32 &i); | |
16518 | QDataStream &operator>>(quint32 &i); | |
16519 | QDataStream &operator>>(qint64 &i); | |
16520 | QDataStream &operator>>(quint64 &i); | |
16521 | QDataStream &operator>>(bool &i); | |
16522 | QDataStream &operator>>(float &f); | |
16523 | QDataStream &operator>>(double &f); | |
16524 | QDataStream &operator>>(char *&str); | |
16525 | QDataStream &operator<<(qint8 i); | |
16526 | QDataStream &operator<<(quint8 i); | |
16527 | QDataStream &operator<<(qint16 i); | |
16528 | QDataStream &operator<<(quint16 i); | |
16529 | QDataStream &operator<<(qint32 i); | |
16530 | QDataStream &operator<<(quint32 i); | |
16531 | QDataStream &operator<<(qint64 i); | |
16532 | QDataStream &operator<<(quint64 i); | |
16533 | QDataStream &operator<<(bool i); | |
16534 | QDataStream &operator<<(float f); | |
16535 | QDataStream &operator<<(double f); | |
16536 | QDataStream &operator<<(const char *str); | |
16537 | QDataStream &readBytes(char *&, uint &len); | |
16538 | int readRawData(char *, int len); | |
16539 | QDataStream &writeBytes(const char *, uint len); | |
16540 | int writeRawData(const char *, int len); | |
16541 | int skipRawData(int len); | |
16542 | private: | |
16543 | QDataStream(const QDataStream &); QDataStream &operator=(const QDataStream &); | |
16544 | QDataStreamPrivate *d; | |
16545 | QIODevice *dev; | |
16546 | bool owndev; | |
16547 | bool noswap; | |
16548 | ByteOrder byteorder; | |
16549 | int ver; | |
16550 | Status q_status; | |
16551 | }; | |
16552 | inline QIODevice *QDataStream::device() const | |
16553 | { return dev; } | |
16554 | inline QDataStream::ByteOrder QDataStream::byteOrder() const | |
16555 | { return byteorder; } | |
16556 | inline int QDataStream::version() const | |
16557 | { return ver; } | |
16558 | inline void QDataStream::setVersion(int v) | |
16559 | { ver = v; } | |
16560 | inline QDataStream &QDataStream::operator>>(quint8 &i) | |
16561 | { return *this >> reinterpret_cast<qint8&>(i); } | |
16562 | inline QDataStream &QDataStream::operator>>(quint16 &i) | |
16563 | { return *this >> reinterpret_cast<qint16&>(i); } | |
16564 | inline QDataStream &QDataStream::operator>>(quint32 &i) | |
16565 | { return *this >> reinterpret_cast<qint32&>(i); } | |
16566 | inline QDataStream &QDataStream::operator>>(quint64 &i) | |
16567 | { return *this >> reinterpret_cast<qint64&>(i); } | |
16568 | inline QDataStream &QDataStream::operator<<(quint8 i) | |
16569 | { return *this << qint8(i); } | |
16570 | inline QDataStream &QDataStream::operator<<(quint16 i) | |
16571 | { return *this << qint16(i); } | |
16572 | inline QDataStream &QDataStream::operator<<(quint32 i) | |
16573 | { return *this << qint32(i); } | |
16574 | inline QDataStream &QDataStream::operator<<(quint64 i) | |
16575 | { return *this << qint64(i); } | |
16576 | template <typename T> | |
16577 | QDataStream& operator>>(QDataStream& s, QList<T>& l) | |
16578 | { | |
16579 | l.clear(); | |
16580 | quint32 c; | |
16581 | s >> c; | |
16582 | for(quint32 i = 0; i < c; ++i) | |
16583 | { | |
16584 | T t; | |
16585 | s >> t; | |
16586 | l.append(t); | |
16587 | if (s.atEnd()) | |
16588 | break; | |
16589 | } | |
16590 | return s; | |
16591 | } | |
16592 | template <typename T> | |
16593 | QDataStream& operator<<(QDataStream& s, const QList<T>& l) | |
16594 | { | |
16595 | s << quint32(l.size()); | |
16596 | for (int i = 0; i < l.size(); ++i) | |
16597 | s << l.at(i); | |
16598 | return s; | |
16599 | } | |
16600 | template <typename T> | |
16601 | QDataStream& operator>>(QDataStream& s, QLinkedList<T>& l) | |
16602 | { | |
16603 | l.clear(); | |
16604 | quint32 c; | |
16605 | s >> c; | |
16606 | for(quint32 i = 0; i < c; ++i) | |
16607 | { | |
16608 | T t; | |
16609 | s >> t; | |
16610 | l.append(t); | |
16611 | if (s.atEnd()) | |
16612 | break; | |
16613 | } | |
16614 | return s; | |
16615 | } | |
16616 | template <typename T> | |
16617 | QDataStream& operator<<(QDataStream& s, const QLinkedList<T>& l) | |
16618 | { | |
16619 | s << quint32(l.size()); | |
16620 | typename QLinkedList<T>::ConstIterator it = l.constBegin(); | |
16621 | for(; it != l.constEnd(); ++it) | |
16622 | s << *it; | |
16623 | return s; | |
16624 | } | |
16625 | template<typename T> | |
16626 | QDataStream& operator>>(QDataStream& s, QVector<T>& v) | |
16627 | { | |
16628 | v.clear(); | |
16629 | quint32 c; | |
16630 | s >> c; | |
16631 | v.resize(c); | |
16632 | for(quint32 i = 0; i < c; ++i) { | |
16633 | T t; | |
16634 | s >> t; | |
16635 | v[i] = t; | |
16636 | } | |
16637 | return s; | |
16638 | } | |
16639 | template<typename T> | |
16640 | QDataStream& operator<<(QDataStream& s, const QVector<T>& v) | |
16641 | { | |
16642 | s << quint32(v.size()); | |
16643 | for (typename QVector<T>::const_iterator it = v.begin(); it != v.end(); ++it) | |
16644 | s << *it; | |
16645 | return s; | |
16646 | } | |
16647 | template <typename T> | |
16648 | QDataStream &operator>>(QDataStream &in, QSet<T> &set) | |
16649 | { | |
16650 | set.clear(); | |
16651 | quint32 c; | |
16652 | in >> c; | |
16653 | for (quint32 i = 0; i < c; ++i) { | |
16654 | T t; | |
16655 | in >> t; | |
16656 | set << t; | |
16657 | if (in.atEnd()) | |
16658 | break; | |
16659 | } | |
16660 | return in; | |
16661 | } | |
16662 | template <typename T> | |
16663 | QDataStream& operator<<(QDataStream &out, const QSet<T> &set) | |
16664 | { | |
16665 | out << quint32(set.size()); | |
16666 | typename QSet<T>::const_iterator i = set.constBegin(); | |
16667 | while (i != set.constEnd()) { | |
16668 | out << *i; | |
16669 | ++i; | |
16670 | } | |
16671 | return out; | |
16672 | } | |
16673 | template <class Key, class T> | |
16674 | QDataStream &operator>>(QDataStream &in, QHash<Key, T> &hash) | |
16675 | { | |
16676 | QDataStream::Status oldStatus = in.status(); | |
16677 | in.resetStatus(); | |
16678 | hash.clear(); | |
16679 | quint32 n; | |
16680 | in >> n; | |
16681 | for (quint32 i = 0; i < n; ++i) { | |
16682 | if (in.status() != QDataStream::Ok) | |
16683 | break; | |
16684 | Key k; | |
16685 | T t; | |
16686 | in >> k >> t; | |
16687 | hash.insertMulti(k, t); | |
16688 | } | |
16689 | if (in.status() != QDataStream::Ok) | |
16690 | hash.clear(); | |
16691 | if (oldStatus != QDataStream::Ok) | |
16692 | in.setStatus(oldStatus); | |
16693 | return in; | |
16694 | } | |
16695 | template <class Key, class T> | |
16696 | QDataStream &operator<<(QDataStream &out, const QHash<Key, T>& hash) | |
16697 | { | |
16698 | out << quint32(hash.size()); | |
16699 | typename QHash<Key, T>::ConstIterator it = hash.end(); | |
16700 | typename QHash<Key, T>::ConstIterator begin = hash.begin(); | |
16701 | while (it != begin) { | |
16702 | --it; | |
16703 | out << it.key() << it.value(); | |
16704 | } | |
16705 | return out; | |
16706 | } | |
16707 | template <class aKey, class aT> | |
16708 | QDataStream &operator>>(QDataStream &in, QMap<aKey, aT> &map) | |
16709 | { | |
16710 | QDataStream::Status oldStatus = in.status(); | |
16711 | in.resetStatus(); | |
16712 | map.clear(); | |
16713 | quint32 n; | |
16714 | in >> n; | |
16715 | map.detach(); | |
16716 | map.setInsertInOrder(true); | |
16717 | for (quint32 i = 0; i < n; ++i) { | |
16718 | if (in.status() != QDataStream::Ok) | |
16719 | break; | |
16720 | aKey key; | |
16721 | aT value; | |
16722 | in >> key >> value; | |
16723 | map.insertMulti(key, value); | |
16724 | } | |
16725 | map.setInsertInOrder(false); | |
16726 | if (in.status() != QDataStream::Ok) | |
16727 | map.clear(); | |
16728 | if (oldStatus != QDataStream::Ok) | |
16729 | in.setStatus(oldStatus); | |
16730 | return in; | |
16731 | } | |
16732 | template <class Key, class T> | |
16733 | QDataStream &operator<<(QDataStream &out, const QMap<Key, T> &map) | |
16734 | { | |
16735 | out << quint32(map.size()); | |
16736 | typename QMap<Key, T>::ConstIterator it = map.end(); | |
16737 | typename QMap<Key, T>::ConstIterator begin = map.begin(); | |
16738 | while (it != begin) { | |
16739 | --it; | |
16740 | out << it.key() << it.value(); | |
16741 | } | |
16742 | return out; | |
16743 | } | |
16744 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
16745 | template <class T1, class T2> | |
16746 | struct QPair | |
16747 | { | |
16748 | typedef T1 first_type; | |
16749 | typedef T2 second_type; | |
16750 | QPair() : first(T1()), second(T2()) {} | |
16751 | QPair(const T1 &t1, const T2 &t2) : first(t1), second(t2) {} | |
16752 | QPair<T1, T2> &operator=(const QPair<T1, T2> &other) | |
16753 | { first = other.first; second = other.second; return *this; } | |
16754 | T1 first; | |
16755 | T2 second; | |
16756 | }; | |
16757 | template <class T1, class T2> | |
16758 | inline bool operator==(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
16759 | { return p1.first == p2.first && p1.second == p2.second; } | |
16760 | template <class T1, class T2> | |
16761 | inline bool operator!=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
16762 | { return !(p1 == p2); } | |
16763 | template <class T1, class T2> | |
16764 | inline bool operator<(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
16765 | { | |
16766 | return p1.first < p2.first || (!(p2.first < p1.first) && p1.second < p2.second); | |
16767 | } | |
16768 | template <class T1, class T2> | |
16769 | inline bool operator>(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
16770 | { | |
16771 | return p2 < p1; | |
16772 | } | |
16773 | template <class T1, class T2> | |
16774 | inline bool operator<=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
16775 | { | |
16776 | return !(p2 < p1); | |
16777 | } | |
16778 | template <class T1, class T2> | |
16779 | inline bool operator>=(const QPair<T1, T2> &p1, const QPair<T1, T2> &p2) | |
16780 | { | |
16781 | return !(p1 < p2); | |
16782 | } | |
16783 | template <class T1, class T2> | |
16784 | QPair<T1, T2> qMakePair(const T1 &x, const T2 &y) | |
16785 | { | |
16786 | return QPair<T1, T2>(x, y); | |
16787 | } | |
16788 | template <class T1, class T2> | |
16789 | inline QDataStream& operator>>(QDataStream& s, QPair<T1, T2>& p) | |
16790 | { | |
16791 | s >> p.first >> p.second; | |
16792 | return s; | |
16793 | } | |
16794 | template <class T1, class T2> | |
16795 | inline QDataStream& operator<<(QDataStream& s, const QPair<T1, T2>& p) | |
16796 | { | |
16797 | s << p.first << p.second; | |
16798 | return s; | |
16799 | } | |
16800 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
16801 | class QBitArray; | |
16802 | class QByteArray; | |
16803 | class QString; | |
16804 | class QStringRef; | |
16805 | inline uint qHash(char key) { return uint(key); } | |
16806 | inline uint qHash(uchar key) { return uint(key); } | |
16807 | inline uint qHash(signed char key) { return uint(key); } | |
16808 | inline uint qHash(ushort key) { return uint(key); } | |
16809 | inline uint qHash(short key) { return uint(key); } | |
16810 | inline uint qHash(uint key) { return key; } | |
16811 | inline uint qHash(int key) { return uint(key); } | |
16812 | inline uint qHash(ulong key) | |
16813 | { | |
16814 | if (sizeof(ulong) > sizeof(uint)) { | |
16815 | return uint((key >> (8 * sizeof(uint) - 1)) ^ key); | |
16816 | } else { | |
16817 | return uint(key); | |
16818 | } | |
16819 | } | |
16820 | inline uint qHash(long key) { return qHash(ulong(key)); } | |
16821 | inline uint qHash(quint64 key) | |
16822 | { | |
16823 | if (sizeof(quint64) > sizeof(uint)) { | |
16824 | return uint((key >> (8 * sizeof(uint) - 1)) ^ key); | |
16825 | } else { | |
16826 | return uint(key); | |
16827 | } | |
16828 | } | |
16829 | inline uint qHash(qint64 key) { return qHash(quint64(key)); } | |
16830 | inline uint qHash(QChar key) { return qHash(key.unicode()); } | |
16831 | __attribute__((visibility("default"))) uint qHash(const QByteArray &key); | |
16832 | __attribute__((visibility("default"))) uint qHash(const QString &key); | |
16833 | __attribute__((visibility("default"))) uint qHash(const QStringRef &key); | |
16834 | __attribute__((visibility("default"))) uint qHash(const QBitArray &key); | |
16835 | template <class T> inline uint qHash(const T *key) | |
16836 | { | |
16837 | if (sizeof(const T *) > sizeof(uint)) | |
16838 | return qHash(reinterpret_cast<quint64>(key)); | |
16839 | else | |
16840 | return uint(reinterpret_cast<ulong>(key)); | |
16841 | } | |
16842 | template <typename T1, typename T2> inline uint qHash(const QPair<T1, T2> &key) | |
16843 | { | |
16844 | uint h1 = qHash(key.first); | |
16845 | uint h2 = qHash(key.second); | |
16846 | return ((h1 << 16) | (h1 >> 16)) ^ h2; | |
16847 | } | |
16848 | struct __attribute__((visibility("default"))) QHashData | |
16849 | { | |
16850 | struct Node { | |
16851 | Node *next; | |
16852 | uint h; | |
16853 | }; | |
16854 | Node *fakeNext; | |
16855 | Node **buckets; | |
16856 | QBasicAtomicInt ref; | |
16857 | int size; | |
16858 | int nodeSize; | |
16859 | short userNumBits; | |
16860 | short numBits; | |
16861 | int numBuckets; | |
16862 | uint sharable : 1; | |
16863 | void *allocateNode(); | |
16864 | void freeNode(void *node); | |
16865 | QHashData *detach_helper(void (*node_duplicate)(Node *, void *), int nodeSize); | |
16866 | void mightGrow(); | |
16867 | bool willGrow(); | |
16868 | void hasShrunk(); | |
16869 | void rehash(int hint); | |
16870 | void destroyAndFree(); | |
16871 | Node *firstNode(); | |
16872 | static Node *nextNode(Node *node); | |
16873 | static Node *previousNode(Node *node); | |
16874 | static QHashData shared_null; | |
16875 | }; | |
16876 | inline void QHashData::mightGrow() | |
16877 | { | |
16878 | if (size >= numBuckets) | |
16879 | rehash(numBits + 1); | |
16880 | } | |
16881 | inline bool QHashData::willGrow() | |
16882 | { | |
16883 | if (size >= numBuckets) { | |
16884 | rehash(numBits + 1); | |
16885 | return true; | |
16886 | } else { | |
16887 | return false; | |
16888 | } | |
16889 | } | |
16890 | inline void QHashData::hasShrunk() | |
16891 | { | |
16892 | if (size <= (numBuckets >> 3) && numBits > userNumBits) | |
16893 | rehash(qMax(int(numBits) - 2, int(userNumBits))); | |
16894 | } | |
16895 | inline QHashData::Node *QHashData::firstNode() | |
16896 | { | |
16897 | Node *e = reinterpret_cast<Node *>(this); | |
16898 | Node **bucket = buckets; | |
16899 | int n = numBuckets; | |
16900 | while (n--) { | |
16901 | if (*bucket != e) | |
16902 | return *bucket; | |
16903 | ++bucket; | |
16904 | } | |
16905 | return e; | |
16906 | } | |
16907 | struct QHashDummyValue | |
16908 | { | |
16909 | }; | |
16910 | inline bool operator==(const QHashDummyValue & , const QHashDummyValue & ) | |
16911 | { | |
16912 | return true; | |
16913 | } | |
16914 | template <> class QTypeInfo<QHashDummyValue> { public: enum { isComplex = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QHashDummyValue)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE | Q_DUMMY_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QHashDummyValue"; } }; | |
16915 | template <class Key, class T> | |
16916 | struct QHashDummyNode | |
16917 | { | |
16918 | QHashDummyNode *next; | |
16919 | uint h; | |
16920 | Key key; | |
16921 | inline QHashDummyNode(const Key &key0) : key(key0) {} | |
16922 | }; | |
16923 | template <class Key, class T> | |
16924 | struct QHashNode | |
16925 | { | |
16926 | QHashNode *next; | |
16927 | uint h; | |
16928 | Key key; | |
16929 | T value; | |
16930 | inline QHashNode(const Key &key0) : key(key0) {} | |
16931 | inline QHashNode(const Key &key0, const T &value0) : key(key0), value(value0) {} | |
16932 | inline bool same_key(uint h0, const Key &key0) { return h0 == h && key0 == key; } | |
16933 | }; | |
16934 | template <class T> struct QHashDummyNode<short, T> { QHashDummyNode *next; union { uint h; short key; }; inline QHashDummyNode(short ) {} }; template <class T> struct QHashNode<short, T> { QHashNode *next; union { uint h; short key; }; T value; inline QHashNode(short ) {} inline QHashNode(short , const T &value0) : value(value0) {} inline bool same_key(uint h0, short) { return h0 == h; } }; | |
16935 | template <class T> struct QHashDummyNode<ushort, T> { QHashDummyNode *next; union { uint h; ushort key; }; inline QHashDummyNode(ushort ) {} }; template <class T> struct QHashNode<ushort, T> { QHashNode *next; union { uint h; ushort key; }; T value; inline QHashNode(ushort ) {} inline QHashNode(ushort , const T &value0) : value(value0) {} inline bool same_key(uint h0, ushort) { return h0 == h; } }; | |
16936 | template <class T> struct QHashDummyNode<int, T> { QHashDummyNode *next; union { uint h; int key; }; inline QHashDummyNode(int ) {} }; template <class T> struct QHashNode<int, T> { QHashNode *next; union { uint h; int key; }; T value; inline QHashNode(int ) {} inline QHashNode(int , const T &value0) : value(value0) {} inline bool same_key(uint h0, int) { return h0 == h; } }; | |
16937 | template <class T> struct QHashDummyNode<uint, T> { QHashDummyNode *next; union { uint h; uint key; }; inline QHashDummyNode(uint ) {} }; template <class T> struct QHashNode<uint, T> { QHashNode *next; union { uint h; uint key; }; T value; inline QHashNode(uint ) {} inline QHashNode(uint , const T &value0) : value(value0) {} inline bool same_key(uint h0, uint) { return h0 == h; } }; | |
16938 | template <class Key, class T> | |
16939 | class QHash | |
16940 | { | |
16941 | typedef QHashDummyNode<Key, T> DummyNode; | |
16942 | typedef QHashNode<Key, T> Node; | |
16943 | union { | |
16944 | QHashData *d; | |
16945 | QHashNode<Key, T> *e; | |
16946 | }; | |
16947 | static inline Node *concrete(QHashData::Node *node) { | |
16948 | return reinterpret_cast<Node *>(node); | |
16949 | } | |
16950 | public: | |
16951 | inline QHash() : d(&QHashData::shared_null) { d->ref.ref(); } | |
16952 | inline QHash(const QHash<Key, T> &other) : d(other.d) { d->ref.ref(); if (!d->sharable) detach(); } | |
16953 | inline ~QHash() { if (!d->ref.deref()) freeData(d); } | |
16954 | QHash<Key, T> &operator=(const QHash<Key, T> &other); | |
16955 | bool operator==(const QHash<Key, T> &other) const; | |
16956 | inline bool operator!=(const QHash<Key, T> &other) const { return !(*this == other); } | |
16957 | inline int size() const { return d->size; } | |
16958 | inline bool isEmpty() const { return d->size == 0; } | |
16959 | inline int capacity() const { return d->numBuckets; } | |
16960 | void reserve(int size); | |
16961 | inline void squeeze() { reserve(1); } | |
16962 | inline void detach() { if (d->ref != 1) detach_helper(); } | |
16963 | inline bool isDetached() const { return d->ref == 1; } | |
16964 | inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } | |
16965 | void clear(); | |
16966 | int remove(const Key &key); | |
16967 | T take(const Key &key); | |
16968 | bool contains(const Key &key) const; | |
16969 | const Key key(const T &value) const; | |
16970 | const Key key(const T &value, const Key &defaultKey) const; | |
16971 | const T value(const Key &key) const; | |
16972 | const T value(const Key &key, const T &defaultValue) const; | |
16973 | T &operator[](const Key &key); | |
16974 | const T operator[](const Key &key) const; | |
16975 | QList<Key> uniqueKeys() const; | |
16976 | QList<Key> keys() const; | |
16977 | QList<Key> keys(const T &value) const; | |
16978 | QList<T> values() const; | |
16979 | QList<T> values(const Key &key) const; | |
16980 | int count(const Key &key) const; | |
16981 | class const_iterator; | |
16982 | class iterator | |
16983 | { | |
16984 | friend class const_iterator; | |
16985 | QHashData::Node *i; | |
16986 | public: | |
16987 | typedef std::bidirectional_iterator_tag iterator_category; | |
16988 | typedef ptrdiff_t difference_type; | |
16989 | typedef T value_type; | |
16990 | typedef T *pointer; | |
16991 | typedef T &reference; | |
16992 | inline operator Node *() const { return concrete(i); } | |
16993 | inline iterator() : i(0) { } | |
16994 | explicit inline iterator(void *node) : i(reinterpret_cast<QHashData::Node *>(node)) { } | |
16995 | inline const Key &key() const { return concrete(i)->key; } | |
16996 | inline T &value() const { return concrete(i)->value; } | |
16997 | inline T &operator*() const { return concrete(i)->value; } | |
16998 | inline T *operator->() const { return &concrete(i)->value; } | |
16999 | inline bool operator==(const iterator &o) const { return i == o.i; } | |
17000 | inline bool operator!=(const iterator &o) const { return i != o.i; } | |
17001 | inline iterator &operator++() { | |
17002 | i = QHashData::nextNode(i); | |
17003 | return *this; | |
17004 | } | |
17005 | inline iterator operator++(int) { | |
17006 | iterator r = *this; | |
17007 | i = QHashData::nextNode(i); | |
17008 | return r; | |
17009 | } | |
17010 | inline iterator &operator--() { | |
17011 | i = QHashData::previousNode(i); | |
17012 | return *this; | |
17013 | } | |
17014 | inline iterator operator--(int) { | |
17015 | iterator r = *this; | |
17016 | i = QHashData::previousNode(i); | |
17017 | return r; | |
17018 | } | |
17019 | inline iterator operator+(int j) const | |
17020 | { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } | |
17021 | inline iterator operator-(int j) const { return operator+(-j); } | |
17022 | inline iterator &operator+=(int j) { return *this = *this + j; } | |
17023 | inline iterator &operator-=(int j) { return *this = *this - j; } | |
17024 | public: | |
17025 | inline bool operator==(const const_iterator &o) const | |
17026 | { return i == o.i; } | |
17027 | inline bool operator!=(const const_iterator &o) const | |
17028 | { return i != o.i; } | |
17029 | private: | |
17030 | inline operator bool() const { return false; } | |
17031 | }; | |
17032 | friend class iterator; | |
17033 | class const_iterator | |
17034 | { | |
17035 | friend class iterator; | |
17036 | QHashData::Node *i; | |
17037 | public: | |
17038 | typedef std::bidirectional_iterator_tag iterator_category; | |
17039 | typedef ptrdiff_t difference_type; | |
17040 | typedef T value_type; | |
17041 | typedef const T *pointer; | |
17042 | typedef const T &reference; | |
17043 | inline operator Node *() const { return concrete(i); } | |
17044 | inline const_iterator() : i(0) { } | |
17045 | explicit inline const_iterator(void *node) | |
17046 | : i(reinterpret_cast<QHashData::Node *>(node)) { } | |
17047 | inline const_iterator(const iterator &o) | |
17048 | { i = o.i; } | |
17049 | inline const Key &key() const { return concrete(i)->key; } | |
17050 | inline const T &value() const { return concrete(i)->value; } | |
17051 | inline const T &operator*() const { return concrete(i)->value; } | |
17052 | inline const T *operator->() const { return &concrete(i)->value; } | |
17053 | inline bool operator==(const const_iterator &o) const { return i == o.i; } | |
17054 | inline bool operator!=(const const_iterator &o) const { return i != o.i; } | |
17055 | inline const_iterator &operator++() { | |
17056 | i = QHashData::nextNode(i); | |
17057 | return *this; | |
17058 | } | |
17059 | inline const_iterator operator++(int) { | |
17060 | const_iterator r = *this; | |
17061 | i = QHashData::nextNode(i); | |
17062 | return r; | |
17063 | } | |
17064 | inline const_iterator &operator--() { | |
17065 | i = QHashData::previousNode(i); | |
17066 | return *this; | |
17067 | } | |
17068 | inline const_iterator operator--(int) { | |
17069 | const_iterator r = *this; | |
17070 | i = QHashData::previousNode(i); | |
17071 | return r; | |
17072 | } | |
17073 | inline const_iterator operator+(int j) const | |
17074 | { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } | |
17075 | inline const_iterator operator-(int j) const { return operator+(-j); } | |
17076 | inline const_iterator &operator+=(int j) { return *this = *this + j; } | |
17077 | inline const_iterator &operator-=(int j) { return *this = *this - j; } | |
17078 | private: | |
17079 | inline operator bool() const { return false; } | |
17080 | }; | |
17081 | friend class const_iterator; | |
17082 | inline iterator begin() { detach(); return iterator(d->firstNode()); } | |
17083 | inline const_iterator begin() const { return const_iterator(d->firstNode()); } | |
17084 | inline const_iterator constBegin() const { return const_iterator(d->firstNode()); } | |
17085 | inline iterator end() { detach(); return iterator(e); } | |
17086 | inline const_iterator end() const { return const_iterator(e); } | |
17087 | inline const_iterator constEnd() const { return const_iterator(e); } | |
17088 | iterator erase(iterator it); | |
17089 | typedef iterator Iterator; | |
17090 | typedef const_iterator ConstIterator; | |
17091 | inline int count() const { return d->size; } | |
17092 | iterator find(const Key &key); | |
17093 | const_iterator find(const Key &key) const; | |
17094 | const_iterator constFind(const Key &key) const; | |
17095 | iterator insert(const Key &key, const T &value); | |
17096 | iterator insertMulti(const Key &key, const T &value); | |
17097 | QHash<Key, T> &unite(const QHash<Key, T> &other); | |
17098 | typedef T mapped_type; | |
17099 | typedef Key key_type; | |
17100 | typedef ptrdiff_t difference_type; | |
17101 | typedef int size_type; | |
17102 | inline bool empty() const { return isEmpty(); } | |
17103 | private: | |
17104 | void detach_helper(); | |
17105 | void freeData(QHashData *d); | |
17106 | Node **findNode(const Key &key, uint *hp = 0) const; | |
17107 | Node *createNode(uint h, const Key &key, const T &value, Node **nextNode); | |
17108 | void deleteNode(Node *node); | |
17109 | static void duplicateNode(QHashData::Node *originalNode, void *newNode); | |
17110 | }; | |
17111 | template <class Key, class T> | |
17112 | inline void QHash<Key, T>::deleteNode(Node *node) | |
17113 | { | |
17114 | node->~Node(); | |
17115 | d->freeNode(node); | |
17116 | } | |
17117 | template <class Key, class T> | |
17118 | inline void QHash<Key, T>::duplicateNode(QHashData::Node *node, void *newNode) | |
17119 | { | |
17120 | Node *concreteNode = concrete(node); | |
17121 | if (QTypeInfo<T>::isDummy) { | |
17122 | (void) new (newNode) DummyNode(concreteNode->key); | |
17123 | } else { | |
17124 | (void) new (newNode) Node(concreteNode->key, concreteNode->value); | |
17125 | } | |
17126 | } | |
17127 | template <class Key, class T> | |
17128 | inline typename QHash<Key, T>::Node * | |
17129 | QHash<Key, T>::createNode(uint ah, const Key &akey, const T &avalue, Node **anextNode) | |
17130 | { | |
17131 | Node *node; | |
17132 | if (QTypeInfo<T>::isDummy) { | |
17133 | node = reinterpret_cast<Node *>(new (d->allocateNode()) DummyNode(akey)); | |
17134 | } else { | |
17135 | node = new (d->allocateNode()) Node(akey, avalue); | |
17136 | } | |
17137 | node->h = ah; | |
17138 | node->next = *anextNode; | |
17139 | *anextNode = node; | |
17140 | ++d->size; | |
17141 | return node; | |
17142 | } | |
17143 | template <class Key, class T> | |
17144 | inline QHash<Key, T> &QHash<Key, T>::unite(const QHash<Key, T> &other) | |
17145 | { | |
17146 | QHash<Key, T> copy(other); | |
17147 | const_iterator it = copy.constEnd(); | |
17148 | while (it != copy.constBegin()) { | |
17149 | --it; | |
17150 | insertMulti(it.key(), it.value()); | |
17151 | } | |
17152 | return *this; | |
17153 | } | |
17154 | template <class Key, class T> | |
17155 | void QHash<Key, T>::freeData(QHashData *x) | |
17156 | { | |
17157 | Node *e_for_x = reinterpret_cast<Node *>(x); | |
17158 | Node **bucket = reinterpret_cast<Node **>(x->buckets); | |
17159 | int n = x->numBuckets; | |
17160 | while (n--) { | |
17161 | Node *cur = *bucket++; | |
17162 | while (cur != e_for_x) { | |
17163 | Node *next = cur->next; | |
17164 | deleteNode(cur); | |
17165 | cur = next; | |
17166 | } | |
17167 | } | |
17168 | x->destroyAndFree(); | |
17169 | } | |
17170 | template <class Key, class T> | |
17171 | inline void QHash<Key, T>::clear() | |
17172 | { | |
17173 | *this = QHash<Key,T>(); | |
17174 | } | |
17175 | template <class Key, class T> | |
17176 | void QHash<Key, T>::detach_helper() | |
17177 | { | |
17178 | QHashData *x = d->detach_helper(duplicateNode, | |
17179 | QTypeInfo<T>::isDummy ? sizeof(DummyNode) : sizeof(Node)); | |
17180 | if (!d->ref.deref()) | |
17181 | freeData(d); | |
17182 | d = x; | |
17183 | } | |
17184 | template <class Key, class T> | |
17185 | inline QHash<Key, T> &QHash<Key, T>::operator=(const QHash<Key, T> &other) | |
17186 | { | |
17187 | if (d != other.d) { | |
17188 | other.d->ref.ref(); | |
17189 | if (!d->ref.deref()) | |
17190 | freeData(d); | |
17191 | d = other.d; | |
17192 | if (!d->sharable) | |
17193 | detach_helper(); | |
17194 | } | |
17195 | return *this; | |
17196 | } | |
17197 | template <class Key, class T> | |
17198 | inline const T QHash<Key, T>::value(const Key &akey) const | |
17199 | { | |
17200 | Node *node; | |
17201 | if (d->size == 0 || (node = *findNode(akey)) == e) { | |
17202 | return T(); | |
17203 | } else { | |
17204 | return node->value; | |
17205 | } | |
17206 | } | |
17207 | template <class Key, class T> | |
17208 | inline const T QHash<Key, T>::value(const Key &akey, const T &adefaultValue) const | |
17209 | { | |
17210 | Node *node; | |
17211 | if (d->size == 0 || (node = *findNode(akey)) == e) { | |
17212 | return adefaultValue; | |
17213 | } else { | |
17214 | return node->value; | |
17215 | } | |
17216 | } | |
17217 | template <class Key, class T> | |
17218 | QList<Key> QHash<Key, T>::uniqueKeys() const | |
17219 | { | |
17220 | QList<Key> res; | |
17221 | const_iterator i = begin(); | |
17222 | if (i != end()) { | |
17223 | for (;;) { | |
17224 | const Key &aKey = i.key(); | |
17225 | res.append(aKey); | |
17226 | do { | |
17227 | if (++i == end()) | |
17228 | goto break_out_of_outer_loop; | |
17229 | } while (aKey == i.key()); | |
17230 | } | |
17231 | } | |
17232 | break_out_of_outer_loop: | |
17233 | return res; | |
17234 | } | |
17235 | template <class Key, class T> | |
17236 | QList<Key> QHash<Key, T>::keys() const | |
17237 | { | |
17238 | QList<Key> res; | |
17239 | const_iterator i = begin(); | |
17240 | while (i != end()) { | |
17241 | res.append(i.key()); | |
17242 | ++i; | |
17243 | } | |
17244 | return res; | |
17245 | } | |
17246 | template <class Key, class T> | |
17247 | QList<Key> QHash<Key, T>::keys(const T &avalue) const | |
17248 | { | |
17249 | QList<Key> res; | |
17250 | const_iterator i = begin(); | |
17251 | while (i != end()) { | |
17252 | if (i.value() == avalue) | |
17253 | res.append(i.key()); | |
17254 | ++i; | |
17255 | } | |
17256 | return res; | |
17257 | } | |
17258 | template <class Key, class T> | |
17259 | const Key QHash<Key, T>::key(const T &avalue) const | |
17260 | { | |
17261 | return key(avalue, Key()); | |
17262 | } | |
17263 | template <class Key, class T> | |
17264 | const Key QHash<Key, T>::key(const T &avalue, const Key &defaultValue) const | |
17265 | { | |
17266 | const_iterator i = begin(); | |
17267 | while (i != end()) { | |
17268 | if (i.value() == avalue) | |
17269 | return i.key(); | |
17270 | ++i; | |
17271 | } | |
17272 | return defaultValue; | |
17273 | } | |
17274 | template <class Key, class T> | |
17275 | QList<T> QHash<Key, T>::values() const | |
17276 | { | |
17277 | QList<T> res; | |
17278 | const_iterator i = begin(); | |
17279 | while (i != end()) { | |
17280 | res.append(i.value()); | |
17281 | ++i; | |
17282 | } | |
17283 | return res; | |
17284 | } | |
17285 | template <class Key, class T> | |
17286 | QList<T> QHash<Key, T>::values(const Key &akey) const | |
17287 | { | |
17288 | QList<T> res; | |
17289 | Node *node = *findNode(akey); | |
17290 | if (node != e) { | |
17291 | do { | |
17292 | res.append(node->value); | |
17293 | } while ((node = node->next) != e && node->key == akey); | |
17294 | } | |
17295 | return res; | |
17296 | } | |
17297 | template <class Key, class T> | |
17298 | int QHash<Key, T>::count(const Key &akey) const | |
17299 | { | |
17300 | int cnt = 0; | |
17301 | Node *node = *findNode(akey); | |
17302 | if (node != e) { | |
17303 | do { | |
17304 | ++cnt; | |
17305 | } while ((node = node->next) != e && node->key == akey); | |
17306 | } | |
17307 | return cnt; | |
17308 | } | |
17309 | template <class Key, class T> | |
17310 | inline const T QHash<Key, T>::operator[](const Key &akey) const | |
17311 | { | |
17312 | return value(akey); | |
17313 | } | |
17314 | template <class Key, class T> | |
17315 | inline T &QHash<Key, T>::operator[](const Key &akey) | |
17316 | { | |
17317 | detach(); | |
17318 | uint h; | |
17319 | Node **node = findNode(akey, &h); | |
17320 | if (*node == e) { | |
17321 | if (d->willGrow()) | |
17322 | node = findNode(akey, &h); | |
17323 | return createNode(h, akey, T(), node)->value; | |
17324 | } | |
17325 | return (*node)->value; | |
17326 | } | |
17327 | template <class Key, class T> | |
17328 | inline typename QHash<Key, T>::iterator QHash<Key, T>::insert(const Key &akey, | |
17329 | const T &avalue) | |
17330 | { | |
17331 | detach(); | |
17332 | uint h; | |
17333 | Node **node = findNode(akey, &h); | |
17334 | if (*node == e) { | |
17335 | if (d->willGrow()) | |
17336 | node = findNode(akey, &h); | |
17337 | return iterator(createNode(h, akey, avalue, node)); | |
17338 | } | |
17339 | if (!QTypeInfo<T>::isDummy) | |
17340 | (*node)->value = avalue; | |
17341 | return iterator(*node); | |
17342 | } | |
17343 | template <class Key, class T> | |
17344 | inline typename QHash<Key, T>::iterator QHash<Key, T>::insertMulti(const Key &akey, | |
17345 | const T &avalue) | |
17346 | { | |
17347 | detach(); | |
17348 | d->willGrow(); | |
17349 | uint h; | |
17350 | Node **nextNode = findNode(akey, &h); | |
17351 | return iterator(createNode(h, akey, avalue, nextNode)); | |
17352 | } | |
17353 | template <class Key, class T> | |
17354 | int QHash<Key, T>::remove(const Key &akey) | |
17355 | { | |
17356 | detach(); | |
17357 | int oldSize = d->size; | |
17358 | Node **node = findNode(akey); | |
17359 | if (*node != e) { | |
17360 | bool deleteNext = true; | |
17361 | do { | |
17362 | Node *next = (*node)->next; | |
17363 | deleteNext = (next != e && next->key == (*node)->key); | |
17364 | deleteNode(*node); | |
17365 | *node = next; | |
17366 | --d->size; | |
17367 | } while (deleteNext); | |
17368 | d->hasShrunk(); | |
17369 | } | |
17370 | return oldSize - d->size; | |
17371 | } | |
17372 | template <class Key, class T> | |
17373 | T QHash<Key, T>::take(const Key &akey) | |
17374 | { | |
17375 | detach(); | |
17376 | Node **node = findNode(akey); | |
17377 | if (*node != e) { | |
17378 | T t = (*node)->value; | |
17379 | Node *next = (*node)->next; | |
17380 | deleteNode(*node); | |
17381 | *node = next; | |
17382 | --d->size; | |
17383 | d->hasShrunk(); | |
17384 | return t; | |
17385 | } | |
17386 | return T(); | |
17387 | } | |
17388 | template <class Key, class T> | |
17389 | typename QHash<Key, T>::iterator QHash<Key, T>::erase(iterator it) | |
17390 | { | |
17391 | if (it == iterator(e)) | |
17392 | return it; | |
17393 | iterator ret = it; | |
17394 | ++ret; | |
17395 | Node *node = it; | |
17396 | Node **node_ptr = reinterpret_cast<Node **>(&d->buckets[node->h % d->numBuckets]); | |
17397 | while (*node_ptr != node) | |
17398 | node_ptr = &(*node_ptr)->next; | |
17399 | *node_ptr = node->next; | |
17400 | deleteNode(node); | |
17401 | --d->size; | |
17402 | return ret; | |
17403 | } | |
17404 | template <class Key, class T> | |
17405 | inline void QHash<Key, T>::reserve(int asize) | |
17406 | { | |
17407 | detach(); | |
17408 | d->rehash(-qMax(asize, 1)); | |
17409 | } | |
17410 | template <class Key, class T> | |
17411 | inline typename QHash<Key, T>::const_iterator QHash<Key, T>::find(const Key &akey) const | |
17412 | { | |
17413 | return const_iterator(*findNode(akey)); | |
17414 | } | |
17415 | template <class Key, class T> | |
17416 | inline typename QHash<Key, T>::const_iterator QHash<Key, T>::constFind(const Key &akey) const | |
17417 | { | |
17418 | return const_iterator(*findNode(akey)); | |
17419 | } | |
17420 | template <class Key, class T> | |
17421 | inline typename QHash<Key, T>::iterator QHash<Key, T>::find(const Key &akey) | |
17422 | { | |
17423 | detach(); | |
17424 | return iterator(*findNode(akey)); | |
17425 | } | |
17426 | template <class Key, class T> | |
17427 | inline bool QHash<Key, T>::contains(const Key &akey) const | |
17428 | { | |
17429 | return *findNode(akey) != e; | |
17430 | } | |
17431 | template <class Key, class T> | |
17432 | typename QHash<Key, T>::Node **QHash<Key, T>::findNode(const Key &akey, | |
17433 | uint *ahp) const | |
17434 | { | |
17435 | Node **node; | |
17436 | uint h = qHash(akey); | |
17437 | if (d->numBuckets) { | |
17438 | node = reinterpret_cast<Node **>(&d->buckets[h % d->numBuckets]); | |
17439 | qt_noop(); | |
17440 | while (*node != e && !(*node)->same_key(h, akey)) | |
17441 | node = &(*node)->next; | |
17442 | } else { | |
17443 | node = const_cast<Node **>(reinterpret_cast<const Node * const *>(&e)); | |
17444 | } | |
17445 | if (ahp) | |
17446 | *ahp = h; | |
17447 | return node; | |
17448 | } | |
17449 | template <class Key, class T> | |
17450 | bool QHash<Key, T>::operator==(const QHash<Key, T> &other) const | |
17451 | { | |
17452 | if (size() != other.size()) | |
17453 | return false; | |
17454 | if (d == other.d) | |
17455 | return true; | |
17456 | const_iterator it = begin(); | |
17457 | while (it != end()) { | |
17458 | const Key &akey = it.key(); | |
17459 | const_iterator it2 = other.find(akey); | |
17460 | do { | |
17461 | if (it2 == other.end() || !(it2.key() == akey)) | |
17462 | return false; | |
17463 | if (!QTypeInfo<T>::isDummy && !(it.value() == it2.value())) | |
17464 | return false; | |
17465 | ++it; | |
17466 | ++it2; | |
17467 | } while (it != end() && it.key() == akey); | |
17468 | } | |
17469 | return true; | |
17470 | } | |
17471 | template <class Key, class T> | |
17472 | class QMultiHash : public QHash<Key, T> | |
17473 | { | |
17474 | public: | |
17475 | QMultiHash() {} | |
17476 | QMultiHash(const QHash<Key, T> &other) : QHash<Key, T>(other) {} | |
17477 | inline typename QHash<Key, T>::iterator replace(const Key &key, const T &value) | |
17478 | { return QHash<Key, T>::insert(key, value); } | |
17479 | inline typename QHash<Key, T>::iterator insert(const Key &key, const T &value) | |
17480 | { return QHash<Key, T>::insertMulti(key, value); } | |
17481 | inline QMultiHash &operator+=(const QMultiHash &other) | |
17482 | { unite(other); return *this; } | |
17483 | inline QMultiHash operator+(const QMultiHash &other) const | |
17484 | { QMultiHash result = *this; result += other; return result; } | |
17485 | using QHash<Key, T>::contains; | |
17486 | using QHash<Key, T>::remove; | |
17487 | using QHash<Key, T>::count; | |
17488 | using QHash<Key, T>::find; | |
17489 | using QHash<Key, T>::constFind; | |
17490 | bool contains(const Key &key, const T &value) const; | |
17491 | int remove(const Key &key, const T &value); | |
17492 | int count(const Key &key, const T &value) const; | |
17493 | typename QHash<Key, T>::iterator find(const Key &key, const T &value) { | |
17494 | typename QHash<Key, T>::iterator i(find(key)); | |
17495 | typename QHash<Key, T>::iterator end(this->end()); | |
17496 | while (i != end && i.key() == key) { | |
17497 | if (i.value() == value) | |
17498 | return i; | |
17499 | ++i; | |
17500 | } | |
17501 | return end; | |
17502 | } | |
17503 | typename QHash<Key, T>::const_iterator find(const Key &key, const T &value) const { | |
17504 | typename QHash<Key, T>::const_iterator i(constFind(key)); | |
17505 | typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd()); | |
17506 | while (i != end && i.key() == key) { | |
17507 | if (i.value() == value) | |
17508 | return i; | |
17509 | ++i; | |
17510 | } | |
17511 | return end; | |
17512 | } | |
17513 | typename QHash<Key, T>::const_iterator constFind(const Key &key, const T &value) const | |
17514 | { return find(key, value); } | |
17515 | private: | |
17516 | T &operator[](const Key &key); | |
17517 | const T operator[](const Key &key) const; | |
17518 | }; | |
17519 | template <class Key, class T> | |
17520 | inline bool QMultiHash<Key, T>::contains(const Key &key, const T &value) const | |
17521 | { | |
17522 | return constFind(key, value) != QHash<Key, T>::constEnd(); | |
17523 | } | |
17524 | template <class Key, class T> | |
17525 | inline int QMultiHash<Key, T>::remove(const Key &key, const T &value) | |
17526 | { | |
17527 | int n = 0; | |
17528 | typename QHash<Key, T>::iterator i(find(key)); | |
17529 | typename QHash<Key, T>::iterator end(QHash<Key, T>::end()); | |
17530 | while (i != end && i.key() == key) { | |
17531 | if (i.value() == value) { | |
17532 | i = erase(i); | |
17533 | ++n; | |
17534 | } else { | |
17535 | ++i; | |
17536 | } | |
17537 | } | |
17538 | return n; | |
17539 | } | |
17540 | template <class Key, class T> | |
17541 | inline int QMultiHash<Key, T>::count(const Key &key, const T &value) const | |
17542 | { | |
17543 | int n = 0; | |
17544 | typename QHash<Key, T>::const_iterator i(constFind(key)); | |
17545 | typename QHash<Key, T>::const_iterator end(QHash<Key, T>::constEnd()); | |
17546 | while (i != end && i.key() == key) { | |
17547 | if (i.value() == value) | |
17548 | ++n; | |
17549 | ++i; | |
17550 | } | |
17551 | return n; | |
17552 | } | |
17553 | template <class Key, class T> class QHashIterator { typedef typename QHash<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QHash<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QHashIterator(const QHash<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QHashIterator &operator=(const QHash<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } }; | |
17554 | template <class Key, class T> class QMutableHashIterator { typedef typename QHash<Key,T>::iterator iterator; typedef typename QHash<Key,T>::const_iterator const_iterator; typedef iterator Item; QHash<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableHashIterator(QHash<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableHashIterator() { c->setSharable(true); } inline QMutableHashIterator &operator=(QHash<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } }; | |
17555 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
17556 | enum _Rb_tree_color { _S_red = false, _S_black = true }; | |
17557 | struct _Rb_tree_node_base | |
17558 | { | |
17559 | typedef _Rb_tree_node_base* _Base_ptr; | |
17560 | typedef const _Rb_tree_node_base* _Const_Base_ptr; | |
17561 | _Rb_tree_color _M_color; | |
17562 | _Base_ptr _M_parent; | |
17563 | _Base_ptr _M_left; | |
17564 | _Base_ptr _M_right; | |
17565 | static _Base_ptr | |
17566 | _S_minimum(_Base_ptr __x) | |
17567 | { | |
17568 | while (__x->_M_left != 0) __x = __x->_M_left; | |
17569 | return __x; | |
17570 | } | |
17571 | static _Const_Base_ptr | |
17572 | _S_minimum(_Const_Base_ptr __x) | |
17573 | { | |
17574 | while (__x->_M_left != 0) __x = __x->_M_left; | |
17575 | return __x; | |
17576 | } | |
17577 | static _Base_ptr | |
17578 | _S_maximum(_Base_ptr __x) | |
17579 | { | |
17580 | while (__x->_M_right != 0) __x = __x->_M_right; | |
17581 | return __x; | |
17582 | } | |
17583 | static _Const_Base_ptr | |
17584 | _S_maximum(_Const_Base_ptr __x) | |
17585 | { | |
17586 | while (__x->_M_right != 0) __x = __x->_M_right; | |
17587 | return __x; | |
17588 | } | |
17589 | }; | |
17590 | template<typename _Val> | |
17591 | struct _Rb_tree_node : public _Rb_tree_node_base | |
17592 | { | |
17593 | typedef _Rb_tree_node<_Val>* _Link_type; | |
17594 | _Val _M_value_field; | |
17595 | }; | |
17596 | _Rb_tree_node_base* | |
17597 | _Rb_tree_increment(_Rb_tree_node_base* __x); | |
17598 | const _Rb_tree_node_base* | |
17599 | _Rb_tree_increment(const _Rb_tree_node_base* __x); | |
17600 | _Rb_tree_node_base* | |
17601 | _Rb_tree_decrement(_Rb_tree_node_base* __x); | |
17602 | const _Rb_tree_node_base* | |
17603 | _Rb_tree_decrement(const _Rb_tree_node_base* __x); | |
17604 | template<typename _Tp> | |
17605 | struct _Rb_tree_iterator | |
17606 | { | |
17607 | typedef _Tp value_type; | |
17608 | typedef _Tp& reference; | |
17609 | typedef _Tp* pointer; | |
17610 | typedef bidirectional_iterator_tag iterator_category; | |
17611 | typedef ptrdiff_t difference_type; | |
17612 | typedef _Rb_tree_iterator<_Tp> _Self; | |
17613 | typedef _Rb_tree_node_base::_Base_ptr _Base_ptr; | |
17614 | typedef _Rb_tree_node<_Tp>* _Link_type; | |
17615 | _Rb_tree_iterator() | |
17616 | : _M_node() { } | |
17617 | explicit | |
17618 | _Rb_tree_iterator(_Link_type __x) | |
17619 | : _M_node(__x) { } | |
17620 | reference | |
17621 | operator*() const | |
17622 | { return static_cast<_Link_type>(_M_node)->_M_value_field; } | |
17623 | pointer | |
17624 | operator->() const | |
17625 | { return &static_cast<_Link_type>(_M_node)->_M_value_field; } | |
17626 | _Self& | |
17627 | operator++() | |
17628 | { | |
17629 | _M_node = _Rb_tree_increment(_M_node); | |
17630 | return *this; | |
17631 | } | |
17632 | _Self | |
17633 | operator++(int) | |
17634 | { | |
17635 | _Self __tmp = *this; | |
17636 | _M_node = _Rb_tree_increment(_M_node); | |
17637 | return __tmp; | |
17638 | } | |
17639 | _Self& | |
17640 | operator--() | |
17641 | { | |
17642 | _M_node = _Rb_tree_decrement(_M_node); | |
17643 | return *this; | |
17644 | } | |
17645 | _Self | |
17646 | operator--(int) | |
17647 | { | |
17648 | _Self __tmp = *this; | |
17649 | _M_node = _Rb_tree_decrement(_M_node); | |
17650 | return __tmp; | |
17651 | } | |
17652 | bool | |
17653 | operator==(const _Self& __x) const | |
17654 | { return _M_node == __x._M_node; } | |
17655 | bool | |
17656 | operator!=(const _Self& __x) const | |
17657 | { return _M_node != __x._M_node; } | |
17658 | _Base_ptr _M_node; | |
17659 | }; | |
17660 | template<typename _Tp> | |
17661 | struct _Rb_tree_const_iterator | |
17662 | { | |
17663 | typedef _Tp value_type; | |
17664 | typedef const _Tp& reference; | |
17665 | typedef const _Tp* pointer; | |
17666 | typedef _Rb_tree_iterator<_Tp> iterator; | |
17667 | typedef bidirectional_iterator_tag iterator_category; | |
17668 | typedef ptrdiff_t difference_type; | |
17669 | typedef _Rb_tree_const_iterator<_Tp> _Self; | |
17670 | typedef _Rb_tree_node_base::_Const_Base_ptr _Base_ptr; | |
17671 | typedef const _Rb_tree_node<_Tp>* _Link_type; | |
17672 | _Rb_tree_const_iterator() | |
17673 | : _M_node() { } | |
17674 | explicit | |
17675 | _Rb_tree_const_iterator(_Link_type __x) | |
17676 | : _M_node(__x) { } | |
17677 | _Rb_tree_const_iterator(const iterator& __it) | |
17678 | : _M_node(__it._M_node) { } | |
17679 | reference | |
17680 | operator*() const | |
17681 | { return static_cast<_Link_type>(_M_node)->_M_value_field; } | |
17682 | pointer | |
17683 | operator->() const | |
17684 | { return &static_cast<_Link_type>(_M_node)->_M_value_field; } | |
17685 | _Self& | |
17686 | operator++() | |
17687 | { | |
17688 | _M_node = _Rb_tree_increment(_M_node); | |
17689 | return *this; | |
17690 | } | |
17691 | _Self | |
17692 | operator++(int) | |
17693 | { | |
17694 | _Self __tmp = *this; | |
17695 | _M_node = _Rb_tree_increment(_M_node); | |
17696 | return __tmp; | |
17697 | } | |
17698 | _Self& | |
17699 | operator--() | |
17700 | { | |
17701 | _M_node = _Rb_tree_decrement(_M_node); | |
17702 | return *this; | |
17703 | } | |
17704 | _Self | |
17705 | operator--(int) | |
17706 | { | |
17707 | _Self __tmp = *this; | |
17708 | _M_node = _Rb_tree_decrement(_M_node); | |
17709 | return __tmp; | |
17710 | } | |
17711 | bool | |
17712 | operator==(const _Self& __x) const | |
17713 | { return _M_node == __x._M_node; } | |
17714 | bool | |
17715 | operator!=(const _Self& __x) const | |
17716 | { return _M_node != __x._M_node; } | |
17717 | _Base_ptr _M_node; | |
17718 | }; | |
17719 | template<typename _Val> | |
17720 | inline bool | |
17721 | operator==(const _Rb_tree_iterator<_Val>& __x, | |
17722 | const _Rb_tree_const_iterator<_Val>& __y) | |
17723 | { return __x._M_node == __y._M_node; } | |
17724 | template<typename _Val> | |
17725 | inline bool | |
17726 | operator!=(const _Rb_tree_iterator<_Val>& __x, | |
17727 | const _Rb_tree_const_iterator<_Val>& __y) | |
17728 | { return __x._M_node != __y._M_node; } | |
17729 | void | |
17730 | _Rb_tree_insert_and_rebalance(const bool __insert_left, | |
17731 | _Rb_tree_node_base* __x, | |
17732 | _Rb_tree_node_base* __p, | |
17733 | _Rb_tree_node_base& __header); | |
17734 | _Rb_tree_node_base* | |
17735 | _Rb_tree_rebalance_for_erase(_Rb_tree_node_base* const __z, | |
17736 | _Rb_tree_node_base& __header); | |
17737 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
17738 | typename _Compare, typename _Alloc = allocator<_Val> > | |
17739 | class _Rb_tree | |
17740 | { | |
17741 | typedef typename _Alloc::template rebind<_Rb_tree_node<_Val> >::other | |
17742 | _Node_allocator; | |
17743 | protected: | |
17744 | typedef _Rb_tree_node_base* _Base_ptr; | |
17745 | typedef const _Rb_tree_node_base* _Const_Base_ptr; | |
17746 | public: | |
17747 | typedef _Key key_type; | |
17748 | typedef _Val value_type; | |
17749 | typedef value_type* pointer; | |
17750 | typedef const value_type* const_pointer; | |
17751 | typedef value_type& reference; | |
17752 | typedef const value_type& const_reference; | |
17753 | typedef _Rb_tree_node<_Val>* _Link_type; | |
17754 | typedef const _Rb_tree_node<_Val>* _Const_Link_type; | |
17755 | typedef size_t size_type; | |
17756 | typedef ptrdiff_t difference_type; | |
17757 | typedef _Alloc allocator_type; | |
17758 | _Node_allocator& | |
17759 | _M_get_Node_allocator() | |
17760 | { return *static_cast<_Node_allocator*>(&this->_M_impl); } | |
17761 | const _Node_allocator& | |
17762 | _M_get_Node_allocator() const | |
17763 | { return *static_cast<const _Node_allocator*>(&this->_M_impl); } | |
17764 | allocator_type | |
17765 | get_allocator() const | |
17766 | { return allocator_type(_M_get_Node_allocator()); } | |
17767 | protected: | |
17768 | _Link_type | |
17769 | _M_get_node() | |
17770 | { return _M_impl._Node_allocator::allocate(1); } | |
17771 | void | |
17772 | _M_put_node(_Link_type __p) | |
17773 | { _M_impl._Node_allocator::deallocate(__p, 1); } | |
17774 | _Link_type | |
17775 | _M_create_node(const value_type& __x) | |
17776 | { | |
17777 | _Link_type __tmp = _M_get_node(); | |
17778 | try | |
17779 | { get_allocator().construct(&__tmp->_M_value_field, __x); } | |
17780 | catch(...) | |
17781 | { | |
17782 | _M_put_node(__tmp); | |
17783 | throw; | |
17784 | } | |
17785 | return __tmp; | |
17786 | } | |
17787 | _Link_type | |
17788 | _M_clone_node(_Const_Link_type __x) | |
17789 | { | |
17790 | _Link_type __tmp = _M_create_node(__x->_M_value_field); | |
17791 | __tmp->_M_color = __x->_M_color; | |
17792 | __tmp->_M_left = 0; | |
17793 | __tmp->_M_right = 0; | |
17794 | return __tmp; | |
17795 | } | |
17796 | void | |
17797 | _M_destroy_node(_Link_type __p) | |
17798 | { | |
17799 | get_allocator().destroy(&__p->_M_value_field); | |
17800 | _M_put_node(__p); | |
17801 | } | |
17802 | protected: | |
17803 | template<typename _Key_compare, | |
17804 | bool _Is_pod_comparator = __is_pod(_Key_compare)> | |
17805 | struct _Rb_tree_impl : public _Node_allocator | |
17806 | { | |
17807 | _Key_compare _M_key_compare; | |
17808 | _Rb_tree_node_base _M_header; | |
17809 | size_type _M_node_count; | |
17810 | _Rb_tree_impl() | |
17811 | : _Node_allocator(), _M_key_compare(), _M_header(), | |
17812 | _M_node_count(0) | |
17813 | { _M_initialize(); } | |
17814 | _Rb_tree_impl(const _Key_compare& __comp, const _Node_allocator& __a) | |
17815 | : _Node_allocator(__a), _M_key_compare(__comp), _M_header(), | |
17816 | _M_node_count(0) | |
17817 | { _M_initialize(); } | |
17818 | private: | |
17819 | void | |
17820 | _M_initialize() | |
17821 | { | |
17822 | this->_M_header._M_color = _S_red; | |
17823 | this->_M_header._M_parent = 0; | |
17824 | this->_M_header._M_left = &this->_M_header; | |
17825 | this->_M_header._M_right = &this->_M_header; | |
17826 | } | |
17827 | }; | |
17828 | _Rb_tree_impl<_Compare> _M_impl; | |
17829 | protected: | |
17830 | _Base_ptr& | |
17831 | _M_root() | |
17832 | { return this->_M_impl._M_header._M_parent; } | |
17833 | _Const_Base_ptr | |
17834 | _M_root() const | |
17835 | { return this->_M_impl._M_header._M_parent; } | |
17836 | _Base_ptr& | |
17837 | _M_leftmost() | |
17838 | { return this->_M_impl._M_header._M_left; } | |
17839 | _Const_Base_ptr | |
17840 | _M_leftmost() const | |
17841 | { return this->_M_impl._M_header._M_left; } | |
17842 | _Base_ptr& | |
17843 | _M_rightmost() | |
17844 | { return this->_M_impl._M_header._M_right; } | |
17845 | _Const_Base_ptr | |
17846 | _M_rightmost() const | |
17847 | { return this->_M_impl._M_header._M_right; } | |
17848 | _Link_type | |
17849 | _M_begin() | |
17850 | { return static_cast<_Link_type>(this->_M_impl._M_header._M_parent); } | |
17851 | _Const_Link_type | |
17852 | _M_begin() const | |
17853 | { | |
17854 | return static_cast<_Const_Link_type> | |
17855 | (this->_M_impl._M_header._M_parent); | |
17856 | } | |
17857 | _Link_type | |
17858 | _M_end() | |
17859 | { return static_cast<_Link_type>(&this->_M_impl._M_header); } | |
17860 | _Const_Link_type | |
17861 | _M_end() const | |
17862 | { return static_cast<_Const_Link_type>(&this->_M_impl._M_header); } | |
17863 | static const_reference | |
17864 | _S_value(_Const_Link_type __x) | |
17865 | { return __x->_M_value_field; } | |
17866 | static const _Key& | |
17867 | _S_key(_Const_Link_type __x) | |
17868 | { return _KeyOfValue()(_S_value(__x)); } | |
17869 | static _Link_type | |
17870 | _S_left(_Base_ptr __x) | |
17871 | { return static_cast<_Link_type>(__x->_M_left); } | |
17872 | static _Const_Link_type | |
17873 | _S_left(_Const_Base_ptr __x) | |
17874 | { return static_cast<_Const_Link_type>(__x->_M_left); } | |
17875 | static _Link_type | |
17876 | _S_right(_Base_ptr __x) | |
17877 | { return static_cast<_Link_type>(__x->_M_right); } | |
17878 | static _Const_Link_type | |
17879 | _S_right(_Const_Base_ptr __x) | |
17880 | { return static_cast<_Const_Link_type>(__x->_M_right); } | |
17881 | static const_reference | |
17882 | _S_value(_Const_Base_ptr __x) | |
17883 | { return static_cast<_Const_Link_type>(__x)->_M_value_field; } | |
17884 | static const _Key& | |
17885 | _S_key(_Const_Base_ptr __x) | |
17886 | { return _KeyOfValue()(_S_value(__x)); } | |
17887 | static _Base_ptr | |
17888 | _S_minimum(_Base_ptr __x) | |
17889 | { return _Rb_tree_node_base::_S_minimum(__x); } | |
17890 | static _Const_Base_ptr | |
17891 | _S_minimum(_Const_Base_ptr __x) | |
17892 | { return _Rb_tree_node_base::_S_minimum(__x); } | |
17893 | static _Base_ptr | |
17894 | _S_maximum(_Base_ptr __x) | |
17895 | { return _Rb_tree_node_base::_S_maximum(__x); } | |
17896 | static _Const_Base_ptr | |
17897 | _S_maximum(_Const_Base_ptr __x) | |
17898 | { return _Rb_tree_node_base::_S_maximum(__x); } | |
17899 | public: | |
17900 | typedef _Rb_tree_iterator<value_type> iterator; | |
17901 | typedef _Rb_tree_const_iterator<value_type> const_iterator; | |
17902 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
17903 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
17904 | private: | |
17905 | iterator | |
17906 | _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __y, | |
17907 | const value_type& __v); | |
17908 | iterator | |
17909 | _M_insert_lower(_Base_ptr __x, _Base_ptr __y, const value_type& __v); | |
17910 | iterator | |
17911 | _M_insert_equal_lower(const value_type& __x); | |
17912 | _Link_type | |
17913 | _M_copy(_Const_Link_type __x, _Link_type __p); | |
17914 | void | |
17915 | _M_erase(_Link_type __x); | |
17916 | iterator | |
17917 | _M_lower_bound(_Link_type __x, _Link_type __y, | |
17918 | const _Key& __k); | |
17919 | const_iterator | |
17920 | _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, | |
17921 | const _Key& __k) const; | |
17922 | iterator | |
17923 | _M_upper_bound(_Link_type __x, _Link_type __y, | |
17924 | const _Key& __k); | |
17925 | const_iterator | |
17926 | _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, | |
17927 | const _Key& __k) const; | |
17928 | public: | |
17929 | _Rb_tree() { } | |
17930 | _Rb_tree(const _Compare& __comp, | |
17931 | const allocator_type& __a = allocator_type()) | |
17932 | : _M_impl(__comp, __a) { } | |
17933 | _Rb_tree(const _Rb_tree& __x) | |
17934 | : _M_impl(__x._M_impl._M_key_compare, __x._M_get_Node_allocator()) | |
17935 | { | |
17936 | if (__x._M_root() != 0) | |
17937 | { | |
17938 | _M_root() = _M_copy(__x._M_begin(), _M_end()); | |
17939 | _M_leftmost() = _S_minimum(_M_root()); | |
17940 | _M_rightmost() = _S_maximum(_M_root()); | |
17941 | _M_impl._M_node_count = __x._M_impl._M_node_count; | |
17942 | } | |
17943 | } | |
17944 | ~_Rb_tree() | |
17945 | { _M_erase(_M_begin()); } | |
17946 | _Rb_tree& | |
17947 | operator=(const _Rb_tree& __x); | |
17948 | _Compare | |
17949 | key_comp() const | |
17950 | { return _M_impl._M_key_compare; } | |
17951 | iterator | |
17952 | begin() | |
17953 | { | |
17954 | return iterator(static_cast<_Link_type> | |
17955 | (this->_M_impl._M_header._M_left)); | |
17956 | } | |
17957 | const_iterator | |
17958 | begin() const | |
17959 | { | |
17960 | return const_iterator(static_cast<_Const_Link_type> | |
17961 | (this->_M_impl._M_header._M_left)); | |
17962 | } | |
17963 | iterator | |
17964 | end() | |
17965 | { return iterator(static_cast<_Link_type>(&this->_M_impl._M_header)); } | |
17966 | const_iterator | |
17967 | end() const | |
17968 | { | |
17969 | return const_iterator(static_cast<_Const_Link_type> | |
17970 | (&this->_M_impl._M_header)); | |
17971 | } | |
17972 | reverse_iterator | |
17973 | rbegin() | |
17974 | { return reverse_iterator(end()); } | |
17975 | const_reverse_iterator | |
17976 | rbegin() const | |
17977 | { return const_reverse_iterator(end()); } | |
17978 | reverse_iterator | |
17979 | rend() | |
17980 | { return reverse_iterator(begin()); } | |
17981 | const_reverse_iterator | |
17982 | rend() const | |
17983 | { return const_reverse_iterator(begin()); } | |
17984 | bool | |
17985 | empty() const | |
17986 | { return _M_impl._M_node_count == 0; } | |
17987 | size_type | |
17988 | size() const | |
17989 | { return _M_impl._M_node_count; } | |
17990 | size_type | |
17991 | max_size() const | |
17992 | { return get_allocator().max_size(); } | |
17993 | void | |
17994 | swap(_Rb_tree& __t); | |
17995 | pair<iterator, bool> | |
17996 | _M_insert_unique(const value_type& __x); | |
17997 | iterator | |
17998 | _M_insert_equal(const value_type& __x); | |
17999 | iterator | |
18000 | _M_insert_unique_(const_iterator __position, const value_type& __x); | |
18001 | iterator | |
18002 | _M_insert_equal_(const_iterator __position, const value_type& __x); | |
18003 | template<typename _InputIterator> | |
18004 | void | |
18005 | _M_insert_unique(_InputIterator __first, _InputIterator __last); | |
18006 | template<typename _InputIterator> | |
18007 | void | |
18008 | _M_insert_equal(_InputIterator __first, _InputIterator __last); | |
18009 | void | |
18010 | erase(iterator __position); | |
18011 | void | |
18012 | erase(const_iterator __position); | |
18013 | size_type | |
18014 | erase(const key_type& __x); | |
18015 | void | |
18016 | erase(iterator __first, iterator __last); | |
18017 | void | |
18018 | erase(const_iterator __first, const_iterator __last); | |
18019 | void | |
18020 | erase(const key_type* __first, const key_type* __last); | |
18021 | void | |
18022 | clear() | |
18023 | { | |
18024 | _M_erase(_M_begin()); | |
18025 | _M_leftmost() = _M_end(); | |
18026 | _M_root() = 0; | |
18027 | _M_rightmost() = _M_end(); | |
18028 | _M_impl._M_node_count = 0; | |
18029 | } | |
18030 | iterator | |
18031 | find(const key_type& __k); | |
18032 | const_iterator | |
18033 | find(const key_type& __k) const; | |
18034 | size_type | |
18035 | count(const key_type& __k) const; | |
18036 | iterator | |
18037 | lower_bound(const key_type& __k) | |
18038 | { return _M_lower_bound(_M_begin(), _M_end(), __k); } | |
18039 | const_iterator | |
18040 | lower_bound(const key_type& __k) const | |
18041 | { return _M_lower_bound(_M_begin(), _M_end(), __k); } | |
18042 | iterator | |
18043 | upper_bound(const key_type& __k) | |
18044 | { return _M_upper_bound(_M_begin(), _M_end(), __k); } | |
18045 | const_iterator | |
18046 | upper_bound(const key_type& __k) const | |
18047 | { return _M_upper_bound(_M_begin(), _M_end(), __k); } | |
18048 | pair<iterator, iterator> | |
18049 | equal_range(const key_type& __k); | |
18050 | pair<const_iterator, const_iterator> | |
18051 | equal_range(const key_type& __k) const; | |
18052 | bool | |
18053 | __rb_verify() const; | |
18054 | }; | |
18055 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18056 | typename _Compare, typename _Alloc> | |
18057 | inline bool | |
18058 | operator==(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18059 | const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18060 | { | |
18061 | return __x.size() == __y.size() | |
18062 | && std::equal(__x.begin(), __x.end(), __y.begin()); | |
18063 | } | |
18064 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18065 | typename _Compare, typename _Alloc> | |
18066 | inline bool | |
18067 | operator<(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18068 | const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18069 | { | |
18070 | return std::lexicographical_compare(__x.begin(), __x.end(), | |
18071 | __y.begin(), __y.end()); | |
18072 | } | |
18073 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18074 | typename _Compare, typename _Alloc> | |
18075 | inline bool | |
18076 | operator!=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18077 | const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18078 | { return !(__x == __y); } | |
18079 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18080 | typename _Compare, typename _Alloc> | |
18081 | inline bool | |
18082 | operator>(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18083 | const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18084 | { return __y < __x; } | |
18085 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18086 | typename _Compare, typename _Alloc> | |
18087 | inline bool | |
18088 | operator<=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18089 | const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18090 | { return !(__y < __x); } | |
18091 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18092 | typename _Compare, typename _Alloc> | |
18093 | inline bool | |
18094 | operator>=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18095 | const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18096 | { return !(__x < __y); } | |
18097 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18098 | typename _Compare, typename _Alloc> | |
18099 | inline void | |
18100 | swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x, | |
18101 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __y) | |
18102 | { __x.swap(__y); } | |
18103 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18104 | typename _Compare, typename _Alloc> | |
18105 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& | |
18106 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18107 | operator=(const _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __x) | |
18108 | { | |
18109 | if (this != &__x) | |
18110 | { | |
18111 | clear(); | |
18112 | _M_impl._M_key_compare = __x._M_impl._M_key_compare; | |
18113 | if (__x._M_root() != 0) | |
18114 | { | |
18115 | _M_root() = _M_copy(__x._M_begin(), _M_end()); | |
18116 | _M_leftmost() = _S_minimum(_M_root()); | |
18117 | _M_rightmost() = _S_maximum(_M_root()); | |
18118 | _M_impl._M_node_count = __x._M_impl._M_node_count; | |
18119 | } | |
18120 | } | |
18121 | return *this; | |
18122 | } | |
18123 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18124 | typename _Compare, typename _Alloc> | |
18125 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
18126 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18127 | _M_insert_(_Const_Base_ptr __x, _Const_Base_ptr __p, const _Val& __v) | |
18128 | { | |
18129 | bool __insert_left = (__x != 0 || __p == _M_end() | |
18130 | || _M_impl._M_key_compare(_KeyOfValue()(__v), | |
18131 | _S_key(__p))); | |
18132 | _Link_type __z = _M_create_node(__v); | |
18133 | _Rb_tree_insert_and_rebalance(__insert_left, __z, | |
18134 | const_cast<_Base_ptr>(__p), | |
18135 | this->_M_impl._M_header); | |
18136 | ++_M_impl._M_node_count; | |
18137 | return iterator(__z); | |
18138 | } | |
18139 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18140 | typename _Compare, typename _Alloc> | |
18141 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
18142 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18143 | _M_insert_lower(_Base_ptr __x, _Base_ptr __p, const _Val& __v) | |
18144 | { | |
18145 | bool __insert_left = (__x != 0 || __p == _M_end() | |
18146 | || !_M_impl._M_key_compare(_S_key(__p), | |
18147 | _KeyOfValue()(__v))); | |
18148 | _Link_type __z = _M_create_node(__v); | |
18149 | _Rb_tree_insert_and_rebalance(__insert_left, __z, __p, | |
18150 | this->_M_impl._M_header); | |
18151 | ++_M_impl._M_node_count; | |
18152 | return iterator(__z); | |
18153 | } | |
18154 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18155 | typename _Compare, typename _Alloc> | |
18156 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
18157 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18158 | _M_insert_equal_lower(const _Val& __v) | |
18159 | { | |
18160 | _Link_type __x = _M_begin(); | |
18161 | _Link_type __y = _M_end(); | |
18162 | while (__x != 0) | |
18163 | { | |
18164 | __y = __x; | |
18165 | __x = !_M_impl._M_key_compare(_S_key(__x), _KeyOfValue()(__v)) ? | |
18166 | _S_left(__x) : _S_right(__x); | |
18167 | } | |
18168 | return _M_insert_lower(__x, __y, __v); | |
18169 | } | |
18170 | template<typename _Key, typename _Val, typename _KoV, | |
18171 | typename _Compare, typename _Alloc> | |
18172 | typename _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>::_Link_type | |
18173 | _Rb_tree<_Key, _Val, _KoV, _Compare, _Alloc>:: | |
18174 | _M_copy(_Const_Link_type __x, _Link_type __p) | |
18175 | { | |
18176 | _Link_type __top = _M_clone_node(__x); | |
18177 | __top->_M_parent = __p; | |
18178 | try | |
18179 | { | |
18180 | if (__x->_M_right) | |
18181 | __top->_M_right = _M_copy(_S_right(__x), __top); | |
18182 | __p = __top; | |
18183 | __x = _S_left(__x); | |
18184 | while (__x != 0) | |
18185 | { | |
18186 | _Link_type __y = _M_clone_node(__x); | |
18187 | __p->_M_left = __y; | |
18188 | __y->_M_parent = __p; | |
18189 | if (__x->_M_right) | |
18190 | __y->_M_right = _M_copy(_S_right(__x), __y); | |
18191 | __p = __y; | |
18192 | __x = _S_left(__x); | |
18193 | } | |
18194 | } | |
18195 | catch(...) | |
18196 | { | |
18197 | _M_erase(__top); | |
18198 | throw; | |
18199 | } | |
18200 | return __top; | |
18201 | } | |
18202 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18203 | typename _Compare, typename _Alloc> | |
18204 | void | |
18205 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18206 | _M_erase(_Link_type __x) | |
18207 | { | |
18208 | while (__x != 0) | |
18209 | { | |
18210 | _M_erase(_S_right(__x)); | |
18211 | _Link_type __y = _S_left(__x); | |
18212 | _M_destroy_node(__x); | |
18213 | __x = __y; | |
18214 | } | |
18215 | } | |
18216 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18217 | typename _Compare, typename _Alloc> | |
18218 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18219 | _Compare, _Alloc>::iterator | |
18220 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18221 | _M_lower_bound(_Link_type __x, _Link_type __y, | |
18222 | const _Key& __k) | |
18223 | { | |
18224 | while (__x != 0) | |
18225 | if (!_M_impl._M_key_compare(_S_key(__x), __k)) | |
18226 | __y = __x, __x = _S_left(__x); | |
18227 | else | |
18228 | __x = _S_right(__x); | |
18229 | return iterator(__y); | |
18230 | } | |
18231 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18232 | typename _Compare, typename _Alloc> | |
18233 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18234 | _Compare, _Alloc>::const_iterator | |
18235 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18236 | _M_lower_bound(_Const_Link_type __x, _Const_Link_type __y, | |
18237 | const _Key& __k) const | |
18238 | { | |
18239 | while (__x != 0) | |
18240 | if (!_M_impl._M_key_compare(_S_key(__x), __k)) | |
18241 | __y = __x, __x = _S_left(__x); | |
18242 | else | |
18243 | __x = _S_right(__x); | |
18244 | return const_iterator(__y); | |
18245 | } | |
18246 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18247 | typename _Compare, typename _Alloc> | |
18248 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18249 | _Compare, _Alloc>::iterator | |
18250 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18251 | _M_upper_bound(_Link_type __x, _Link_type __y, | |
18252 | const _Key& __k) | |
18253 | { | |
18254 | while (__x != 0) | |
18255 | if (_M_impl._M_key_compare(__k, _S_key(__x))) | |
18256 | __y = __x, __x = _S_left(__x); | |
18257 | else | |
18258 | __x = _S_right(__x); | |
18259 | return iterator(__y); | |
18260 | } | |
18261 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18262 | typename _Compare, typename _Alloc> | |
18263 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18264 | _Compare, _Alloc>::const_iterator | |
18265 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18266 | _M_upper_bound(_Const_Link_type __x, _Const_Link_type __y, | |
18267 | const _Key& __k) const | |
18268 | { | |
18269 | while (__x != 0) | |
18270 | if (_M_impl._M_key_compare(__k, _S_key(__x))) | |
18271 | __y = __x, __x = _S_left(__x); | |
18272 | else | |
18273 | __x = _S_right(__x); | |
18274 | return const_iterator(__y); | |
18275 | } | |
18276 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18277 | typename _Compare, typename _Alloc> | |
18278 | pair<typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18279 | _Compare, _Alloc>::iterator, | |
18280 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18281 | _Compare, _Alloc>::iterator> | |
18282 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18283 | equal_range(const _Key& __k) | |
18284 | { | |
18285 | _Link_type __x = _M_begin(); | |
18286 | _Link_type __y = _M_end(); | |
18287 | while (__x != 0) | |
18288 | { | |
18289 | if (_M_impl._M_key_compare(_S_key(__x), __k)) | |
18290 | __x = _S_right(__x); | |
18291 | else if (_M_impl._M_key_compare(__k, _S_key(__x))) | |
18292 | __y = __x, __x = _S_left(__x); | |
18293 | else | |
18294 | { | |
18295 | _Link_type __xu(__x), __yu(__y); | |
18296 | __y = __x, __x = _S_left(__x); | |
18297 | __xu = _S_right(__xu); | |
18298 | return pair<iterator, | |
18299 | iterator>(_M_lower_bound(__x, __y, __k), | |
18300 | _M_upper_bound(__xu, __yu, __k)); | |
18301 | } | |
18302 | } | |
18303 | return pair<iterator, iterator>(iterator(__y), | |
18304 | iterator(__y)); | |
18305 | } | |
18306 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18307 | typename _Compare, typename _Alloc> | |
18308 | pair<typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18309 | _Compare, _Alloc>::const_iterator, | |
18310 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18311 | _Compare, _Alloc>::const_iterator> | |
18312 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18313 | equal_range(const _Key& __k) const | |
18314 | { | |
18315 | _Const_Link_type __x = _M_begin(); | |
18316 | _Const_Link_type __y = _M_end(); | |
18317 | while (__x != 0) | |
18318 | { | |
18319 | if (_M_impl._M_key_compare(_S_key(__x), __k)) | |
18320 | __x = _S_right(__x); | |
18321 | else if (_M_impl._M_key_compare(__k, _S_key(__x))) | |
18322 | __y = __x, __x = _S_left(__x); | |
18323 | else | |
18324 | { | |
18325 | _Const_Link_type __xu(__x), __yu(__y); | |
18326 | __y = __x, __x = _S_left(__x); | |
18327 | __xu = _S_right(__xu); | |
18328 | return pair<const_iterator, | |
18329 | const_iterator>(_M_lower_bound(__x, __y, __k), | |
18330 | _M_upper_bound(__xu, __yu, __k)); | |
18331 | } | |
18332 | } | |
18333 | return pair<const_iterator, const_iterator>(const_iterator(__y), | |
18334 | const_iterator(__y)); | |
18335 | } | |
18336 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18337 | typename _Compare, typename _Alloc> | |
18338 | void | |
18339 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18340 | swap(_Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>& __t) | |
18341 | { | |
18342 | if (_M_root() == 0) | |
18343 | { | |
18344 | if (__t._M_root() != 0) | |
18345 | { | |
18346 | _M_root() = __t._M_root(); | |
18347 | _M_leftmost() = __t._M_leftmost(); | |
18348 | _M_rightmost() = __t._M_rightmost(); | |
18349 | _M_root()->_M_parent = _M_end(); | |
18350 | __t._M_root() = 0; | |
18351 | __t._M_leftmost() = __t._M_end(); | |
18352 | __t._M_rightmost() = __t._M_end(); | |
18353 | } | |
18354 | } | |
18355 | else if (__t._M_root() == 0) | |
18356 | { | |
18357 | __t._M_root() = _M_root(); | |
18358 | __t._M_leftmost() = _M_leftmost(); | |
18359 | __t._M_rightmost() = _M_rightmost(); | |
18360 | __t._M_root()->_M_parent = __t._M_end(); | |
18361 | _M_root() = 0; | |
18362 | _M_leftmost() = _M_end(); | |
18363 | _M_rightmost() = _M_end(); | |
18364 | } | |
18365 | else | |
18366 | { | |
18367 | std::swap(_M_root(),__t._M_root()); | |
18368 | std::swap(_M_leftmost(),__t._M_leftmost()); | |
18369 | std::swap(_M_rightmost(),__t._M_rightmost()); | |
18370 | _M_root()->_M_parent = _M_end(); | |
18371 | __t._M_root()->_M_parent = __t._M_end(); | |
18372 | } | |
18373 | std::swap(this->_M_impl._M_node_count, __t._M_impl._M_node_count); | |
18374 | std::swap(this->_M_impl._M_key_compare, __t._M_impl._M_key_compare); | |
18375 | std::__alloc_swap<_Node_allocator>:: | |
18376 | _S_do_it(_M_get_Node_allocator(), __t._M_get_Node_allocator()); | |
18377 | } | |
18378 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18379 | typename _Compare, typename _Alloc> | |
18380 | pair<typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18381 | _Compare, _Alloc>::iterator, bool> | |
18382 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18383 | _M_insert_unique(const _Val& __v) | |
18384 | { | |
18385 | _Link_type __x = _M_begin(); | |
18386 | _Link_type __y = _M_end(); | |
18387 | bool __comp = true; | |
18388 | while (__x != 0) | |
18389 | { | |
18390 | __y = __x; | |
18391 | __comp = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)); | |
18392 | __x = __comp ? _S_left(__x) : _S_right(__x); | |
18393 | } | |
18394 | iterator __j = iterator(__y); | |
18395 | if (__comp) | |
18396 | { | |
18397 | if (__j == begin()) | |
18398 | return pair<iterator, bool>(_M_insert_(__x, __y, __v), true); | |
18399 | else | |
18400 | --__j; | |
18401 | } | |
18402 | if (_M_impl._M_key_compare(_S_key(__j._M_node), _KeyOfValue()(__v))) | |
18403 | return pair<iterator, bool>(_M_insert_(__x, __y, __v), true); | |
18404 | return pair<iterator, bool>(__j, false); | |
18405 | } | |
18406 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18407 | typename _Compare, typename _Alloc> | |
18408 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
18409 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18410 | _M_insert_equal(const _Val& __v) | |
18411 | { | |
18412 | _Link_type __x = _M_begin(); | |
18413 | _Link_type __y = _M_end(); | |
18414 | while (__x != 0) | |
18415 | { | |
18416 | __y = __x; | |
18417 | __x = _M_impl._M_key_compare(_KeyOfValue()(__v), _S_key(__x)) ? | |
18418 | _S_left(__x) : _S_right(__x); | |
18419 | } | |
18420 | return _M_insert_(__x, __y, __v); | |
18421 | } | |
18422 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18423 | typename _Compare, typename _Alloc> | |
18424 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
18425 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18426 | _M_insert_unique_(const_iterator __position, const _Val& __v) | |
18427 | { | |
18428 | if (__position._M_node == _M_end()) | |
18429 | { | |
18430 | if (size() > 0 | |
18431 | && _M_impl._M_key_compare(_S_key(_M_rightmost()), | |
18432 | _KeyOfValue()(__v))) | |
18433 | return _M_insert_(0, _M_rightmost(), __v); | |
18434 | else | |
18435 | return _M_insert_unique(__v).first; | |
18436 | } | |
18437 | else if (_M_impl._M_key_compare(_KeyOfValue()(__v), | |
18438 | _S_key(__position._M_node))) | |
18439 | { | |
18440 | const_iterator __before = __position; | |
18441 | if (__position._M_node == _M_leftmost()) | |
18442 | return _M_insert_(_M_leftmost(), _M_leftmost(), __v); | |
18443 | else if (_M_impl._M_key_compare(_S_key((--__before)._M_node), | |
18444 | _KeyOfValue()(__v))) | |
18445 | { | |
18446 | if (_S_right(__before._M_node) == 0) | |
18447 | return _M_insert_(0, __before._M_node, __v); | |
18448 | else | |
18449 | return _M_insert_(__position._M_node, | |
18450 | __position._M_node, __v); | |
18451 | } | |
18452 | else | |
18453 | return _M_insert_unique(__v).first; | |
18454 | } | |
18455 | else if (_M_impl._M_key_compare(_S_key(__position._M_node), | |
18456 | _KeyOfValue()(__v))) | |
18457 | { | |
18458 | const_iterator __after = __position; | |
18459 | if (__position._M_node == _M_rightmost()) | |
18460 | return _M_insert_(0, _M_rightmost(), __v); | |
18461 | else if (_M_impl._M_key_compare(_KeyOfValue()(__v), | |
18462 | _S_key((++__after)._M_node))) | |
18463 | { | |
18464 | if (_S_right(__position._M_node) == 0) | |
18465 | return _M_insert_(0, __position._M_node, __v); | |
18466 | else | |
18467 | return _M_insert_(__after._M_node, __after._M_node, __v); | |
18468 | } | |
18469 | else | |
18470 | return _M_insert_unique(__v).first; | |
18471 | } | |
18472 | else | |
18473 | return iterator(static_cast<_Link_type> | |
18474 | (const_cast<_Base_ptr>(__position._M_node))); | |
18475 | } | |
18476 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18477 | typename _Compare, typename _Alloc> | |
18478 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::iterator | |
18479 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18480 | _M_insert_equal_(const_iterator __position, const _Val& __v) | |
18481 | { | |
18482 | if (__position._M_node == _M_end()) | |
18483 | { | |
18484 | if (size() > 0 | |
18485 | && !_M_impl._M_key_compare(_KeyOfValue()(__v), | |
18486 | _S_key(_M_rightmost()))) | |
18487 | return _M_insert_(0, _M_rightmost(), __v); | |
18488 | else | |
18489 | return _M_insert_equal(__v); | |
18490 | } | |
18491 | else if (!_M_impl._M_key_compare(_S_key(__position._M_node), | |
18492 | _KeyOfValue()(__v))) | |
18493 | { | |
18494 | const_iterator __before = __position; | |
18495 | if (__position._M_node == _M_leftmost()) | |
18496 | return _M_insert_(_M_leftmost(), _M_leftmost(), __v); | |
18497 | else if (!_M_impl._M_key_compare(_KeyOfValue()(__v), | |
18498 | _S_key((--__before)._M_node))) | |
18499 | { | |
18500 | if (_S_right(__before._M_node) == 0) | |
18501 | return _M_insert_(0, __before._M_node, __v); | |
18502 | else | |
18503 | return _M_insert_(__position._M_node, | |
18504 | __position._M_node, __v); | |
18505 | } | |
18506 | else | |
18507 | return _M_insert_equal(__v); | |
18508 | } | |
18509 | else | |
18510 | { | |
18511 | const_iterator __after = __position; | |
18512 | if (__position._M_node == _M_rightmost()) | |
18513 | return _M_insert_(0, _M_rightmost(), __v); | |
18514 | else if (!_M_impl._M_key_compare(_S_key((++__after)._M_node), | |
18515 | _KeyOfValue()(__v))) | |
18516 | { | |
18517 | if (_S_right(__position._M_node) == 0) | |
18518 | return _M_insert_(0, __position._M_node, __v); | |
18519 | else | |
18520 | return _M_insert_(__after._M_node, __after._M_node, __v); | |
18521 | } | |
18522 | else | |
18523 | return _M_insert_equal_lower(__v); | |
18524 | } | |
18525 | } | |
18526 | template<typename _Key, typename _Val, typename _KoV, | |
18527 | typename _Cmp, typename _Alloc> | |
18528 | template<class _II> | |
18529 | void | |
18530 | _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>:: | |
18531 | _M_insert_unique(_II __first, _II __last) | |
18532 | { | |
18533 | for (; __first != __last; ++__first) | |
18534 | _M_insert_unique_(end(), *__first); | |
18535 | } | |
18536 | template<typename _Key, typename _Val, typename _KoV, | |
18537 | typename _Cmp, typename _Alloc> | |
18538 | template<class _II> | |
18539 | void | |
18540 | _Rb_tree<_Key, _Val, _KoV, _Cmp, _Alloc>:: | |
18541 | _M_insert_equal(_II __first, _II __last) | |
18542 | { | |
18543 | for (; __first != __last; ++__first) | |
18544 | _M_insert_equal_(end(), *__first); | |
18545 | } | |
18546 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18547 | typename _Compare, typename _Alloc> | |
18548 | inline void | |
18549 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18550 | erase(iterator __position) | |
18551 | { | |
18552 | _Link_type __y = | |
18553 | static_cast<_Link_type>(_Rb_tree_rebalance_for_erase | |
18554 | (__position._M_node, | |
18555 | this->_M_impl._M_header)); | |
18556 | _M_destroy_node(__y); | |
18557 | --_M_impl._M_node_count; | |
18558 | } | |
18559 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18560 | typename _Compare, typename _Alloc> | |
18561 | inline void | |
18562 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18563 | erase(const_iterator __position) | |
18564 | { | |
18565 | _Link_type __y = | |
18566 | static_cast<_Link_type>(_Rb_tree_rebalance_for_erase | |
18567 | (const_cast<_Base_ptr>(__position._M_node), | |
18568 | this->_M_impl._M_header)); | |
18569 | _M_destroy_node(__y); | |
18570 | --_M_impl._M_node_count; | |
18571 | } | |
18572 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18573 | typename _Compare, typename _Alloc> | |
18574 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type | |
18575 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18576 | erase(const _Key& __x) | |
18577 | { | |
18578 | pair<iterator, iterator> __p = equal_range(__x); | |
18579 | const size_type __old_size = size(); | |
18580 | erase(__p.first, __p.second); | |
18581 | return __old_size - size(); | |
18582 | } | |
18583 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18584 | typename _Compare, typename _Alloc> | |
18585 | void | |
18586 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18587 | erase(iterator __first, iterator __last) | |
18588 | { | |
18589 | if (__first == begin() && __last == end()) | |
18590 | clear(); | |
18591 | else | |
18592 | while (__first != __last) | |
18593 | erase(__first++); | |
18594 | } | |
18595 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18596 | typename _Compare, typename _Alloc> | |
18597 | void | |
18598 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18599 | erase(const_iterator __first, const_iterator __last) | |
18600 | { | |
18601 | if (__first == begin() && __last == end()) | |
18602 | clear(); | |
18603 | else | |
18604 | while (__first != __last) | |
18605 | erase(__first++); | |
18606 | } | |
18607 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18608 | typename _Compare, typename _Alloc> | |
18609 | void | |
18610 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18611 | erase(const _Key* __first, const _Key* __last) | |
18612 | { | |
18613 | while (__first != __last) | |
18614 | erase(*__first++); | |
18615 | } | |
18616 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18617 | typename _Compare, typename _Alloc> | |
18618 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18619 | _Compare, _Alloc>::iterator | |
18620 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18621 | find(const _Key& __k) | |
18622 | { | |
18623 | iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); | |
18624 | return (__j == end() | |
18625 | || _M_impl._M_key_compare(__k, | |
18626 | _S_key(__j._M_node))) ? end() : __j; | |
18627 | } | |
18628 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18629 | typename _Compare, typename _Alloc> | |
18630 | typename _Rb_tree<_Key, _Val, _KeyOfValue, | |
18631 | _Compare, _Alloc>::const_iterator | |
18632 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18633 | find(const _Key& __k) const | |
18634 | { | |
18635 | const_iterator __j = _M_lower_bound(_M_begin(), _M_end(), __k); | |
18636 | return (__j == end() | |
18637 | || _M_impl._M_key_compare(__k, | |
18638 | _S_key(__j._M_node))) ? end() : __j; | |
18639 | } | |
18640 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18641 | typename _Compare, typename _Alloc> | |
18642 | typename _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>::size_type | |
18643 | _Rb_tree<_Key, _Val, _KeyOfValue, _Compare, _Alloc>:: | |
18644 | count(const _Key& __k) const | |
18645 | { | |
18646 | pair<const_iterator, const_iterator> __p = equal_range(__k); | |
18647 | const size_type __n = std::distance(__p.first, __p.second); | |
18648 | return __n; | |
18649 | } | |
18650 | unsigned int | |
18651 | _Rb_tree_black_count(const _Rb_tree_node_base* __node, | |
18652 | const _Rb_tree_node_base* __root); | |
18653 | template<typename _Key, typename _Val, typename _KeyOfValue, | |
18654 | typename _Compare, typename _Alloc> | |
18655 | bool | |
18656 | _Rb_tree<_Key,_Val,_KeyOfValue,_Compare,_Alloc>::__rb_verify() const | |
18657 | { | |
18658 | if (_M_impl._M_node_count == 0 || begin() == end()) | |
18659 | return _M_impl._M_node_count == 0 && begin() == end() | |
18660 | && this->_M_impl._M_header._M_left == _M_end() | |
18661 | && this->_M_impl._M_header._M_right == _M_end(); | |
18662 | unsigned int __len = _Rb_tree_black_count(_M_leftmost(), _M_root()); | |
18663 | for (const_iterator __it = begin(); __it != end(); ++__it) | |
18664 | { | |
18665 | _Const_Link_type __x = static_cast<_Const_Link_type>(__it._M_node); | |
18666 | _Const_Link_type __L = _S_left(__x); | |
18667 | _Const_Link_type __R = _S_right(__x); | |
18668 | if (__x->_M_color == _S_red) | |
18669 | if ((__L && __L->_M_color == _S_red) | |
18670 | || (__R && __R->_M_color == _S_red)) | |
18671 | return false; | |
18672 | if (__L && _M_impl._M_key_compare(_S_key(__x), _S_key(__L))) | |
18673 | return false; | |
18674 | if (__R && _M_impl._M_key_compare(_S_key(__R), _S_key(__x))) | |
18675 | return false; | |
18676 | if (!__L && !__R && _Rb_tree_black_count(__x, _M_root()) != __len) | |
18677 | return false; | |
18678 | } | |
18679 | if (_M_leftmost() != _Rb_tree_node_base::_S_minimum(_M_root())) | |
18680 | return false; | |
18681 | if (_M_rightmost() != _Rb_tree_node_base::_S_maximum(_M_root())) | |
18682 | return false; | |
18683 | return true; | |
18684 | } | |
18685 | } | |
18686 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
18687 | template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>, | |
18688 | typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > > | |
18689 | class map | |
18690 | { | |
18691 | public: | |
18692 | typedef _Key key_type; | |
18693 | typedef _Tp mapped_type; | |
18694 | typedef std::pair<const _Key, _Tp> value_type; | |
18695 | typedef _Compare key_compare; | |
18696 | typedef _Alloc allocator_type; | |
18697 | private: | |
18698 | typedef typename _Alloc::value_type _Alloc_value_type; | |
18699 | public: | |
18700 | class value_compare | |
18701 | : public std::binary_function<value_type, value_type, bool> | |
18702 | { | |
18703 | friend class map<_Key, _Tp, _Compare, _Alloc>; | |
18704 | protected: | |
18705 | _Compare comp; | |
18706 | value_compare(_Compare __c) | |
18707 | : comp(__c) { } | |
18708 | public: | |
18709 | bool operator()(const value_type& __x, const value_type& __y) const | |
18710 | { return comp(__x.first, __y.first); } | |
18711 | }; | |
18712 | private: | |
18713 | typedef typename _Alloc::template rebind<value_type>::other | |
18714 | _Pair_alloc_type; | |
18715 | typedef _Rb_tree<key_type, value_type, _Select1st<value_type>, | |
18716 | key_compare, _Pair_alloc_type> _Rep_type; | |
18717 | _Rep_type _M_t; | |
18718 | public: | |
18719 | typedef typename _Pair_alloc_type::pointer pointer; | |
18720 | typedef typename _Pair_alloc_type::const_pointer const_pointer; | |
18721 | typedef typename _Pair_alloc_type::reference reference; | |
18722 | typedef typename _Pair_alloc_type::const_reference const_reference; | |
18723 | typedef typename _Rep_type::iterator iterator; | |
18724 | typedef typename _Rep_type::const_iterator const_iterator; | |
18725 | typedef typename _Rep_type::size_type size_type; | |
18726 | typedef typename _Rep_type::difference_type difference_type; | |
18727 | typedef typename _Rep_type::reverse_iterator reverse_iterator; | |
18728 | typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; | |
18729 | map() | |
18730 | : _M_t() { } | |
18731 | explicit | |
18732 | map(const _Compare& __comp, | |
18733 | const allocator_type& __a = allocator_type()) | |
18734 | : _M_t(__comp, __a) { } | |
18735 | map(const map& __x) | |
18736 | : _M_t(__x._M_t) { } | |
18737 | template<typename _InputIterator> | |
18738 | map(_InputIterator __first, _InputIterator __last) | |
18739 | : _M_t() | |
18740 | { _M_t._M_insert_unique(__first, __last); } | |
18741 | template<typename _InputIterator> | |
18742 | map(_InputIterator __first, _InputIterator __last, | |
18743 | const _Compare& __comp, | |
18744 | const allocator_type& __a = allocator_type()) | |
18745 | : _M_t(__comp, __a) | |
18746 | { _M_t._M_insert_unique(__first, __last); } | |
18747 | map& | |
18748 | operator=(const map& __x) | |
18749 | { | |
18750 | _M_t = __x._M_t; | |
18751 | return *this; | |
18752 | } | |
18753 | allocator_type | |
18754 | get_allocator() const | |
18755 | { return _M_t.get_allocator(); } | |
18756 | iterator | |
18757 | begin() | |
18758 | { return _M_t.begin(); } | |
18759 | const_iterator | |
18760 | begin() const | |
18761 | { return _M_t.begin(); } | |
18762 | iterator | |
18763 | end() | |
18764 | { return _M_t.end(); } | |
18765 | const_iterator | |
18766 | end() const | |
18767 | { return _M_t.end(); } | |
18768 | reverse_iterator | |
18769 | rbegin() | |
18770 | { return _M_t.rbegin(); } | |
18771 | const_reverse_iterator | |
18772 | rbegin() const | |
18773 | { return _M_t.rbegin(); } | |
18774 | reverse_iterator | |
18775 | rend() | |
18776 | { return _M_t.rend(); } | |
18777 | const_reverse_iterator | |
18778 | rend() const | |
18779 | { return _M_t.rend(); } | |
18780 | bool | |
18781 | empty() const | |
18782 | { return _M_t.empty(); } | |
18783 | size_type | |
18784 | size() const | |
18785 | { return _M_t.size(); } | |
18786 | size_type | |
18787 | max_size() const | |
18788 | { return _M_t.max_size(); } | |
18789 | mapped_type& | |
18790 | operator[](const key_type& __k) | |
18791 | { | |
18792 | iterator __i = lower_bound(__k); | |
18793 | if (__i == end() || key_comp()(__k, (*__i).first)) | |
18794 | __i = insert(__i, value_type(__k, mapped_type())); | |
18795 | return (*__i).second; | |
18796 | } | |
18797 | mapped_type& | |
18798 | at(const key_type& __k) | |
18799 | { | |
18800 | iterator __i = lower_bound(__k); | |
18801 | if (__i == end() || key_comp()(__k, (*__i).first)) | |
18802 | __throw_out_of_range(("map::at")); | |
18803 | return (*__i).second; | |
18804 | } | |
18805 | const mapped_type& | |
18806 | at(const key_type& __k) const | |
18807 | { | |
18808 | const_iterator __i = lower_bound(__k); | |
18809 | if (__i == end() || key_comp()(__k, (*__i).first)) | |
18810 | __throw_out_of_range(("map::at")); | |
18811 | return (*__i).second; | |
18812 | } | |
18813 | std::pair<iterator, bool> | |
18814 | insert(const value_type& __x) | |
18815 | { return _M_t._M_insert_unique(__x); } | |
18816 | iterator | |
18817 | insert(iterator __position, const value_type& __x) | |
18818 | { return _M_t._M_insert_unique_(__position, __x); } | |
18819 | template<typename _InputIterator> | |
18820 | void | |
18821 | insert(_InputIterator __first, _InputIterator __last) | |
18822 | { _M_t._M_insert_unique(__first, __last); } | |
18823 | void | |
18824 | erase(iterator __position) | |
18825 | { _M_t.erase(__position); } | |
18826 | size_type | |
18827 | erase(const key_type& __x) | |
18828 | { return _M_t.erase(__x); } | |
18829 | void | |
18830 | erase(iterator __first, iterator __last) | |
18831 | { _M_t.erase(__first, __last); } | |
18832 | void | |
18833 | swap(map& __x) | |
18834 | { _M_t.swap(__x._M_t); } | |
18835 | void | |
18836 | clear() | |
18837 | { _M_t.clear(); } | |
18838 | key_compare | |
18839 | key_comp() const | |
18840 | { return _M_t.key_comp(); } | |
18841 | value_compare | |
18842 | value_comp() const | |
18843 | { return value_compare(_M_t.key_comp()); } | |
18844 | iterator | |
18845 | find(const key_type& __x) | |
18846 | { return _M_t.find(__x); } | |
18847 | const_iterator | |
18848 | find(const key_type& __x) const | |
18849 | { return _M_t.find(__x); } | |
18850 | size_type | |
18851 | count(const key_type& __x) const | |
18852 | { return _M_t.find(__x) == _M_t.end() ? 0 : 1; } | |
18853 | iterator | |
18854 | lower_bound(const key_type& __x) | |
18855 | { return _M_t.lower_bound(__x); } | |
18856 | const_iterator | |
18857 | lower_bound(const key_type& __x) const | |
18858 | { return _M_t.lower_bound(__x); } | |
18859 | iterator | |
18860 | upper_bound(const key_type& __x) | |
18861 | { return _M_t.upper_bound(__x); } | |
18862 | const_iterator | |
18863 | upper_bound(const key_type& __x) const | |
18864 | { return _M_t.upper_bound(__x); } | |
18865 | std::pair<iterator, iterator> | |
18866 | equal_range(const key_type& __x) | |
18867 | { return _M_t.equal_range(__x); } | |
18868 | std::pair<const_iterator, const_iterator> | |
18869 | equal_range(const key_type& __x) const | |
18870 | { return _M_t.equal_range(__x); } | |
18871 | template<typename _K1, typename _T1, typename _C1, typename _A1> | |
18872 | friend bool | |
18873 | operator==(const map<_K1, _T1, _C1, _A1>&, | |
18874 | const map<_K1, _T1, _C1, _A1>&); | |
18875 | template<typename _K1, typename _T1, typename _C1, typename _A1> | |
18876 | friend bool | |
18877 | operator<(const map<_K1, _T1, _C1, _A1>&, | |
18878 | const map<_K1, _T1, _C1, _A1>&); | |
18879 | }; | |
18880 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18881 | inline bool | |
18882 | operator==(const map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18883 | const map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18884 | { return __x._M_t == __y._M_t; } | |
18885 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18886 | inline bool | |
18887 | operator<(const map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18888 | const map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18889 | { return __x._M_t < __y._M_t; } | |
18890 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18891 | inline bool | |
18892 | operator!=(const map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18893 | const map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18894 | { return !(__x == __y); } | |
18895 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18896 | inline bool | |
18897 | operator>(const map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18898 | const map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18899 | { return __y < __x; } | |
18900 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18901 | inline bool | |
18902 | operator<=(const map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18903 | const map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18904 | { return !(__y < __x); } | |
18905 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18906 | inline bool | |
18907 | operator>=(const map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18908 | const map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18909 | { return !(__x < __y); } | |
18910 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
18911 | inline void | |
18912 | swap(map<_Key, _Tp, _Compare, _Alloc>& __x, | |
18913 | map<_Key, _Tp, _Compare, _Alloc>& __y) | |
18914 | { __x.swap(__y); } | |
18915 | } | |
18916 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
18917 | template <typename _Key, typename _Tp, | |
18918 | typename _Compare = std::less<_Key>, | |
18919 | typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > > | |
18920 | class multimap | |
18921 | { | |
18922 | public: | |
18923 | typedef _Key key_type; | |
18924 | typedef _Tp mapped_type; | |
18925 | typedef std::pair<const _Key, _Tp> value_type; | |
18926 | typedef _Compare key_compare; | |
18927 | typedef _Alloc allocator_type; | |
18928 | private: | |
18929 | typedef typename _Alloc::value_type _Alloc_value_type; | |
18930 | public: | |
18931 | class value_compare | |
18932 | : public std::binary_function<value_type, value_type, bool> | |
18933 | { | |
18934 | friend class multimap<_Key, _Tp, _Compare, _Alloc>; | |
18935 | protected: | |
18936 | _Compare comp; | |
18937 | value_compare(_Compare __c) | |
18938 | : comp(__c) { } | |
18939 | public: | |
18940 | bool operator()(const value_type& __x, const value_type& __y) const | |
18941 | { return comp(__x.first, __y.first); } | |
18942 | }; | |
18943 | private: | |
18944 | typedef typename _Alloc::template rebind<value_type>::other | |
18945 | _Pair_alloc_type; | |
18946 | typedef _Rb_tree<key_type, value_type, _Select1st<value_type>, | |
18947 | key_compare, _Pair_alloc_type> _Rep_type; | |
18948 | _Rep_type _M_t; | |
18949 | public: | |
18950 | typedef typename _Pair_alloc_type::pointer pointer; | |
18951 | typedef typename _Pair_alloc_type::const_pointer const_pointer; | |
18952 | typedef typename _Pair_alloc_type::reference reference; | |
18953 | typedef typename _Pair_alloc_type::const_reference const_reference; | |
18954 | typedef typename _Rep_type::iterator iterator; | |
18955 | typedef typename _Rep_type::const_iterator const_iterator; | |
18956 | typedef typename _Rep_type::size_type size_type; | |
18957 | typedef typename _Rep_type::difference_type difference_type; | |
18958 | typedef typename _Rep_type::reverse_iterator reverse_iterator; | |
18959 | typedef typename _Rep_type::const_reverse_iterator const_reverse_iterator; | |
18960 | multimap() | |
18961 | : _M_t() { } | |
18962 | explicit | |
18963 | multimap(const _Compare& __comp, | |
18964 | const allocator_type& __a = allocator_type()) | |
18965 | : _M_t(__comp, __a) { } | |
18966 | multimap(const multimap& __x) | |
18967 | : _M_t(__x._M_t) { } | |
18968 | template<typename _InputIterator> | |
18969 | multimap(_InputIterator __first, _InputIterator __last) | |
18970 | : _M_t() | |
18971 | { _M_t._M_insert_equal(__first, __last); } | |
18972 | template<typename _InputIterator> | |
18973 | multimap(_InputIterator __first, _InputIterator __last, | |
18974 | const _Compare& __comp, | |
18975 | const allocator_type& __a = allocator_type()) | |
18976 | : _M_t(__comp, __a) | |
18977 | { _M_t._M_insert_equal(__first, __last); } | |
18978 | multimap& | |
18979 | operator=(const multimap& __x) | |
18980 | { | |
18981 | _M_t = __x._M_t; | |
18982 | return *this; | |
18983 | } | |
18984 | allocator_type | |
18985 | get_allocator() const | |
18986 | { return _M_t.get_allocator(); } | |
18987 | iterator | |
18988 | begin() | |
18989 | { return _M_t.begin(); } | |
18990 | const_iterator | |
18991 | begin() const | |
18992 | { return _M_t.begin(); } | |
18993 | iterator | |
18994 | end() | |
18995 | { return _M_t.end(); } | |
18996 | const_iterator | |
18997 | end() const | |
18998 | { return _M_t.end(); } | |
18999 | reverse_iterator | |
19000 | rbegin() | |
19001 | { return _M_t.rbegin(); } | |
19002 | const_reverse_iterator | |
19003 | rbegin() const | |
19004 | { return _M_t.rbegin(); } | |
19005 | reverse_iterator | |
19006 | rend() | |
19007 | { return _M_t.rend(); } | |
19008 | const_reverse_iterator | |
19009 | rend() const | |
19010 | { return _M_t.rend(); } | |
19011 | bool | |
19012 | empty() const | |
19013 | { return _M_t.empty(); } | |
19014 | size_type | |
19015 | size() const | |
19016 | { return _M_t.size(); } | |
19017 | size_type | |
19018 | max_size() const | |
19019 | { return _M_t.max_size(); } | |
19020 | iterator | |
19021 | insert(const value_type& __x) | |
19022 | { return _M_t._M_insert_equal(__x); } | |
19023 | iterator | |
19024 | insert(iterator __position, const value_type& __x) | |
19025 | { return _M_t._M_insert_equal_(__position, __x); } | |
19026 | template<typename _InputIterator> | |
19027 | void | |
19028 | insert(_InputIterator __first, _InputIterator __last) | |
19029 | { _M_t._M_insert_equal(__first, __last); } | |
19030 | void | |
19031 | erase(iterator __position) | |
19032 | { _M_t.erase(__position); } | |
19033 | size_type | |
19034 | erase(const key_type& __x) | |
19035 | { return _M_t.erase(__x); } | |
19036 | void | |
19037 | erase(iterator __first, iterator __last) | |
19038 | { _M_t.erase(__first, __last); } | |
19039 | void | |
19040 | swap(multimap& __x) | |
19041 | { _M_t.swap(__x._M_t); } | |
19042 | void | |
19043 | clear() | |
19044 | { _M_t.clear(); } | |
19045 | key_compare | |
19046 | key_comp() const | |
19047 | { return _M_t.key_comp(); } | |
19048 | value_compare | |
19049 | value_comp() const | |
19050 | { return value_compare(_M_t.key_comp()); } | |
19051 | iterator | |
19052 | find(const key_type& __x) | |
19053 | { return _M_t.find(__x); } | |
19054 | const_iterator | |
19055 | find(const key_type& __x) const | |
19056 | { return _M_t.find(__x); } | |
19057 | size_type | |
19058 | count(const key_type& __x) const | |
19059 | { return _M_t.count(__x); } | |
19060 | iterator | |
19061 | lower_bound(const key_type& __x) | |
19062 | { return _M_t.lower_bound(__x); } | |
19063 | const_iterator | |
19064 | lower_bound(const key_type& __x) const | |
19065 | { return _M_t.lower_bound(__x); } | |
19066 | iterator | |
19067 | upper_bound(const key_type& __x) | |
19068 | { return _M_t.upper_bound(__x); } | |
19069 | const_iterator | |
19070 | upper_bound(const key_type& __x) const | |
19071 | { return _M_t.upper_bound(__x); } | |
19072 | std::pair<iterator, iterator> | |
19073 | equal_range(const key_type& __x) | |
19074 | { return _M_t.equal_range(__x); } | |
19075 | std::pair<const_iterator, const_iterator> | |
19076 | equal_range(const key_type& __x) const | |
19077 | { return _M_t.equal_range(__x); } | |
19078 | template<typename _K1, typename _T1, typename _C1, typename _A1> | |
19079 | friend bool | |
19080 | operator==(const multimap<_K1, _T1, _C1, _A1>&, | |
19081 | const multimap<_K1, _T1, _C1, _A1>&); | |
19082 | template<typename _K1, typename _T1, typename _C1, typename _A1> | |
19083 | friend bool | |
19084 | operator<(const multimap<_K1, _T1, _C1, _A1>&, | |
19085 | const multimap<_K1, _T1, _C1, _A1>&); | |
19086 | }; | |
19087 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19088 | inline bool | |
19089 | operator==(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19090 | const multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19091 | { return __x._M_t == __y._M_t; } | |
19092 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19093 | inline bool | |
19094 | operator<(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19095 | const multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19096 | { return __x._M_t < __y._M_t; } | |
19097 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19098 | inline bool | |
19099 | operator!=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19100 | const multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19101 | { return !(__x == __y); } | |
19102 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19103 | inline bool | |
19104 | operator>(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19105 | const multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19106 | { return __y < __x; } | |
19107 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19108 | inline bool | |
19109 | operator<=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19110 | const multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19111 | { return !(__y < __x); } | |
19112 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19113 | inline bool | |
19114 | operator>=(const multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19115 | const multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19116 | { return !(__x < __y); } | |
19117 | template<typename _Key, typename _Tp, typename _Compare, typename _Alloc> | |
19118 | inline void | |
19119 | swap(multimap<_Key, _Tp, _Compare, _Alloc>& __x, | |
19120 | multimap<_Key, _Tp, _Compare, _Alloc>& __y) | |
19121 | { __x.swap(__y); } | |
19122 | } | |
19123 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
19124 | struct __attribute__((visibility("default"))) QMapData | |
19125 | { | |
19126 | struct Node { | |
19127 | Node *backward; | |
19128 | Node *forward[1]; | |
19129 | }; | |
19130 | enum { LastLevel = 11, Sparseness = 3 }; | |
19131 | QMapData *backward; | |
19132 | QMapData *forward[QMapData::LastLevel + 1]; | |
19133 | QBasicAtomicInt ref; | |
19134 | int topLevel; | |
19135 | int size; | |
19136 | uint randomBits; | |
19137 | uint insertInOrder : 1; | |
19138 | uint sharable : 1; | |
19139 | static QMapData *createData(); | |
19140 | void continueFreeData(int offset); | |
19141 | Node *node_create(Node *update[], int offset); | |
19142 | void node_delete(Node *update[], int offset, Node *node); | |
19143 | static QMapData shared_null; | |
19144 | }; | |
19145 | template <class Key> inline bool qMapLessThanKey(const Key &key1, const Key &key2) | |
19146 | { | |
19147 | return key1 < key2; | |
19148 | } | |
19149 | template <class Ptr> inline bool qMapLessThanKey(Ptr *key1, Ptr *key2) | |
19150 | { | |
19151 | qt_noop(); | |
19152 | return quintptr(key1) < quintptr(key2); | |
19153 | } | |
19154 | template <class Ptr> inline bool qMapLessThanKey(const Ptr *key1, const Ptr *key2) | |
19155 | { | |
19156 | qt_noop(); | |
19157 | return quintptr(key1) < quintptr(key2); | |
19158 | } | |
19159 | template <class Key, class T> | |
19160 | struct QMapNode { | |
19161 | Key key; | |
19162 | T value; | |
19163 | QMapData::Node *backward; | |
19164 | QMapData::Node *forward[1]; | |
19165 | }; | |
19166 | template <class Key, class T> | |
19167 | struct QMapPayloadNode | |
19168 | { | |
19169 | Key key; | |
19170 | T value; | |
19171 | QMapData::Node *backward; | |
19172 | }; | |
19173 | template <class Key, class T> | |
19174 | class QMap | |
19175 | { | |
19176 | typedef QMapNode<Key, T> Node; | |
19177 | typedef QMapPayloadNode<Key, T> PayloadNode; | |
19178 | union { | |
19179 | QMapData *d; | |
19180 | QMapData::Node *e; | |
19181 | }; | |
19182 | static inline int payload() { return sizeof(PayloadNode) - sizeof(QMapData::Node *); } | |
19183 | static inline Node *concrete(QMapData::Node *node) { | |
19184 | return reinterpret_cast<Node *>(reinterpret_cast<char *>(node) - payload()); | |
19185 | } | |
19186 | public: | |
19187 | inline QMap() : d(&QMapData::shared_null) { d->ref.ref(); } | |
19188 | inline QMap(const QMap<Key, T> &other) : d(other.d) | |
19189 | { d->ref.ref(); if (!d->sharable) detach(); } | |
19190 | inline ~QMap() { if (!d) return; if (!d->ref.deref()) freeData(d); } | |
19191 | QMap<Key, T> &operator=(const QMap<Key, T> &other); | |
19192 | explicit QMap(const typename std::map<Key, T> &other); | |
19193 | std::map<Key, T> toStdMap() const; | |
19194 | bool operator==(const QMap<Key, T> &other) const; | |
19195 | inline bool operator!=(const QMap<Key, T> &other) const { return !(*this == other); } | |
19196 | inline int size() const { return d->size; } | |
19197 | inline bool isEmpty() const { return d->size == 0; } | |
19198 | inline void detach() { if (d->ref != 1) detach_helper(); } | |
19199 | inline bool isDetached() const { return d->ref == 1; } | |
19200 | inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } | |
19201 | inline void setInsertInOrder(bool ordered) { d->insertInOrder = ordered; } | |
19202 | void clear(); | |
19203 | int remove(const Key &key); | |
19204 | T take(const Key &key); | |
19205 | bool contains(const Key &key) const; | |
19206 | const Key key(const T &value) const; | |
19207 | const Key key(const T &value, const Key &defaultKey) const; | |
19208 | const T value(const Key &key) const; | |
19209 | const T value(const Key &key, const T &defaultValue) const; | |
19210 | T &operator[](const Key &key); | |
19211 | const T operator[](const Key &key) const; | |
19212 | QList<Key> uniqueKeys() const; | |
19213 | QList<Key> keys() const; | |
19214 | QList<Key> keys(const T &value) const; | |
19215 | QList<T> values() const; | |
19216 | QList<T> values(const Key &key) const; | |
19217 | int count(const Key &key) const; | |
19218 | class const_iterator; | |
19219 | class iterator | |
19220 | { | |
19221 | friend class const_iterator; | |
19222 | QMapData::Node *i; | |
19223 | public: | |
19224 | typedef std::bidirectional_iterator_tag iterator_category; | |
19225 | typedef ptrdiff_t difference_type; | |
19226 | typedef T value_type; | |
19227 | typedef T *pointer; | |
19228 | typedef T &reference; | |
19229 | inline operator QMapData::Node *() const { return i; } | |
19230 | inline iterator() : i(0) { } | |
19231 | inline iterator(QMapData::Node *node) : i(node) { } | |
19232 | inline const Key &key() const { return concrete(i)->key; } | |
19233 | inline T &value() const { return concrete(i)->value; } | |
19234 | inline T &operator*() const { return concrete(i)->value; } | |
19235 | inline T *operator->() const { return &concrete(i)->value; } | |
19236 | inline bool operator==(const iterator &o) const { return i == o.i; } | |
19237 | inline bool operator!=(const iterator &o) const { return i != o.i; } | |
19238 | inline iterator &operator++() { | |
19239 | i = i->forward[0]; | |
19240 | return *this; | |
19241 | } | |
19242 | inline iterator operator++(int) { | |
19243 | iterator r = *this; | |
19244 | i = i->forward[0]; | |
19245 | return r; | |
19246 | } | |
19247 | inline iterator &operator--() { | |
19248 | i = i->backward; | |
19249 | return *this; | |
19250 | } | |
19251 | inline iterator operator--(int) { | |
19252 | iterator r = *this; | |
19253 | i = i->backward; | |
19254 | return r; | |
19255 | } | |
19256 | inline iterator operator+(int j) const | |
19257 | { iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } | |
19258 | inline iterator operator-(int j) const { return operator+(-j); } | |
19259 | inline iterator &operator+=(int j) { return *this = *this + j; } | |
19260 | inline iterator &operator-=(int j) { return *this = *this - j; } | |
19261 | public: | |
19262 | inline bool operator==(const const_iterator &o) const | |
19263 | { return i == o.i; } | |
19264 | inline bool operator!=(const const_iterator &o) const | |
19265 | { return i != o.i; } | |
19266 | private: | |
19267 | inline operator bool() const { return false; } | |
19268 | }; | |
19269 | friend class iterator; | |
19270 | class const_iterator | |
19271 | { | |
19272 | friend class iterator; | |
19273 | QMapData::Node *i; | |
19274 | public: | |
19275 | typedef std::bidirectional_iterator_tag iterator_category; | |
19276 | typedef ptrdiff_t difference_type; | |
19277 | typedef T value_type; | |
19278 | typedef const T *pointer; | |
19279 | typedef const T &reference; | |
19280 | inline operator QMapData::Node *() const { return i; } | |
19281 | inline const_iterator() : i(0) { } | |
19282 | inline const_iterator(QMapData::Node *node) : i(node) { } | |
19283 | inline const_iterator(const iterator &o) | |
19284 | { i = o.i; } | |
19285 | inline const Key &key() const { return concrete(i)->key; } | |
19286 | inline const T &value() const { return concrete(i)->value; } | |
19287 | inline const T &operator*() const { return concrete(i)->value; } | |
19288 | inline const T *operator->() const { return &concrete(i)->value; } | |
19289 | inline bool operator==(const const_iterator &o) const { return i == o.i; } | |
19290 | inline bool operator!=(const const_iterator &o) const { return i != o.i; } | |
19291 | inline const_iterator &operator++() { | |
19292 | i = i->forward[0]; | |
19293 | return *this; | |
19294 | } | |
19295 | inline const_iterator operator++(int) { | |
19296 | const_iterator r = *this; | |
19297 | i = i->forward[0]; | |
19298 | return r; | |
19299 | } | |
19300 | inline const_iterator &operator--() { | |
19301 | i = i->backward; | |
19302 | return *this; | |
19303 | } | |
19304 | inline const_iterator operator--(int) { | |
19305 | const_iterator r = *this; | |
19306 | i = i->backward; | |
19307 | return r; | |
19308 | } | |
19309 | inline const_iterator operator+(int j) const | |
19310 | { const_iterator r = *this; if (j > 0) while (j--) ++r; else while (j++) --r; return r; } | |
19311 | inline const_iterator operator-(int j) const { return operator+(-j); } | |
19312 | inline const_iterator &operator+=(int j) { return *this = *this + j; } | |
19313 | inline const_iterator &operator-=(int j) { return *this = *this - j; } | |
19314 | private: | |
19315 | inline operator bool() const { return false; } | |
19316 | }; | |
19317 | friend class const_iterator; | |
19318 | inline iterator begin() { detach(); return iterator(e->forward[0]); } | |
19319 | inline const_iterator begin() const { return const_iterator(e->forward[0]); } | |
19320 | inline const_iterator constBegin() const { return const_iterator(e->forward[0]); } | |
19321 | inline iterator end() { | |
19322 | detach(); | |
19323 | return iterator(e); | |
19324 | } | |
19325 | inline const_iterator end() const { return const_iterator(e); } | |
19326 | inline const_iterator constEnd() const { return const_iterator(e); } | |
19327 | iterator erase(iterator it); | |
19328 | typedef iterator Iterator; | |
19329 | typedef const_iterator ConstIterator; | |
19330 | inline int count() const { return d->size; } | |
19331 | iterator find(const Key &key); | |
19332 | const_iterator find(const Key &key) const; | |
19333 | const_iterator constFind(const Key &key) const; | |
19334 | iterator lowerBound(const Key &key); | |
19335 | const_iterator lowerBound(const Key &key) const; | |
19336 | iterator upperBound(const Key &key); | |
19337 | const_iterator upperBound(const Key &key) const; | |
19338 | iterator insert(const Key &key, const T &value); | |
19339 | iterator insertMulti(const Key &key, const T &value); | |
19340 | QMap<Key, T> &unite(const QMap<Key, T> &other); | |
19341 | typedef Key key_type; | |
19342 | typedef T mapped_type; | |
19343 | typedef ptrdiff_t difference_type; | |
19344 | typedef int size_type; | |
19345 | inline bool empty() const { return isEmpty(); } | |
19346 | private: | |
19347 | void detach_helper(); | |
19348 | void freeData(QMapData *d); | |
19349 | QMapData::Node *findNode(const Key &key) const; | |
19350 | QMapData::Node *mutableFindNode(QMapData::Node *update[], const Key &key) const; | |
19351 | QMapData::Node *node_create(QMapData *d, QMapData::Node *update[], const Key &key, | |
19352 | const T &value); | |
19353 | }; | |
19354 | template <class Key, class T> | |
19355 | inline QMap<Key, T> &QMap<Key, T>::operator=(const QMap<Key, T> &other) | |
19356 | { | |
19357 | if (d != other.d) { | |
19358 | other.d->ref.ref(); | |
19359 | if (!d->ref.deref()) | |
19360 | freeData(d); | |
19361 | d = other.d; | |
19362 | if (!d->sharable) | |
19363 | detach_helper(); | |
19364 | } | |
19365 | return *this; | |
19366 | } | |
19367 | template <class Key, class T> | |
19368 | inline void QMap<Key, T>::clear() | |
19369 | { | |
19370 | *this = QMap<Key, T>(); | |
19371 | } | |
19372 | template <class Key, class T> | |
19373 | inline typename QMapData::Node * | |
19374 | QMap<Key, T>::node_create(QMapData *adt, QMapData::Node *aupdate[], const Key &akey, const T &avalue) | |
19375 | { | |
19376 | QMapData::Node *abstractNode = adt->node_create(aupdate, payload()); | |
19377 | Node *concreteNode = concrete(abstractNode); | |
19378 | new (&concreteNode->key) Key(akey); | |
19379 | new (&concreteNode->value) T(avalue); | |
19380 | return abstractNode; | |
19381 | } | |
19382 | template <class Key, class T> | |
19383 | inline QMapData::Node *QMap<Key, T>::findNode(const Key &akey) const | |
19384 | { | |
19385 | QMapData::Node *cur = e; | |
19386 | QMapData::Node *next = e; | |
19387 | for (int i = d->topLevel; i >= 0; i--) { | |
19388 | while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey)) | |
19389 | cur = next; | |
19390 | } | |
19391 | if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) { | |
19392 | return next; | |
19393 | } else { | |
19394 | return e; | |
19395 | } | |
19396 | } | |
19397 | template <class Key, class T> | |
19398 | inline const T QMap<Key, T>::value(const Key &akey) const | |
19399 | { | |
19400 | QMapData::Node *node; | |
19401 | if (d->size == 0 || (node = findNode(akey)) == e) { | |
19402 | return T(); | |
19403 | } else { | |
19404 | return concrete(node)->value; | |
19405 | } | |
19406 | } | |
19407 | template <class Key, class T> | |
19408 | inline const T QMap<Key, T>::value(const Key &akey, const T &adefaultValue) const | |
19409 | { | |
19410 | QMapData::Node *node; | |
19411 | if (d->size == 0 || (node = findNode(akey)) == e) { | |
19412 | return adefaultValue; | |
19413 | } else { | |
19414 | return concrete(node)->value; | |
19415 | } | |
19416 | } | |
19417 | template <class Key, class T> | |
19418 | inline const T QMap<Key, T>::operator[](const Key &akey) const | |
19419 | { | |
19420 | return value(akey); | |
19421 | } | |
19422 | template <class Key, class T> | |
19423 | inline T &QMap<Key, T>::operator[](const Key &akey) | |
19424 | { | |
19425 | detach(); | |
19426 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19427 | QMapData::Node *node = mutableFindNode(update, akey); | |
19428 | if (node == e) | |
19429 | node = node_create(d, update, akey, T()); | |
19430 | return concrete(node)->value; | |
19431 | } | |
19432 | template <class Key, class T> | |
19433 | inline int QMap<Key, T>::count(const Key &akey) const | |
19434 | { | |
19435 | int cnt = 0; | |
19436 | QMapData::Node *node = findNode(akey); | |
19437 | if (node != e) { | |
19438 | do { | |
19439 | ++cnt; | |
19440 | node = node->forward[0]; | |
19441 | } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key)); | |
19442 | } | |
19443 | return cnt; | |
19444 | } | |
19445 | template <class Key, class T> | |
19446 | inline bool QMap<Key, T>::contains(const Key &akey) const | |
19447 | { | |
19448 | return findNode(akey) != e; | |
19449 | } | |
19450 | template <class Key, class T> | |
19451 | inline typename QMap<Key, T>::iterator QMap<Key, T>::insert(const Key &akey, | |
19452 | const T &avalue) | |
19453 | { | |
19454 | detach(); | |
19455 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19456 | QMapData::Node *node = mutableFindNode(update, akey); | |
19457 | if (node == e) { | |
19458 | node = node_create(d, update, akey, avalue); | |
19459 | } else { | |
19460 | concrete(node)->value = avalue; | |
19461 | } | |
19462 | return iterator(node); | |
19463 | } | |
19464 | template <class Key, class T> | |
19465 | inline typename QMap<Key, T>::iterator QMap<Key, T>::insertMulti(const Key &akey, | |
19466 | const T &avalue) | |
19467 | { | |
19468 | detach(); | |
19469 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19470 | mutableFindNode(update, akey); | |
19471 | return iterator(node_create(d, update, akey, avalue)); | |
19472 | } | |
19473 | template <class Key, class T> | |
19474 | inline typename QMap<Key, T>::const_iterator QMap<Key, T>::find(const Key &akey) const | |
19475 | { | |
19476 | return const_iterator(findNode(akey)); | |
19477 | } | |
19478 | template <class Key, class T> | |
19479 | inline typename QMap<Key, T>::const_iterator QMap<Key, T>::constFind(const Key &akey) const | |
19480 | { | |
19481 | return const_iterator(findNode(akey)); | |
19482 | } | |
19483 | template <class Key, class T> | |
19484 | inline typename QMap<Key, T>::iterator QMap<Key, T>::find(const Key &akey) | |
19485 | { | |
19486 | detach(); | |
19487 | return iterator(findNode(akey)); | |
19488 | } | |
19489 | template <class Key, class T> | |
19490 | inline QMap<Key, T> &QMap<Key, T>::unite(const QMap<Key, T> &other) | |
19491 | { | |
19492 | QMap<Key, T> copy(other); | |
19493 | const_iterator it = copy.constEnd(); | |
19494 | const const_iterator b = copy.constBegin(); | |
19495 | while (it != b) { | |
19496 | --it; | |
19497 | insertMulti(it.key(), it.value()); | |
19498 | } | |
19499 | return *this; | |
19500 | } | |
19501 | template <class Key, class T> | |
19502 | void QMap<Key, T>::freeData(QMapData *x) | |
19503 | { | |
19504 | if (QTypeInfo<Key>::isComplex || QTypeInfo<T>::isComplex) { | |
19505 | QMapData::Node *y = reinterpret_cast<QMapData::Node *>(x); | |
19506 | QMapData::Node *cur = y; | |
19507 | QMapData::Node *next = cur->forward[0]; | |
19508 | while (next != y) { | |
19509 | cur = next; | |
19510 | next = cur->forward[0]; | |
19511 | Node *concreteNode = concrete(cur); | |
19512 | concreteNode->key.~Key(); | |
19513 | concreteNode->value.~T(); | |
19514 | } | |
19515 | } | |
19516 | x->continueFreeData(payload()); | |
19517 | } | |
19518 | template <class Key, class T> | |
19519 | int QMap<Key, T>::remove(const Key &akey) | |
19520 | { | |
19521 | detach(); | |
19522 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19523 | QMapData::Node *cur = e; | |
19524 | QMapData::Node *next = e; | |
19525 | int oldSize = d->size; | |
19526 | for (int i = d->topLevel; i >= 0; i--) { | |
19527 | while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey)) | |
19528 | cur = next; | |
19529 | update[i] = cur; | |
19530 | } | |
19531 | if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) { | |
19532 | bool deleteNext = true; | |
19533 | do { | |
19534 | cur = next; | |
19535 | next = cur->forward[0]; | |
19536 | deleteNext = (next != e && !qMapLessThanKey<Key>(concrete(cur)->key, concrete(next)->key)); | |
19537 | concrete(cur)->key.~Key(); | |
19538 | concrete(cur)->value.~T(); | |
19539 | d->node_delete(update, payload(), cur); | |
19540 | } while (deleteNext); | |
19541 | } | |
19542 | return oldSize - d->size; | |
19543 | } | |
19544 | template <class Key, class T> | |
19545 | T QMap<Key, T>::take(const Key &akey) | |
19546 | { | |
19547 | detach(); | |
19548 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19549 | QMapData::Node *cur = e; | |
19550 | QMapData::Node *next = e; | |
19551 | for (int i = d->topLevel; i >= 0; i--) { | |
19552 | while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey)) | |
19553 | cur = next; | |
19554 | update[i] = cur; | |
19555 | } | |
19556 | if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) { | |
19557 | T t = concrete(next)->value; | |
19558 | concrete(next)->key.~Key(); | |
19559 | concrete(next)->value.~T(); | |
19560 | d->node_delete(update, payload(), next); | |
19561 | return t; | |
19562 | } | |
19563 | return T(); | |
19564 | } | |
19565 | template <class Key, class T> | |
19566 | typename QMap<Key, T>::iterator QMap<Key, T>::erase(iterator it) | |
19567 | { | |
19568 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19569 | QMapData::Node *cur = e; | |
19570 | QMapData::Node *next = e; | |
19571 | if (it == iterator(e)) | |
19572 | return it; | |
19573 | for (int i = d->topLevel; i >= 0; i--) { | |
19574 | while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, it.key())) | |
19575 | cur = next; | |
19576 | update[i] = cur; | |
19577 | } | |
19578 | while (next != e) { | |
19579 | cur = next; | |
19580 | next = cur->forward[0]; | |
19581 | if (cur == it) { | |
19582 | concrete(cur)->key.~Key(); | |
19583 | concrete(cur)->value.~T(); | |
19584 | d->node_delete(update, payload(), cur); | |
19585 | return iterator(next); | |
19586 | } | |
19587 | for (int i = 0; i <= d->topLevel; ++i) { | |
19588 | if (update[i]->forward[i] != cur) | |
19589 | break; | |
19590 | update[i] = cur; | |
19591 | } | |
19592 | } | |
19593 | return end(); | |
19594 | } | |
19595 | template <class Key, class T> | |
19596 | void QMap<Key, T>::detach_helper() | |
19597 | { | |
19598 | union { QMapData *d; QMapData::Node *e; } x; | |
19599 | x.d = QMapData::createData(); | |
19600 | if (d->size) { | |
19601 | x.d->insertInOrder = true; | |
19602 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19603 | QMapData::Node *cur = e->forward[0]; | |
19604 | update[0] = x.e; | |
19605 | while (cur != e) { | |
19606 | Node *concreteNode = concrete(cur); | |
19607 | node_create(x.d, update, concreteNode->key, concreteNode->value); | |
19608 | cur = cur->forward[0]; | |
19609 | } | |
19610 | x.d->insertInOrder = false; | |
19611 | } | |
19612 | if (!d->ref.deref()) | |
19613 | freeData(d); | |
19614 | d = x.d; | |
19615 | } | |
19616 | template <class Key, class T> | |
19617 | QMapData::Node *QMap<Key, T>::mutableFindNode(QMapData::Node *aupdate[], | |
19618 | const Key &akey) const | |
19619 | { | |
19620 | QMapData::Node *cur = e; | |
19621 | QMapData::Node *next = e; | |
19622 | for (int i = d->topLevel; i >= 0; i--) { | |
19623 | while ((next = cur->forward[i]) != e && qMapLessThanKey<Key>(concrete(next)->key, akey)) | |
19624 | cur = next; | |
19625 | aupdate[i] = cur; | |
19626 | } | |
19627 | if (next != e && !qMapLessThanKey<Key>(akey, concrete(next)->key)) { | |
19628 | return next; | |
19629 | } else { | |
19630 | return e; | |
19631 | } | |
19632 | } | |
19633 | template <class Key, class T> | |
19634 | QList<Key> QMap<Key, T>::uniqueKeys() const | |
19635 | { | |
19636 | QList<Key> res; | |
19637 | const_iterator i = begin(); | |
19638 | if (i != end()) { | |
19639 | for (;;) { | |
19640 | const Key &aKey = i.key(); | |
19641 | res.append(aKey); | |
19642 | do { | |
19643 | if (++i == end()) | |
19644 | goto break_out_of_outer_loop; | |
19645 | } while (!(aKey < i.key())); | |
19646 | } | |
19647 | } | |
19648 | break_out_of_outer_loop: | |
19649 | return res; | |
19650 | } | |
19651 | template <class Key, class T> | |
19652 | QList<Key> QMap<Key, T>::keys() const | |
19653 | { | |
19654 | QList<Key> res; | |
19655 | const_iterator i = begin(); | |
19656 | while (i != end()) { | |
19657 | res.append(i.key()); | |
19658 | ++i; | |
19659 | } | |
19660 | return res; | |
19661 | } | |
19662 | template <class Key, class T> | |
19663 | QList<Key> QMap<Key, T>::keys(const T &avalue) const | |
19664 | { | |
19665 | QList<Key> res; | |
19666 | const_iterator i = begin(); | |
19667 | while (i != end()) { | |
19668 | if (i.value() == avalue) | |
19669 | res.append(i.key()); | |
19670 | ++i; | |
19671 | } | |
19672 | return res; | |
19673 | } | |
19674 | template <class Key, class T> | |
19675 | const Key QMap<Key, T>::key(const T &avalue) const | |
19676 | { | |
19677 | return key(avalue, Key()); | |
19678 | } | |
19679 | template <class Key, class T> | |
19680 | const Key QMap<Key, T>::key(const T &avalue, const Key &defaultKey) const | |
19681 | { | |
19682 | const_iterator i = begin(); | |
19683 | while (i != end()) { | |
19684 | if (i.value() == avalue) | |
19685 | return i.key(); | |
19686 | ++i; | |
19687 | } | |
19688 | return defaultKey; | |
19689 | } | |
19690 | template <class Key, class T> | |
19691 | QList<T> QMap<Key, T>::values() const | |
19692 | { | |
19693 | QList<T> res; | |
19694 | const_iterator i = begin(); | |
19695 | while (i != end()) { | |
19696 | res.append(i.value()); | |
19697 | ++i; | |
19698 | } | |
19699 | return res; | |
19700 | } | |
19701 | template <class Key, class T> | |
19702 | QList<T> QMap<Key, T>::values(const Key &akey) const | |
19703 | { | |
19704 | QList<T> res; | |
19705 | QMapData::Node *node = findNode(akey); | |
19706 | if (node != e) { | |
19707 | do { | |
19708 | res.append(concrete(node)->value); | |
19709 | node = node->forward[0]; | |
19710 | } while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key)); | |
19711 | } | |
19712 | return res; | |
19713 | } | |
19714 | template <class Key, class T> | |
19715 | inline typename QMap<Key, T>::const_iterator | |
19716 | QMap<Key, T>::lowerBound(const Key &akey) const | |
19717 | { | |
19718 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19719 | mutableFindNode(update, akey); | |
19720 | return const_iterator(update[0]->forward[0]); | |
19721 | } | |
19722 | template <class Key, class T> | |
19723 | inline typename QMap<Key, T>::iterator QMap<Key, T>::lowerBound(const Key &akey) | |
19724 | { | |
19725 | detach(); | |
19726 | return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->lowerBound(akey)); | |
19727 | } | |
19728 | template <class Key, class T> | |
19729 | inline typename QMap<Key, T>::const_iterator | |
19730 | QMap<Key, T>::upperBound(const Key &akey) const | |
19731 | { | |
19732 | QMapData::Node *update[QMapData::LastLevel + 1]; | |
19733 | mutableFindNode(update, akey); | |
19734 | QMapData::Node *node = update[0]->forward[0]; | |
19735 | while (node != e && !qMapLessThanKey<Key>(akey, concrete(node)->key)) | |
19736 | node = node->forward[0]; | |
19737 | return const_iterator(node); | |
19738 | } | |
19739 | template <class Key, class T> | |
19740 | inline typename QMap<Key, T>::iterator QMap<Key, T>::upperBound(const Key &akey) | |
19741 | { | |
19742 | detach(); | |
19743 | return static_cast<QMapData::Node *>(const_cast<const QMap *>(this)->upperBound(akey)); | |
19744 | } | |
19745 | template <class Key, class T> | |
19746 | bool QMap<Key, T>::operator==(const QMap<Key, T> &other) const | |
19747 | { | |
19748 | if (size() != other.size()) | |
19749 | return false; | |
19750 | if (d == other.d) | |
19751 | return true; | |
19752 | const_iterator it1 = begin(); | |
19753 | const_iterator it2 = other.begin(); | |
19754 | while (it1 != end()) { | |
19755 | if (!(it1.value() == it2.value()) || qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key())) | |
19756 | return false; | |
19757 | ++it2; | |
19758 | ++it1; | |
19759 | } | |
19760 | return true; | |
19761 | } | |
19762 | template <class Key, class T> | |
19763 | QMap<Key, T>::QMap(const std::map<Key, T> &other) | |
19764 | { | |
19765 | d = QMapData::createData(); | |
19766 | d->insertInOrder = true; | |
19767 | typename std::map<Key,T>::const_iterator it = other.end(); | |
19768 | while (it != other.begin()) { | |
19769 | --it; | |
19770 | insert((*it).first, (*it).second); | |
19771 | } | |
19772 | d->insertInOrder = false; | |
19773 | } | |
19774 | template <class Key, class T> | |
19775 | std::map<Key, T> QMap<Key, T>::toStdMap() const | |
19776 | { | |
19777 | std::map<Key, T> map; | |
19778 | const_iterator it = end(); | |
19779 | while (it != begin()) { | |
19780 | --it; | |
19781 | map.insert(std::pair<Key, T>(it.key(), it.value())); | |
19782 | } | |
19783 | return map; | |
19784 | } | |
19785 | template <class Key, class T> | |
19786 | class QMultiMap : public QMap<Key, T> | |
19787 | { | |
19788 | public: | |
19789 | QMultiMap() {} | |
19790 | QMultiMap(const QMap<Key, T> &other) : QMap<Key, T>(other) {} | |
19791 | inline typename QMap<Key, T>::iterator replace(const Key &key, const T &value) | |
19792 | { return QMap<Key, T>::insert(key, value); } | |
19793 | inline typename QMap<Key, T>::iterator insert(const Key &key, const T &value) | |
19794 | { return QMap<Key, T>::insertMulti(key, value); } | |
19795 | inline QMultiMap &operator+=(const QMultiMap &other) | |
19796 | { unite(other); return *this; } | |
19797 | inline QMultiMap operator+(const QMultiMap &other) const | |
19798 | { QMultiMap result = *this; result += other; return result; } | |
19799 | using QMap<Key, T>::contains; | |
19800 | using QMap<Key, T>::remove; | |
19801 | using QMap<Key, T>::count; | |
19802 | using QMap<Key, T>::find; | |
19803 | using QMap<Key, T>::constFind; | |
19804 | bool contains(const Key &key, const T &value) const; | |
19805 | int remove(const Key &key, const T &value); | |
19806 | int count(const Key &key, const T &value) const; | |
19807 | typename QMap<Key, T>::iterator find(const Key &key, const T &value) { | |
19808 | typename QMap<Key, T>::iterator i(find(key)); | |
19809 | typename QMap<Key, T>::iterator end(this->end()); | |
19810 | while (i != end && !qMapLessThanKey<Key>(key, i.key())) { | |
19811 | if (i.value() == value) | |
19812 | return i; | |
19813 | ++i; | |
19814 | } | |
19815 | return end; | |
19816 | } | |
19817 | typename QMap<Key, T>::const_iterator find(const Key &key, const T &value) const { | |
19818 | typename QMap<Key, T>::const_iterator i(constFind(key)); | |
19819 | typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd()); | |
19820 | while (i != end && !qMapLessThanKey<Key>(key, i.key())) { | |
19821 | if (i.value() == value) | |
19822 | return i; | |
19823 | ++i; | |
19824 | } | |
19825 | return end; | |
19826 | } | |
19827 | typename QMap<Key, T>::const_iterator constFind(const Key &key, const T &value) const | |
19828 | { return find(key, value); } | |
19829 | private: | |
19830 | T &operator[](const Key &key); | |
19831 | const T operator[](const Key &key) const; | |
19832 | }; | |
19833 | template <class Key, class T> | |
19834 | inline bool QMultiMap<Key, T>::contains(const Key &key, const T &value) const | |
19835 | { | |
19836 | return constFind(key, value) != QMap<Key, T>::constEnd(); | |
19837 | } | |
19838 | template <class Key, class T> | |
19839 | inline int QMultiMap<Key, T>::remove(const Key &key, const T &value) | |
19840 | { | |
19841 | int n = 0; | |
19842 | typename QMap<Key, T>::iterator i(find(key)); | |
19843 | typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd()); | |
19844 | while (i != end && !qMapLessThanKey<Key>(key, i.key())) { | |
19845 | if (i.value() == value) { | |
19846 | i = erase(i); | |
19847 | ++n; | |
19848 | } else { | |
19849 | ++i; | |
19850 | } | |
19851 | } | |
19852 | return n; | |
19853 | } | |
19854 | template <class Key, class T> | |
19855 | inline int QMultiMap<Key, T>::count(const Key &key, const T &value) const | |
19856 | { | |
19857 | int n = 0; | |
19858 | typename QMap<Key, T>::const_iterator i(constFind(key)); | |
19859 | typename QMap<Key, T>::const_iterator end(QMap<Key, T>::constEnd()); | |
19860 | while (i != end && !qMapLessThanKey<Key>(key, i.key())) { | |
19861 | if (i.value() == value) | |
19862 | ++n; | |
19863 | ++i; | |
19864 | } | |
19865 | return n; | |
19866 | } | |
19867 | template <class Key, class T> class QMapIterator { typedef typename QMap<Key,T>::const_iterator const_iterator; typedef const_iterator Item; QMap<Key,T> c; const_iterator i, n; inline bool item_exists() const { return n != c.constEnd(); } public: inline QMapIterator(const QMap<Key,T> &container) : c(container), i(c.constBegin()), n(c.constEnd()) {} inline QMapIterator &operator=(const QMap<Key,T> &container) { c = container; i = c.constBegin(); n = c.constEnd(); return *this; } inline void toFront() { i = c.constBegin(); n = c.constEnd(); } inline void toBack() { i = c.constEnd(); n = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { const_iterator p = i; return --p; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while ((n = i) != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(n = --i) == t) return true; n = c.constEnd(); return false; } }; | |
19868 | template <class Key, class T> class QMutableMapIterator { typedef typename QMap<Key,T>::iterator iterator; typedef typename QMap<Key,T>::const_iterator const_iterator; typedef iterator Item; QMap<Key,T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableMapIterator(QMap<Key,T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableMapIterator() { c->setSharable(true); } inline QMutableMapIterator &operator=(QMap<Key,T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = c->end(); } inline bool hasNext() const { return const_iterator(i) != c->constEnd(); } inline Item next() { n = i++; return n; } inline Item peekNext() const { return i; } inline bool hasPrevious() const { return const_iterator(i) != c->constBegin(); } inline Item previous() { n = --i; return n; } inline Item peekPrevious() const { iterator p = i; return --p; } inline void remove() { if (const_iterator(n) != c->constEnd()) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) { if (const_iterator(n) != c->constEnd()) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline const Key &key() const { qt_noop(); return n.key(); } inline bool findNext(const T &t) { while (const_iterator(n = i) != c->constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (const_iterator(i) != c->constBegin()) if (*(n = --i) == t) return true; n = c->end(); return false; } }; | |
19869 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
19870 | class QDataStream; | |
19871 | class QDate; | |
19872 | class QDateTime; | |
19873 | class QTime; | |
19874 | class QVariant; | |
19875 | class QTextStream; | |
19876 | class QTextStreamPrivate; | |
19877 | class QLocale; | |
19878 | class __attribute__((visibility("default"))) QSystemLocale | |
19879 | { | |
19880 | public: | |
19881 | QSystemLocale(); | |
19882 | virtual ~QSystemLocale(); | |
19883 | enum QueryType { | |
19884 | LanguageId, | |
19885 | CountryId, | |
19886 | DecimalPoint, | |
19887 | GroupSeparator, | |
19888 | ZeroDigit, | |
19889 | NegativeSign, | |
19890 | DateFormatLong, | |
19891 | DateFormatShort, | |
19892 | TimeFormatLong, | |
19893 | TimeFormatShort, | |
19894 | DayNameLong, | |
19895 | DayNameShort, | |
19896 | MonthNameLong, | |
19897 | MonthNameShort, | |
19898 | DateToStringLong, | |
19899 | DateToStringShort, | |
19900 | TimeToStringLong, | |
19901 | TimeToStringShort, | |
19902 | DateTimeFormatLong, | |
19903 | DateTimeFormatShort, | |
19904 | DateTimeToStringLong, | |
19905 | DateTimeToStringShort, | |
19906 | MeasurementSystem, | |
19907 | PositiveSign, | |
19908 | AMText, | |
19909 | PMText | |
19910 | }; | |
19911 | virtual QVariant query(QueryType type, QVariant in) const; | |
19912 | virtual QLocale fallbackLocale() const; | |
19913 | }; | |
19914 | struct QLocalePrivate; | |
19915 | class __attribute__((visibility("default"))) QLocale | |
19916 | { | |
19917 | public: static const QMetaObject staticMetaObject; private: | |
19918 | friend class QString; | |
19919 | friend class QByteArray; | |
19920 | friend class QIntValidator; | |
19921 | friend class QDoubleValidator; | |
19922 | friend class QTextStream; | |
19923 | friend class QTextStreamPrivate; | |
19924 | public: | |
19925 | enum Language { | |
19926 | C = 1, | |
19927 | Abkhazian = 2, | |
19928 | Afan = 3, | |
19929 | Afar = 4, | |
19930 | Afrikaans = 5, | |
19931 | Albanian = 6, | |
19932 | Amharic = 7, | |
19933 | Arabic = 8, | |
19934 | Armenian = 9, | |
19935 | Assamese = 10, | |
19936 | Aymara = 11, | |
19937 | Azerbaijani = 12, | |
19938 | Bashkir = 13, | |
19939 | Basque = 14, | |
19940 | Bengali = 15, | |
19941 | Bhutani = 16, | |
19942 | Bihari = 17, | |
19943 | Bislama = 18, | |
19944 | Breton = 19, | |
19945 | Bulgarian = 20, | |
19946 | Burmese = 21, | |
19947 | Byelorussian = 22, | |
19948 | Cambodian = 23, | |
19949 | Catalan = 24, | |
19950 | Chinese = 25, | |
19951 | Corsican = 26, | |
19952 | Croatian = 27, | |
19953 | Czech = 28, | |
19954 | Danish = 29, | |
19955 | Dutch = 30, | |
19956 | English = 31, | |
19957 | Esperanto = 32, | |
19958 | Estonian = 33, | |
19959 | Faroese = 34, | |
19960 | FijiLanguage = 35, | |
19961 | Finnish = 36, | |
19962 | French = 37, | |
19963 | Frisian = 38, | |
19964 | Gaelic = 39, | |
19965 | Galician = 40, | |
19966 | Georgian = 41, | |
19967 | German = 42, | |
19968 | Greek = 43, | |
19969 | Greenlandic = 44, | |
19970 | Guarani = 45, | |
19971 | Gujarati = 46, | |
19972 | Hausa = 47, | |
19973 | Hebrew = 48, | |
19974 | Hindi = 49, | |
19975 | Hungarian = 50, | |
19976 | Icelandic = 51, | |
19977 | Indonesian = 52, | |
19978 | Interlingua = 53, | |
19979 | Interlingue = 54, | |
19980 | Inuktitut = 55, | |
19981 | Inupiak = 56, | |
19982 | Irish = 57, | |
19983 | Italian = 58, | |
19984 | Japanese = 59, | |
19985 | Javanese = 60, | |
19986 | Kannada = 61, | |
19987 | Kashmiri = 62, | |
19988 | Kazakh = 63, | |
19989 | Kinyarwanda = 64, | |
19990 | Kirghiz = 65, | |
19991 | Korean = 66, | |
19992 | Kurdish = 67, | |
19993 | Kurundi = 68, | |
19994 | Laothian = 69, | |
19995 | Latin = 70, | |
19996 | Latvian = 71, | |
19997 | Lingala = 72, | |
19998 | Lithuanian = 73, | |
19999 | Macedonian = 74, | |
20000 | Malagasy = 75, | |
20001 | Malay = 76, | |
20002 | Malayalam = 77, | |
20003 | Maltese = 78, | |
20004 | Maori = 79, | |
20005 | Marathi = 80, | |
20006 | Moldavian = 81, | |
20007 | Mongolian = 82, | |
20008 | NauruLanguage = 83, | |
20009 | Nepali = 84, | |
20010 | Norwegian = 85, | |
20011 | NorwegianBokmal = Norwegian, | |
20012 | Occitan = 86, | |
20013 | Oriya = 87, | |
20014 | Pashto = 88, | |
20015 | Persian = 89, | |
20016 | Polish = 90, | |
20017 | Portuguese = 91, | |
20018 | Punjabi = 92, | |
20019 | Quechua = 93, | |
20020 | RhaetoRomance = 94, | |
20021 | Romanian = 95, | |
20022 | Russian = 96, | |
20023 | Samoan = 97, | |
20024 | Sangho = 98, | |
20025 | Sanskrit = 99, | |
20026 | Serbian = 100, | |
20027 | SerboCroatian = 101, | |
20028 | Sesotho = 102, | |
20029 | Setswana = 103, | |
20030 | Shona = 104, | |
20031 | Sindhi = 105, | |
20032 | Singhalese = 106, | |
20033 | Siswati = 107, | |
20034 | Slovak = 108, | |
20035 | Slovenian = 109, | |
20036 | Somali = 110, | |
20037 | Spanish = 111, | |
20038 | Sundanese = 112, | |
20039 | Swahili = 113, | |
20040 | Swedish = 114, | |
20041 | Tagalog = 115, | |
20042 | Tajik = 116, | |
20043 | Tamil = 117, | |
20044 | Tatar = 118, | |
20045 | Telugu = 119, | |
20046 | Thai = 120, | |
20047 | Tibetan = 121, | |
20048 | Tigrinya = 122, | |
20049 | TongaLanguage = 123, | |
20050 | Tsonga = 124, | |
20051 | Turkish = 125, | |
20052 | Turkmen = 126, | |
20053 | Twi = 127, | |
20054 | Uigur = 128, | |
20055 | Ukrainian = 129, | |
20056 | Urdu = 130, | |
20057 | Uzbek = 131, | |
20058 | Vietnamese = 132, | |
20059 | Volapuk = 133, | |
20060 | Welsh = 134, | |
20061 | Wolof = 135, | |
20062 | Xhosa = 136, | |
20063 | Yiddish = 137, | |
20064 | Yoruba = 138, | |
20065 | Zhuang = 139, | |
20066 | Zulu = 140, | |
20067 | NorwegianNynorsk = 141, | |
20068 | Nynorsk = NorwegianNynorsk, | |
20069 | Bosnian = 142, | |
20070 | Divehi = 143, | |
20071 | Manx = 144, | |
20072 | Cornish = 145, | |
20073 | Akan = 146, | |
20074 | Konkani = 147, | |
20075 | Ga = 148, | |
20076 | Igbo = 149, | |
20077 | Kamba = 150, | |
20078 | Syriac = 151, | |
20079 | Blin = 152, | |
20080 | Geez = 153, | |
20081 | Koro = 154, | |
20082 | Sidamo = 155, | |
20083 | Atsam = 156, | |
20084 | Tigre = 157, | |
20085 | Jju = 158, | |
20086 | Friulian = 159, | |
20087 | Venda = 160, | |
20088 | Ewe = 161, | |
20089 | Walamo = 162, | |
20090 | Hawaiian = 163, | |
20091 | Tyap = 164, | |
20092 | Chewa = 165, | |
20093 | LastLanguage = Chewa | |
20094 | }; | |
20095 | enum Country { | |
20096 | AnyCountry = 0, | |
20097 | Afghanistan = 1, | |
20098 | Albania = 2, | |
20099 | Algeria = 3, | |
20100 | AmericanSamoa = 4, | |
20101 | Andorra = 5, | |
20102 | Angola = 6, | |
20103 | Anguilla = 7, | |
20104 | Antarctica = 8, | |
20105 | AntiguaAndBarbuda = 9, | |
20106 | Argentina = 10, | |
20107 | Armenia = 11, | |
20108 | Aruba = 12, | |
20109 | Australia = 13, | |
20110 | Austria = 14, | |
20111 | Azerbaijan = 15, | |
20112 | Bahamas = 16, | |
20113 | Bahrain = 17, | |
20114 | Bangladesh = 18, | |
20115 | Barbados = 19, | |
20116 | Belarus = 20, | |
20117 | Belgium = 21, | |
20118 | Belize = 22, | |
20119 | Benin = 23, | |
20120 | Bermuda = 24, | |
20121 | Bhutan = 25, | |
20122 | Bolivia = 26, | |
20123 | BosniaAndHerzegowina = 27, | |
20124 | Botswana = 28, | |
20125 | BouvetIsland = 29, | |
20126 | Brazil = 30, | |
20127 | BritishIndianOceanTerritory = 31, | |
20128 | BruneiDarussalam = 32, | |
20129 | Bulgaria = 33, | |
20130 | BurkinaFaso = 34, | |
20131 | Burundi = 35, | |
20132 | Cambodia = 36, | |
20133 | Cameroon = 37, | |
20134 | Canada = 38, | |
20135 | CapeVerde = 39, | |
20136 | CaymanIslands = 40, | |
20137 | CentralAfricanRepublic = 41, | |
20138 | Chad = 42, | |
20139 | Chile = 43, | |
20140 | China = 44, | |
20141 | ChristmasIsland = 45, | |
20142 | CocosIslands = 46, | |
20143 | Colombia = 47, | |
20144 | Comoros = 48, | |
20145 | DemocraticRepublicOfCongo = 49, | |
20146 | PeoplesRepublicOfCongo = 50, | |
20147 | CookIslands = 51, | |
20148 | CostaRica = 52, | |
20149 | IvoryCoast = 53, | |
20150 | Croatia = 54, | |
20151 | Cuba = 55, | |
20152 | Cyprus = 56, | |
20153 | CzechRepublic = 57, | |
20154 | Denmark = 58, | |
20155 | Djibouti = 59, | |
20156 | Dominica = 60, | |
20157 | DominicanRepublic = 61, | |
20158 | EastTimor = 62, | |
20159 | Ecuador = 63, | |
20160 | Egypt = 64, | |
20161 | ElSalvador = 65, | |
20162 | EquatorialGuinea = 66, | |
20163 | Eritrea = 67, | |
20164 | Estonia = 68, | |
20165 | Ethiopia = 69, | |
20166 | FalklandIslands = 70, | |
20167 | FaroeIslands = 71, | |
20168 | FijiCountry = 72, | |
20169 | Finland = 73, | |
20170 | France = 74, | |
20171 | MetropolitanFrance = 75, | |
20172 | FrenchGuiana = 76, | |
20173 | FrenchPolynesia = 77, | |
20174 | FrenchSouthernTerritories = 78, | |
20175 | Gabon = 79, | |
20176 | Gambia = 80, | |
20177 | Georgia = 81, | |
20178 | Germany = 82, | |
20179 | Ghana = 83, | |
20180 | Gibraltar = 84, | |
20181 | Greece = 85, | |
20182 | Greenland = 86, | |
20183 | Grenada = 87, | |
20184 | Guadeloupe = 88, | |
20185 | Guam = 89, | |
20186 | Guatemala = 90, | |
20187 | Guinea = 91, | |
20188 | GuineaBissau = 92, | |
20189 | Guyana = 93, | |
20190 | Haiti = 94, | |
20191 | HeardAndMcDonaldIslands = 95, | |
20192 | Honduras = 96, | |
20193 | HongKong = 97, | |
20194 | Hungary = 98, | |
20195 | Iceland = 99, | |
20196 | India = 100, | |
20197 | Indonesia = 101, | |
20198 | Iran = 102, | |
20199 | Iraq = 103, | |
20200 | Ireland = 104, | |
20201 | Israel = 105, | |
20202 | Italy = 106, | |
20203 | Jamaica = 107, | |
20204 | Japan = 108, | |
20205 | Jordan = 109, | |
20206 | Kazakhstan = 110, | |
20207 | Kenya = 111, | |
20208 | Kiribati = 112, | |
20209 | DemocraticRepublicOfKorea = 113, | |
20210 | RepublicOfKorea = 114, | |
20211 | Kuwait = 115, | |
20212 | Kyrgyzstan = 116, | |
20213 | Lao = 117, | |
20214 | Latvia = 118, | |
20215 | Lebanon = 119, | |
20216 | Lesotho = 120, | |
20217 | Liberia = 121, | |
20218 | LibyanArabJamahiriya = 122, | |
20219 | Liechtenstein = 123, | |
20220 | Lithuania = 124, | |
20221 | Luxembourg = 125, | |
20222 | Macau = 126, | |
20223 | Macedonia = 127, | |
20224 | Madagascar = 128, | |
20225 | Malawi = 129, | |
20226 | Malaysia = 130, | |
20227 | Maldives = 131, | |
20228 | Mali = 132, | |
20229 | Malta = 133, | |
20230 | MarshallIslands = 134, | |
20231 | Martinique = 135, | |
20232 | Mauritania = 136, | |
20233 | Mauritius = 137, | |
20234 | Mayotte = 138, | |
20235 | Mexico = 139, | |
20236 | Micronesia = 140, | |
20237 | Moldova = 141, | |
20238 | Monaco = 142, | |
20239 | Mongolia = 143, | |
20240 | Montserrat = 144, | |
20241 | Morocco = 145, | |
20242 | Mozambique = 146, | |
20243 | Myanmar = 147, | |
20244 | Namibia = 148, | |
20245 | NauruCountry = 149, | |
20246 | Nepal = 150, | |
20247 | Netherlands = 151, | |
20248 | NetherlandsAntilles = 152, | |
20249 | NewCaledonia = 153, | |
20250 | NewZealand = 154, | |
20251 | Nicaragua = 155, | |
20252 | Niger = 156, | |
20253 | Nigeria = 157, | |
20254 | Niue = 158, | |
20255 | NorfolkIsland = 159, | |
20256 | NorthernMarianaIslands = 160, | |
20257 | Norway = 161, | |
20258 | Oman = 162, | |
20259 | Pakistan = 163, | |
20260 | Palau = 164, | |
20261 | PalestinianTerritory = 165, | |
20262 | Panama = 166, | |
20263 | PapuaNewGuinea = 167, | |
20264 | Paraguay = 168, | |
20265 | Peru = 169, | |
20266 | Philippines = 170, | |
20267 | Pitcairn = 171, | |
20268 | Poland = 172, | |
20269 | Portugal = 173, | |
20270 | PuertoRico = 174, | |
20271 | Qatar = 175, | |
20272 | Reunion = 176, | |
20273 | Romania = 177, | |
20274 | RussianFederation = 178, | |
20275 | Rwanda = 179, | |
20276 | SaintKittsAndNevis = 180, | |
20277 | StLucia = 181, | |
20278 | StVincentAndTheGrenadines = 182, | |
20279 | Samoa = 183, | |
20280 | SanMarino = 184, | |
20281 | SaoTomeAndPrincipe = 185, | |
20282 | SaudiArabia = 186, | |
20283 | Senegal = 187, | |
20284 | Seychelles = 188, | |
20285 | SierraLeone = 189, | |
20286 | Singapore = 190, | |
20287 | Slovakia = 191, | |
20288 | Slovenia = 192, | |
20289 | SolomonIslands = 193, | |
20290 | Somalia = 194, | |
20291 | SouthAfrica = 195, | |
20292 | SouthGeorgiaAndTheSouthSandwichIslands = 196, | |
20293 | Spain = 197, | |
20294 | SriLanka = 198, | |
20295 | StHelena = 199, | |
20296 | StPierreAndMiquelon = 200, | |
20297 | Sudan = 201, | |
20298 | Suriname = 202, | |
20299 | SvalbardAndJanMayenIslands = 203, | |
20300 | Swaziland = 204, | |
20301 | Sweden = 205, | |
20302 | Switzerland = 206, | |
20303 | SyrianArabRepublic = 207, | |
20304 | Taiwan = 208, | |
20305 | Tajikistan = 209, | |
20306 | Tanzania = 210, | |
20307 | Thailand = 211, | |
20308 | Togo = 212, | |
20309 | Tokelau = 213, | |
20310 | TongaCountry = 214, | |
20311 | TrinidadAndTobago = 215, | |
20312 | Tunisia = 216, | |
20313 | Turkey = 217, | |
20314 | Turkmenistan = 218, | |
20315 | TurksAndCaicosIslands = 219, | |
20316 | Tuvalu = 220, | |
20317 | Uganda = 221, | |
20318 | Ukraine = 222, | |
20319 | UnitedArabEmirates = 223, | |
20320 | UnitedKingdom = 224, | |
20321 | UnitedStates = 225, | |
20322 | UnitedStatesMinorOutlyingIslands = 226, | |
20323 | Uruguay = 227, | |
20324 | Uzbekistan = 228, | |
20325 | Vanuatu = 229, | |
20326 | VaticanCityState = 230, | |
20327 | Venezuela = 231, | |
20328 | VietNam = 232, | |
20329 | BritishVirginIslands = 233, | |
20330 | USVirginIslands = 234, | |
20331 | WallisAndFutunaIslands = 235, | |
20332 | WesternSahara = 236, | |
20333 | Yemen = 237, | |
20334 | Yugoslavia = 238, | |
20335 | Zambia = 239, | |
20336 | Zimbabwe = 240, | |
20337 | SerbiaAndMontenegro = 241, | |
20338 | LastCountry = SerbiaAndMontenegro | |
20339 | }; | |
20340 | enum MeasurementSystem { MetricSystem, ImperialSystem }; | |
20341 | enum FormatType { LongFormat, ShortFormat, NarrowFormat }; | |
20342 | enum NumberOption { | |
20343 | OmitGroupSeparator = 0x01, | |
20344 | RejectGroupSeparator = 0x02 | |
20345 | }; | |
20346 | typedef QFlags<NumberOption> NumberOptions; | |
20347 | QLocale(); | |
20348 | QLocale(const QString &name); | |
20349 | QLocale(Language language, Country country = AnyCountry); | |
20350 | QLocale(const QLocale &other); | |
20351 | QLocale &operator=(const QLocale &other); | |
20352 | Language language() const; | |
20353 | Country country() const; | |
20354 | QString name() const; | |
20355 | short toShort(const QString &s, bool *ok = 0, int base = 0) const; | |
20356 | ushort toUShort(const QString &s, bool *ok = 0, int base = 0) const; | |
20357 | int toInt(const QString &s, bool *ok = 0, int base = 0) const; | |
20358 | uint toUInt(const QString &s, bool *ok = 0, int base = 0) const; | |
20359 | qlonglong toLongLong(const QString &s, bool *ok = 0, int base = 0) const; | |
20360 | qlonglong toULongLong(const QString &s, bool *ok = 0, int base = 0) const; | |
20361 | float toFloat(const QString &s, bool *ok = 0) const; | |
20362 | double toDouble(const QString &s, bool *ok = 0) const; | |
20363 | QString toString(qlonglong i) const; | |
20364 | QString toString(qulonglong i) const; | |
20365 | inline QString toString(short i) const; | |
20366 | inline QString toString(ushort i) const; | |
20367 | inline QString toString(int i) const; | |
20368 | inline QString toString(uint i) const; | |
20369 | QString toString(double i, char f = 'g', int prec = 6) const; | |
20370 | inline QString toString(float i, char f = 'g', int prec = 6) const; | |
20371 | QString toString(const QDate &date, const QString &formatStr) const; | |
20372 | QString toString(const QDate &date, FormatType format = LongFormat) const; | |
20373 | QString toString(const QTime &time, const QString &formatStr) const; | |
20374 | QString toString(const QTime &time, FormatType format = LongFormat) const; | |
20375 | QString toString(const QDateTime &dateTime, FormatType format = LongFormat) const; | |
20376 | QString toString(const QDateTime &dateTime, const QString &format) const; | |
20377 | QString dateFormat(FormatType format = LongFormat) const; | |
20378 | QString timeFormat(FormatType format = LongFormat) const; | |
20379 | QString dateTimeFormat(FormatType format = LongFormat) const; | |
20380 | QDate toDate(const QString &string, FormatType = LongFormat) const; | |
20381 | QTime toTime(const QString &string, FormatType = LongFormat) const; | |
20382 | QDateTime toDateTime(const QString &string, FormatType format = LongFormat) const; | |
20383 | QDate toDate(const QString &string, const QString &format) const; | |
20384 | QTime toTime(const QString &string, const QString &format) const; | |
20385 | QDateTime toDateTime(const QString &string, const QString &format) const; | |
20386 | QChar decimalPoint() const; | |
20387 | QChar groupSeparator() const; | |
20388 | QChar percent() const; | |
20389 | QChar zeroDigit() const; | |
20390 | QChar negativeSign() const; | |
20391 | QChar positiveSign() const; | |
20392 | QChar exponential() const; | |
20393 | QString monthName(int, FormatType format = LongFormat) const; | |
20394 | QString standaloneMonthName(int, FormatType format = LongFormat) const; | |
20395 | QString dayName(int, FormatType format = LongFormat) const; | |
20396 | QString standaloneDayName(int, FormatType format = LongFormat) const; | |
20397 | QString amText() const; | |
20398 | QString pmText() const; | |
20399 | MeasurementSystem measurementSystem() const; | |
20400 | inline bool operator==(const QLocale &other) const; | |
20401 | inline bool operator!=(const QLocale &other) const; | |
20402 | static QString languageToString(Language language); | |
20403 | static QString countryToString(Country country); | |
20404 | static void setDefault(const QLocale &locale); | |
20405 | static QLocale c() { return QLocale(C); } | |
20406 | static QLocale system(); | |
20407 | static QList<Country> countriesForLanguage(Language lang); | |
20408 | void setNumberOptions(NumberOptions options); | |
20409 | NumberOptions numberOptions() const; | |
20410 | struct Data { | |
20411 | quint16 index; | |
20412 | quint16 numberOptions; | |
20413 | } | |
20414 | ; | |
20415 | private: | |
20416 | friend struct QLocalePrivate; | |
20417 | union { | |
20418 | void *v; | |
20419 | Data p; | |
20420 | }; | |
20421 | const QLocalePrivate *d() const; | |
20422 | }; | |
20423 | template <> class QTypeInfo<QLocale> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLocale)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLocale"; } }; | |
20424 | inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QLocale::NumberOptions::enum_type f2) { return QFlags<QLocale::NumberOptions::enum_type>(f1) | f2; } inline QFlags<QLocale::NumberOptions::enum_type> operator|(QLocale::NumberOptions::enum_type f1, QFlags<QLocale::NumberOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QLocale::NumberOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
20425 | inline QString QLocale::toString(short i) const | |
20426 | { return toString(qlonglong(i)); } | |
20427 | inline QString QLocale::toString(ushort i) const | |
20428 | { return toString(qulonglong(i)); } | |
20429 | inline QString QLocale::toString(int i) const | |
20430 | { return toString(qlonglong(i)); } | |
20431 | inline QString QLocale::toString(uint i) const | |
20432 | { return toString(qulonglong(i)); } | |
20433 | inline QString QLocale::toString(float i, char f, int prec) const | |
20434 | { return toString(double(i), f, prec); } | |
20435 | inline bool QLocale::operator==(const QLocale &other) const | |
20436 | { return d() == other.d() && numberOptions() == other.numberOptions(); } | |
20437 | inline bool QLocale::operator!=(const QLocale &other) const | |
20438 | { return d() != other.d() || numberOptions() != other.numberOptions(); } | |
20439 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QLocale &); | |
20440 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QLocale &); | |
20441 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
20442 | class QTextCodec; | |
20443 | class QTextDecoder; | |
20444 | class QTextStreamPrivate; | |
20445 | class __attribute__((visibility("default"))) QTextStream | |
20446 | { | |
20447 | inline QTextStreamPrivate* d_func() { return reinterpret_cast<QTextStreamPrivate *>(d_ptr); } inline const QTextStreamPrivate* d_func() const { return reinterpret_cast<const QTextStreamPrivate *>(d_ptr); } friend class QTextStreamPrivate; | |
20448 | public: | |
20449 | enum RealNumberNotation { | |
20450 | SmartNotation, | |
20451 | FixedNotation, | |
20452 | ScientificNotation | |
20453 | }; | |
20454 | enum FieldAlignment { | |
20455 | AlignLeft, | |
20456 | AlignRight, | |
20457 | AlignCenter, | |
20458 | AlignAccountingStyle | |
20459 | }; | |
20460 | enum Status { | |
20461 | Ok, | |
20462 | ReadPastEnd, | |
20463 | ReadCorruptData | |
20464 | }; | |
20465 | enum NumberFlag { | |
20466 | ShowBase = 0x1, | |
20467 | ForcePoint = 0x2, | |
20468 | ForceSign = 0x4, | |
20469 | UppercaseBase = 0x8, | |
20470 | UppercaseDigits = 0x10 | |
20471 | }; | |
20472 | typedef QFlags<NumberFlag> NumberFlags; | |
20473 | QTextStream(); | |
20474 | explicit QTextStream(QIODevice *device); | |
20475 | explicit QTextStream(FILE *fileHandle, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | |
20476 | explicit QTextStream(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | |
20477 | explicit QTextStream(QByteArray *array, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | |
20478 | explicit QTextStream(const QByteArray &array, QIODevice::OpenMode openMode = QIODevice::ReadOnly); | |
20479 | virtual ~QTextStream(); | |
20480 | void setCodec(QTextCodec *codec); | |
20481 | void setCodec(const char *codecName); | |
20482 | QTextCodec *codec() const; | |
20483 | void setAutoDetectUnicode(bool enabled); | |
20484 | bool autoDetectUnicode() const; | |
20485 | void setGenerateByteOrderMark(bool generate); | |
20486 | bool generateByteOrderMark() const; | |
20487 | void setLocale(const QLocale &locale); | |
20488 | QLocale locale() const; | |
20489 | void setDevice(QIODevice *device); | |
20490 | QIODevice *device() const; | |
20491 | void setString(QString *string, QIODevice::OpenMode openMode = QIODevice::ReadWrite); | |
20492 | QString *string() const; | |
20493 | Status status() const; | |
20494 | void setStatus(Status status); | |
20495 | void resetStatus(); | |
20496 | bool atEnd() const; | |
20497 | void reset(); | |
20498 | void flush(); | |
20499 | bool seek(qint64 pos); | |
20500 | qint64 pos() const; | |
20501 | void skipWhiteSpace(); | |
20502 | QString readLine(qint64 maxlen = 0); | |
20503 | QString readAll(); | |
20504 | QString read(qint64 maxlen); | |
20505 | void setFieldAlignment(FieldAlignment alignment); | |
20506 | FieldAlignment fieldAlignment() const; | |
20507 | void setPadChar(QChar ch); | |
20508 | QChar padChar() const; | |
20509 | void setFieldWidth(int width); | |
20510 | int fieldWidth() const; | |
20511 | void setNumberFlags(NumberFlags flags); | |
20512 | NumberFlags numberFlags() const; | |
20513 | void setIntegerBase(int base); | |
20514 | int integerBase() const; | |
20515 | void setRealNumberNotation(RealNumberNotation notation); | |
20516 | RealNumberNotation realNumberNotation() const; | |
20517 | void setRealNumberPrecision(int precision); | |
20518 | int realNumberPrecision() const; | |
20519 | QTextStream &operator>>(QChar &ch); | |
20520 | QTextStream &operator>>(char &ch); | |
20521 | QTextStream &operator>>(signed short &i); | |
20522 | QTextStream &operator>>(unsigned short &i); | |
20523 | QTextStream &operator>>(signed int &i); | |
20524 | QTextStream &operator>>(unsigned int &i); | |
20525 | QTextStream &operator>>(signed long &i); | |
20526 | QTextStream &operator>>(unsigned long &i); | |
20527 | QTextStream &operator>>(qlonglong &i); | |
20528 | QTextStream &operator>>(qulonglong &i); | |
20529 | QTextStream &operator>>(float &f); | |
20530 | QTextStream &operator>>(double &f); | |
20531 | QTextStream &operator>>(QString &s); | |
20532 | QTextStream &operator>>(QByteArray &array); | |
20533 | QTextStream &operator>>(char *c); | |
20534 | QTextStream &operator<<(QBool b); | |
20535 | QTextStream &operator<<(QChar ch); | |
20536 | QTextStream &operator<<(char ch); | |
20537 | QTextStream &operator<<(signed short i); | |
20538 | QTextStream &operator<<(unsigned short i); | |
20539 | QTextStream &operator<<(signed int i); | |
20540 | QTextStream &operator<<(unsigned int i); | |
20541 | QTextStream &operator<<(signed long i); | |
20542 | QTextStream &operator<<(unsigned long i); | |
20543 | QTextStream &operator<<(qlonglong i); | |
20544 | QTextStream &operator<<(qulonglong i); | |
20545 | QTextStream &operator<<(float f); | |
20546 | QTextStream &operator<<(double f); | |
20547 | QTextStream &operator<<(const QString &s); | |
20548 | QTextStream &operator<<(const QByteArray &array); | |
20549 | QTextStream &operator<<(const char *c); | |
20550 | QTextStream &operator<<(const void *ptr); | |
20551 | private: | |
20552 | QTextStream(const QTextStream &); QTextStream &operator=(const QTextStream &); | |
20553 | QTextStreamPrivate *d_ptr; | |
20554 | }; | |
20555 | inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QTextStream::NumberFlags::enum_type f2) { return QFlags<QTextStream::NumberFlags::enum_type>(f1) | f2; } inline QFlags<QTextStream::NumberFlags::enum_type> operator|(QTextStream::NumberFlags::enum_type f1, QFlags<QTextStream::NumberFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextStream::NumberFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
20556 | typedef QTextStream & (*QTextStreamFunction)(QTextStream &); | |
20557 | typedef void (QTextStream::*QTSMFI)(int); | |
20558 | typedef void (QTextStream::*QTSMFC)(QChar); | |
20559 | class __attribute__((visibility("default"))) QTextStreamManipulator | |
20560 | { | |
20561 | public: | |
20562 | QTextStreamManipulator(QTSMFI m, int a) { mf = m; mc = 0; arg = a; } | |
20563 | QTextStreamManipulator(QTSMFC m, QChar c) { mf = 0; mc = m; ch = c; } | |
20564 | void exec(QTextStream &s) { if (mf) { (s.*mf)(arg); } else { (s.*mc)(ch); } } | |
20565 | private: | |
20566 | QTSMFI mf; | |
20567 | QTSMFC mc; | |
20568 | int arg; | |
20569 | QChar ch; | |
20570 | }; | |
20571 | inline QTextStream &operator>>(QTextStream &s, QTextStreamFunction f) | |
20572 | { return (*f)(s); } | |
20573 | inline QTextStream &operator<<(QTextStream &s, QTextStreamFunction f) | |
20574 | { return (*f)(s); } | |
20575 | inline QTextStream &operator<<(QTextStream &s, QTextStreamManipulator m) | |
20576 | { m.exec(s); return s; } | |
20577 | __attribute__((visibility("default"))) QTextStream &bin(QTextStream &s); | |
20578 | __attribute__((visibility("default"))) QTextStream &oct(QTextStream &s); | |
20579 | __attribute__((visibility("default"))) QTextStream &dec(QTextStream &s); | |
20580 | __attribute__((visibility("default"))) QTextStream &hex(QTextStream &s); | |
20581 | __attribute__((visibility("default"))) QTextStream &showbase(QTextStream &s); | |
20582 | __attribute__((visibility("default"))) QTextStream &forcesign(QTextStream &s); | |
20583 | __attribute__((visibility("default"))) QTextStream &forcepoint(QTextStream &s); | |
20584 | __attribute__((visibility("default"))) QTextStream &noshowbase(QTextStream &s); | |
20585 | __attribute__((visibility("default"))) QTextStream &noforcesign(QTextStream &s); | |
20586 | __attribute__((visibility("default"))) QTextStream &noforcepoint(QTextStream &s); | |
20587 | __attribute__((visibility("default"))) QTextStream &uppercasebase(QTextStream &s); | |
20588 | __attribute__((visibility("default"))) QTextStream &uppercasedigits(QTextStream &s); | |
20589 | __attribute__((visibility("default"))) QTextStream &lowercasebase(QTextStream &s); | |
20590 | __attribute__((visibility("default"))) QTextStream &lowercasedigits(QTextStream &s); | |
20591 | __attribute__((visibility("default"))) QTextStream &fixed(QTextStream &s); | |
20592 | __attribute__((visibility("default"))) QTextStream &scientific(QTextStream &s); | |
20593 | __attribute__((visibility("default"))) QTextStream &left(QTextStream &s); | |
20594 | __attribute__((visibility("default"))) QTextStream &right(QTextStream &s); | |
20595 | __attribute__((visibility("default"))) QTextStream ¢er(QTextStream &s); | |
20596 | __attribute__((visibility("default"))) QTextStream &endl(QTextStream &s); | |
20597 | __attribute__((visibility("default"))) QTextStream &flush(QTextStream &s); | |
20598 | __attribute__((visibility("default"))) QTextStream &reset(QTextStream &s); | |
20599 | __attribute__((visibility("default"))) QTextStream &bom(QTextStream &s); | |
20600 | __attribute__((visibility("default"))) QTextStream &ws(QTextStream &s); | |
20601 | inline QTextStreamManipulator qSetFieldWidth(int width) | |
20602 | { | |
20603 | QTSMFI func = &QTextStream::setFieldWidth; | |
20604 | return QTextStreamManipulator(func,width); | |
20605 | } | |
20606 | inline QTextStreamManipulator qSetPadChar(QChar ch) | |
20607 | { | |
20608 | QTSMFC func = &QTextStream::setPadChar; | |
20609 | return QTextStreamManipulator(func, ch); | |
20610 | } | |
20611 | inline QTextStreamManipulator qSetRealNumberPrecision(int precision) | |
20612 | { | |
20613 | QTSMFI func = &QTextStream::setRealNumberPrecision; | |
20614 | return QTextStreamManipulator(func, precision); | |
20615 | } | |
20616 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
20617 | template<typename _T1, typename _T2> | |
20618 | inline void | |
20619 | _Construct(_T1* __p, const _T2& __value) | |
20620 | { | |
20621 | ::new(static_cast<void*>(__p)) _T1(__value); | |
20622 | } | |
20623 | template<typename _Tp> | |
20624 | inline void | |
20625 | _Destroy(_Tp* __pointer) | |
20626 | { __pointer->~_Tp(); } | |
20627 | template<typename _ForwardIterator> | |
20628 | inline void | |
20629 | _Destroy(_ForwardIterator __first, _ForwardIterator __last) | |
20630 | { | |
20631 | typedef typename iterator_traits<_ForwardIterator>::value_type | |
20632 | _Value_type; | |
20633 | if (!__has_trivial_destructor(_Value_type)) | |
20634 | for (; __first != __last; ++__first) | |
20635 | std::_Destroy(&*__first); | |
20636 | } | |
20637 | template <typename _Tp> class allocator; | |
20638 | template<typename _ForwardIterator, typename _Allocator> | |
20639 | void | |
20640 | _Destroy(_ForwardIterator __first, _ForwardIterator __last, | |
20641 | _Allocator& __alloc) | |
20642 | { | |
20643 | for (; __first != __last; ++__first) | |
20644 | __alloc.destroy(&*__first); | |
20645 | } | |
20646 | template<typename _ForwardIterator, typename _Tp> | |
20647 | inline void | |
20648 | _Destroy(_ForwardIterator __first, _ForwardIterator __last, | |
20649 | allocator<_Tp>&) | |
20650 | { | |
20651 | _Destroy(__first, __last); | |
20652 | } | |
20653 | } | |
20654 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
20655 | template<bool> | |
20656 | struct __uninitialized_copy | |
20657 | { | |
20658 | template<typename _InputIterator, typename _ForwardIterator> | |
20659 | static _ForwardIterator | |
20660 | uninitialized_copy(_InputIterator __first, _InputIterator __last, | |
20661 | _ForwardIterator __result) | |
20662 | { | |
20663 | _ForwardIterator __cur = __result; | |
20664 | try | |
20665 | { | |
20666 | for (; __first != __last; ++__first, ++__cur) | |
20667 | ::new(static_cast<void*>(&*__cur)) typename | |
20668 | iterator_traits<_ForwardIterator>::value_type(*__first); | |
20669 | return __cur; | |
20670 | } | |
20671 | catch(...) | |
20672 | { | |
20673 | std::_Destroy(__result, __cur); | |
20674 | throw; | |
20675 | } | |
20676 | } | |
20677 | }; | |
20678 | template<> | |
20679 | struct __uninitialized_copy<true> | |
20680 | { | |
20681 | template<typename _InputIterator, typename _ForwardIterator> | |
20682 | static _ForwardIterator | |
20683 | uninitialized_copy(_InputIterator __first, _InputIterator __last, | |
20684 | _ForwardIterator __result) | |
20685 | { return std::copy(__first, __last, __result); } | |
20686 | }; | |
20687 | template<typename _InputIterator, typename _ForwardIterator> | |
20688 | inline _ForwardIterator | |
20689 | uninitialized_copy(_InputIterator __first, _InputIterator __last, | |
20690 | _ForwardIterator __result) | |
20691 | { | |
20692 | typedef typename iterator_traits<_InputIterator>::value_type | |
20693 | _ValueType1; | |
20694 | typedef typename iterator_traits<_ForwardIterator>::value_type | |
20695 | _ValueType2; | |
20696 | return std::__uninitialized_copy<(__is_pod(_ValueType1) | |
20697 | && __is_pod(_ValueType2))>:: | |
20698 | uninitialized_copy(__first, __last, __result); | |
20699 | } | |
20700 | template<bool> | |
20701 | struct __uninitialized_fill | |
20702 | { | |
20703 | template<typename _ForwardIterator, typename _Tp> | |
20704 | static void | |
20705 | uninitialized_fill(_ForwardIterator __first, | |
20706 | _ForwardIterator __last, const _Tp& __x) | |
20707 | { | |
20708 | _ForwardIterator __cur = __first; | |
20709 | try | |
20710 | { | |
20711 | for (; __cur != __last; ++__cur) | |
20712 | std::_Construct(&*__cur, __x); | |
20713 | } | |
20714 | catch(...) | |
20715 | { | |
20716 | std::_Destroy(__first, __cur); | |
20717 | throw; | |
20718 | } | |
20719 | } | |
20720 | }; | |
20721 | template<> | |
20722 | struct __uninitialized_fill<true> | |
20723 | { | |
20724 | template<typename _ForwardIterator, typename _Tp> | |
20725 | static void | |
20726 | uninitialized_fill(_ForwardIterator __first, | |
20727 | _ForwardIterator __last, const _Tp& __x) | |
20728 | { std::fill(__first, __last, __x); } | |
20729 | }; | |
20730 | template<typename _ForwardIterator, typename _Tp> | |
20731 | inline void | |
20732 | uninitialized_fill(_ForwardIterator __first, _ForwardIterator __last, | |
20733 | const _Tp& __x) | |
20734 | { | |
20735 | typedef typename iterator_traits<_ForwardIterator>::value_type | |
20736 | _ValueType; | |
20737 | std::__uninitialized_fill<__is_pod(_ValueType)>:: | |
20738 | uninitialized_fill(__first, __last, __x); | |
20739 | } | |
20740 | template<bool> | |
20741 | struct __uninitialized_fill_n | |
20742 | { | |
20743 | template<typename _ForwardIterator, typename _Size, typename _Tp> | |
20744 | static void | |
20745 | uninitialized_fill_n(_ForwardIterator __first, _Size __n, | |
20746 | const _Tp& __x) | |
20747 | { | |
20748 | _ForwardIterator __cur = __first; | |
20749 | try | |
20750 | { | |
20751 | for (; __n > 0; --__n, ++__cur) | |
20752 | std::_Construct(&*__cur, __x); | |
20753 | } | |
20754 | catch(...) | |
20755 | { | |
20756 | std::_Destroy(__first, __cur); | |
20757 | throw; | |
20758 | } | |
20759 | } | |
20760 | }; | |
20761 | template<> | |
20762 | struct __uninitialized_fill_n<true> | |
20763 | { | |
20764 | template<typename _ForwardIterator, typename _Size, typename _Tp> | |
20765 | static void | |
20766 | uninitialized_fill_n(_ForwardIterator __first, _Size __n, | |
20767 | const _Tp& __x) | |
20768 | { std::fill_n(__first, __n, __x); } | |
20769 | }; | |
20770 | template<typename _ForwardIterator, typename _Size, typename _Tp> | |
20771 | inline void | |
20772 | uninitialized_fill_n(_ForwardIterator __first, _Size __n, const _Tp& __x) | |
20773 | { | |
20774 | typedef typename iterator_traits<_ForwardIterator>::value_type | |
20775 | _ValueType; | |
20776 | std::__uninitialized_fill_n<__is_pod(_ValueType)>:: | |
20777 | uninitialized_fill_n(__first, __n, __x); | |
20778 | } | |
20779 | template<typename _InputIterator, typename _ForwardIterator, | |
20780 | typename _Allocator> | |
20781 | _ForwardIterator | |
20782 | __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, | |
20783 | _ForwardIterator __result, _Allocator& __alloc) | |
20784 | { | |
20785 | _ForwardIterator __cur = __result; | |
20786 | try | |
20787 | { | |
20788 | for (; __first != __last; ++__first, ++__cur) | |
20789 | __alloc.construct(&*__cur, *__first); | |
20790 | return __cur; | |
20791 | } | |
20792 | catch(...) | |
20793 | { | |
20794 | std::_Destroy(__result, __cur, __alloc); | |
20795 | throw; | |
20796 | } | |
20797 | } | |
20798 | template<typename _InputIterator, typename _ForwardIterator, typename _Tp> | |
20799 | inline _ForwardIterator | |
20800 | __uninitialized_copy_a(_InputIterator __first, _InputIterator __last, | |
20801 | _ForwardIterator __result, allocator<_Tp>&) | |
20802 | { return std::uninitialized_copy(__first, __last, __result); } | |
20803 | template<typename _InputIterator, typename _ForwardIterator, | |
20804 | typename _Allocator> | |
20805 | inline _ForwardIterator | |
20806 | __uninitialized_move_a(_InputIterator __first, _InputIterator __last, | |
20807 | _ForwardIterator __result, _Allocator& __alloc) | |
20808 | { | |
20809 | return std::__uninitialized_copy_a((__first), | |
20810 | (__last), | |
20811 | __result, __alloc); | |
20812 | } | |
20813 | template<typename _ForwardIterator, typename _Tp, typename _Allocator> | |
20814 | void | |
20815 | __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
20816 | const _Tp& __x, _Allocator& __alloc) | |
20817 | { | |
20818 | _ForwardIterator __cur = __first; | |
20819 | try | |
20820 | { | |
20821 | for (; __cur != __last; ++__cur) | |
20822 | __alloc.construct(&*__cur, __x); | |
20823 | } | |
20824 | catch(...) | |
20825 | { | |
20826 | std::_Destroy(__first, __cur, __alloc); | |
20827 | throw; | |
20828 | } | |
20829 | } | |
20830 | template<typename _ForwardIterator, typename _Tp, typename _Tp2> | |
20831 | inline void | |
20832 | __uninitialized_fill_a(_ForwardIterator __first, _ForwardIterator __last, | |
20833 | const _Tp& __x, allocator<_Tp2>&) | |
20834 | { std::uninitialized_fill(__first, __last, __x); } | |
20835 | template<typename _ForwardIterator, typename _Size, typename _Tp, | |
20836 | typename _Allocator> | |
20837 | void | |
20838 | __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, | |
20839 | const _Tp& __x, _Allocator& __alloc) | |
20840 | { | |
20841 | _ForwardIterator __cur = __first; | |
20842 | try | |
20843 | { | |
20844 | for (; __n > 0; --__n, ++__cur) | |
20845 | __alloc.construct(&*__cur, __x); | |
20846 | } | |
20847 | catch(...) | |
20848 | { | |
20849 | std::_Destroy(__first, __cur, __alloc); | |
20850 | throw; | |
20851 | } | |
20852 | } | |
20853 | template<typename _ForwardIterator, typename _Size, typename _Tp, | |
20854 | typename _Tp2> | |
20855 | inline void | |
20856 | __uninitialized_fill_n_a(_ForwardIterator __first, _Size __n, | |
20857 | const _Tp& __x, allocator<_Tp2>&) | |
20858 | { std::uninitialized_fill_n(__first, __n, __x); } | |
20859 | template<typename _InputIterator1, typename _InputIterator2, | |
20860 | typename _ForwardIterator, typename _Allocator> | |
20861 | inline _ForwardIterator | |
20862 | __uninitialized_copy_move(_InputIterator1 __first1, | |
20863 | _InputIterator1 __last1, | |
20864 | _InputIterator2 __first2, | |
20865 | _InputIterator2 __last2, | |
20866 | _ForwardIterator __result, | |
20867 | _Allocator& __alloc) | |
20868 | { | |
20869 | _ForwardIterator __mid = std::__uninitialized_copy_a(__first1, __last1, | |
20870 | __result, | |
20871 | __alloc); | |
20872 | try | |
20873 | { | |
20874 | return std::__uninitialized_move_a(__first2, __last2, __mid, __alloc); | |
20875 | } | |
20876 | catch(...) | |
20877 | { | |
20878 | std::_Destroy(__result, __mid, __alloc); | |
20879 | throw; | |
20880 | } | |
20881 | } | |
20882 | template<typename _InputIterator1, typename _InputIterator2, | |
20883 | typename _ForwardIterator, typename _Allocator> | |
20884 | inline _ForwardIterator | |
20885 | __uninitialized_move_copy(_InputIterator1 __first1, | |
20886 | _InputIterator1 __last1, | |
20887 | _InputIterator2 __first2, | |
20888 | _InputIterator2 __last2, | |
20889 | _ForwardIterator __result, | |
20890 | _Allocator& __alloc) | |
20891 | { | |
20892 | _ForwardIterator __mid = std::__uninitialized_move_a(__first1, __last1, | |
20893 | __result, | |
20894 | __alloc); | |
20895 | try | |
20896 | { | |
20897 | return std::__uninitialized_copy_a(__first2, __last2, __mid, __alloc); | |
20898 | } | |
20899 | catch(...) | |
20900 | { | |
20901 | std::_Destroy(__result, __mid, __alloc); | |
20902 | throw; | |
20903 | } | |
20904 | } | |
20905 | template<typename _ForwardIterator, typename _Tp, typename _InputIterator, | |
20906 | typename _Allocator> | |
20907 | inline _ForwardIterator | |
20908 | __uninitialized_fill_move(_ForwardIterator __result, _ForwardIterator __mid, | |
20909 | const _Tp& __x, _InputIterator __first, | |
20910 | _InputIterator __last, _Allocator& __alloc) | |
20911 | { | |
20912 | std::__uninitialized_fill_a(__result, __mid, __x, __alloc); | |
20913 | try | |
20914 | { | |
20915 | return std::__uninitialized_move_a(__first, __last, __mid, __alloc); | |
20916 | } | |
20917 | catch(...) | |
20918 | { | |
20919 | std::_Destroy(__result, __mid, __alloc); | |
20920 | throw; | |
20921 | } | |
20922 | } | |
20923 | template<typename _InputIterator, typename _ForwardIterator, typename _Tp, | |
20924 | typename _Allocator> | |
20925 | inline void | |
20926 | __uninitialized_move_fill(_InputIterator __first1, _InputIterator __last1, | |
20927 | _ForwardIterator __first2, | |
20928 | _ForwardIterator __last2, const _Tp& __x, | |
20929 | _Allocator& __alloc) | |
20930 | { | |
20931 | _ForwardIterator __mid2 = std::__uninitialized_move_a(__first1, __last1, | |
20932 | __first2, | |
20933 | __alloc); | |
20934 | try | |
20935 | { | |
20936 | std::__uninitialized_fill_a(__mid2, __last2, __x, __alloc); | |
20937 | } | |
20938 | catch(...) | |
20939 | { | |
20940 | std::_Destroy(__first2, __mid2, __alloc); | |
20941 | throw; | |
20942 | } | |
20943 | } | |
20944 | } | |
20945 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
20946 | template<typename _Tp, typename _Alloc> | |
20947 | struct _Vector_base | |
20948 | { | |
20949 | typedef typename _Alloc::template rebind<_Tp>::other _Tp_alloc_type; | |
20950 | struct _Vector_impl | |
20951 | : public _Tp_alloc_type | |
20952 | { | |
20953 | _Tp* _M_start; | |
20954 | _Tp* _M_finish; | |
20955 | _Tp* _M_end_of_storage; | |
20956 | _Vector_impl() | |
20957 | : _Tp_alloc_type(), _M_start(0), _M_finish(0), _M_end_of_storage(0) | |
20958 | { } | |
20959 | _Vector_impl(_Tp_alloc_type const& __a) | |
20960 | : _Tp_alloc_type(__a), _M_start(0), _M_finish(0), _M_end_of_storage(0) | |
20961 | { } | |
20962 | }; | |
20963 | public: | |
20964 | typedef _Alloc allocator_type; | |
20965 | _Tp_alloc_type& | |
20966 | _M_get_Tp_allocator() | |
20967 | { return *static_cast<_Tp_alloc_type*>(&this->_M_impl); } | |
20968 | const _Tp_alloc_type& | |
20969 | _M_get_Tp_allocator() const | |
20970 | { return *static_cast<const _Tp_alloc_type*>(&this->_M_impl); } | |
20971 | allocator_type | |
20972 | get_allocator() const | |
20973 | { return allocator_type(_M_get_Tp_allocator()); } | |
20974 | _Vector_base() | |
20975 | : _M_impl() { } | |
20976 | _Vector_base(const allocator_type& __a) | |
20977 | : _M_impl(__a) { } | |
20978 | _Vector_base(size_t __n, const allocator_type& __a) | |
20979 | : _M_impl(__a) | |
20980 | { | |
20981 | this->_M_impl._M_start = this->_M_allocate(__n); | |
20982 | this->_M_impl._M_finish = this->_M_impl._M_start; | |
20983 | this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; | |
20984 | } | |
20985 | ~_Vector_base() | |
20986 | { _M_deallocate(this->_M_impl._M_start, this->_M_impl._M_end_of_storage | |
20987 | - this->_M_impl._M_start); } | |
20988 | public: | |
20989 | _Vector_impl _M_impl; | |
20990 | _Tp* | |
20991 | _M_allocate(size_t __n) | |
20992 | { return __n != 0 ? _M_impl.allocate(__n) : 0; } | |
20993 | void | |
20994 | _M_deallocate(_Tp* __p, size_t __n) | |
20995 | { | |
20996 | if (__p) | |
20997 | _M_impl.deallocate(__p, __n); | |
20998 | } | |
20999 | }; | |
21000 | template<typename _Tp, typename _Alloc = std::allocator<_Tp> > | |
21001 | class vector : protected _Vector_base<_Tp, _Alloc> | |
21002 | { | |
21003 | typedef typename _Alloc::value_type _Alloc_value_type; | |
21004 | typedef _Vector_base<_Tp, _Alloc> _Base; | |
21005 | typedef vector<_Tp, _Alloc> vector_type; | |
21006 | typedef typename _Base::_Tp_alloc_type _Tp_alloc_type; | |
21007 | public: | |
21008 | typedef _Tp value_type; | |
21009 | typedef typename _Tp_alloc_type::pointer pointer; | |
21010 | typedef typename _Tp_alloc_type::const_pointer const_pointer; | |
21011 | typedef typename _Tp_alloc_type::reference reference; | |
21012 | typedef typename _Tp_alloc_type::const_reference const_reference; | |
21013 | typedef __gnu_cxx::__normal_iterator<pointer, vector_type> iterator; | |
21014 | typedef __gnu_cxx::__normal_iterator<const_pointer, vector_type> | |
21015 | const_iterator; | |
21016 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
21017 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
21018 | typedef size_t size_type; | |
21019 | typedef ptrdiff_t difference_type; | |
21020 | typedef _Alloc allocator_type; | |
21021 | protected: | |
21022 | using _Base::_M_allocate; | |
21023 | using _Base::_M_deallocate; | |
21024 | using _Base::_M_impl; | |
21025 | using _Base::_M_get_Tp_allocator; | |
21026 | public: | |
21027 | vector() | |
21028 | : _Base() { } | |
21029 | explicit | |
21030 | vector(const allocator_type& __a) | |
21031 | : _Base(__a) { } | |
21032 | explicit | |
21033 | vector(size_type __n, const value_type& __value = value_type(), | |
21034 | const allocator_type& __a = allocator_type()) | |
21035 | : _Base(__n, __a) | |
21036 | { _M_fill_initialize(__n, __value); } | |
21037 | vector(const vector& __x) | |
21038 | : _Base(__x.size(), __x._M_get_Tp_allocator()) | |
21039 | { this->_M_impl._M_finish = | |
21040 | std::__uninitialized_copy_a(__x.begin(), __x.end(), | |
21041 | this->_M_impl._M_start, | |
21042 | _M_get_Tp_allocator()); | |
21043 | } | |
21044 | template<typename _InputIterator> | |
21045 | vector(_InputIterator __first, _InputIterator __last, | |
21046 | const allocator_type& __a = allocator_type()) | |
21047 | : _Base(__a) | |
21048 | { | |
21049 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
21050 | _M_initialize_dispatch(__first, __last, _Integral()); | |
21051 | } | |
21052 | ~vector() | |
21053 | { std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
21054 | _M_get_Tp_allocator()); } | |
21055 | vector& | |
21056 | operator=(const vector& __x); | |
21057 | void | |
21058 | assign(size_type __n, const value_type& __val) | |
21059 | { _M_fill_assign(__n, __val); } | |
21060 | template<typename _InputIterator> | |
21061 | void | |
21062 | assign(_InputIterator __first, _InputIterator __last) | |
21063 | { | |
21064 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
21065 | _M_assign_dispatch(__first, __last, _Integral()); | |
21066 | } | |
21067 | using _Base::get_allocator; | |
21068 | iterator | |
21069 | begin() | |
21070 | { return iterator(this->_M_impl._M_start); } | |
21071 | const_iterator | |
21072 | begin() const | |
21073 | { return const_iterator(this->_M_impl._M_start); } | |
21074 | iterator | |
21075 | end() | |
21076 | { return iterator(this->_M_impl._M_finish); } | |
21077 | const_iterator | |
21078 | end() const | |
21079 | { return const_iterator(this->_M_impl._M_finish); } | |
21080 | reverse_iterator | |
21081 | rbegin() | |
21082 | { return reverse_iterator(end()); } | |
21083 | const_reverse_iterator | |
21084 | rbegin() const | |
21085 | { return const_reverse_iterator(end()); } | |
21086 | reverse_iterator | |
21087 | rend() | |
21088 | { return reverse_iterator(begin()); } | |
21089 | const_reverse_iterator | |
21090 | rend() const | |
21091 | { return const_reverse_iterator(begin()); } | |
21092 | size_type | |
21093 | size() const | |
21094 | { return size_type(this->_M_impl._M_finish - this->_M_impl._M_start); } | |
21095 | size_type | |
21096 | max_size() const | |
21097 | { return _M_get_Tp_allocator().max_size(); } | |
21098 | void | |
21099 | resize(size_type __new_size, value_type __x = value_type()) | |
21100 | { | |
21101 | if (__new_size < size()) | |
21102 | _M_erase_at_end(this->_M_impl._M_start + __new_size); | |
21103 | else | |
21104 | insert(end(), __new_size - size(), __x); | |
21105 | } | |
21106 | size_type | |
21107 | capacity() const | |
21108 | { return size_type(this->_M_impl._M_end_of_storage | |
21109 | - this->_M_impl._M_start); } | |
21110 | bool | |
21111 | empty() const | |
21112 | { return begin() == end(); } | |
21113 | void | |
21114 | reserve(size_type __n); | |
21115 | reference | |
21116 | operator[](size_type __n) | |
21117 | { return *(this->_M_impl._M_start + __n); } | |
21118 | const_reference | |
21119 | operator[](size_type __n) const | |
21120 | { return *(this->_M_impl._M_start + __n); } | |
21121 | protected: | |
21122 | void | |
21123 | _M_range_check(size_type __n) const | |
21124 | { | |
21125 | if (__n >= this->size()) | |
21126 | __throw_out_of_range(("vector::_M_range_check")); | |
21127 | } | |
21128 | public: | |
21129 | reference | |
21130 | at(size_type __n) | |
21131 | { | |
21132 | _M_range_check(__n); | |
21133 | return (*this)[__n]; | |
21134 | } | |
21135 | const_reference | |
21136 | at(size_type __n) const | |
21137 | { | |
21138 | _M_range_check(__n); | |
21139 | return (*this)[__n]; | |
21140 | } | |
21141 | reference | |
21142 | front() | |
21143 | { return *begin(); } | |
21144 | const_reference | |
21145 | front() const | |
21146 | { return *begin(); } | |
21147 | reference | |
21148 | back() | |
21149 | { return *(end() - 1); } | |
21150 | const_reference | |
21151 | back() const | |
21152 | { return *(end() - 1); } | |
21153 | pointer | |
21154 | data() | |
21155 | { return pointer(this->_M_impl._M_start); } | |
21156 | const_pointer | |
21157 | data() const | |
21158 | { return const_pointer(this->_M_impl._M_start); } | |
21159 | void | |
21160 | push_back(const value_type& __x) | |
21161 | { | |
21162 | if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) | |
21163 | { | |
21164 | this->_M_impl.construct(this->_M_impl._M_finish, __x); | |
21165 | ++this->_M_impl._M_finish; | |
21166 | } | |
21167 | else | |
21168 | _M_insert_aux(end(), __x); | |
21169 | } | |
21170 | void | |
21171 | pop_back() | |
21172 | { | |
21173 | --this->_M_impl._M_finish; | |
21174 | this->_M_impl.destroy(this->_M_impl._M_finish); | |
21175 | } | |
21176 | iterator | |
21177 | insert(iterator __position, const value_type& __x); | |
21178 | void | |
21179 | insert(iterator __position, size_type __n, const value_type& __x) | |
21180 | { _M_fill_insert(__position, __n, __x); } | |
21181 | template<typename _InputIterator> | |
21182 | void | |
21183 | insert(iterator __position, _InputIterator __first, | |
21184 | _InputIterator __last) | |
21185 | { | |
21186 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
21187 | _M_insert_dispatch(__position, __first, __last, _Integral()); | |
21188 | } | |
21189 | iterator | |
21190 | erase(iterator __position); | |
21191 | iterator | |
21192 | erase(iterator __first, iterator __last); | |
21193 | void | |
21194 | swap(vector& __x) | |
21195 | { | |
21196 | std::swap(this->_M_impl._M_start, __x._M_impl._M_start); | |
21197 | std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); | |
21198 | std::swap(this->_M_impl._M_end_of_storage, | |
21199 | __x._M_impl._M_end_of_storage); | |
21200 | std::__alloc_swap<_Tp_alloc_type>::_S_do_it(_M_get_Tp_allocator(), | |
21201 | __x._M_get_Tp_allocator()); | |
21202 | } | |
21203 | void | |
21204 | clear() | |
21205 | { _M_erase_at_end(this->_M_impl._M_start); } | |
21206 | protected: | |
21207 | template<typename _ForwardIterator> | |
21208 | pointer | |
21209 | _M_allocate_and_copy(size_type __n, | |
21210 | _ForwardIterator __first, _ForwardIterator __last) | |
21211 | { | |
21212 | pointer __result = this->_M_allocate(__n); | |
21213 | try | |
21214 | { | |
21215 | std::__uninitialized_copy_a(__first, __last, __result, | |
21216 | _M_get_Tp_allocator()); | |
21217 | return __result; | |
21218 | } | |
21219 | catch(...) | |
21220 | { | |
21221 | _M_deallocate(__result, __n); | |
21222 | throw; | |
21223 | } | |
21224 | } | |
21225 | template<typename _Integer> | |
21226 | void | |
21227 | _M_initialize_dispatch(_Integer __n, _Integer __value, __true_type) | |
21228 | { | |
21229 | this->_M_impl._M_start = _M_allocate(static_cast<size_type>(__n)); | |
21230 | this->_M_impl._M_end_of_storage = | |
21231 | this->_M_impl._M_start + static_cast<size_type>(__n); | |
21232 | _M_fill_initialize(static_cast<size_type>(__n), __value); | |
21233 | } | |
21234 | template<typename _InputIterator> | |
21235 | void | |
21236 | _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
21237 | __false_type) | |
21238 | { | |
21239 | typedef typename std::iterator_traits<_InputIterator>:: | |
21240 | iterator_category _IterCategory; | |
21241 | _M_range_initialize(__first, __last, _IterCategory()); | |
21242 | } | |
21243 | template<typename _InputIterator> | |
21244 | void | |
21245 | _M_range_initialize(_InputIterator __first, | |
21246 | _InputIterator __last, std::input_iterator_tag) | |
21247 | { | |
21248 | for (; __first != __last; ++__first) | |
21249 | push_back(*__first); | |
21250 | } | |
21251 | template<typename _ForwardIterator> | |
21252 | void | |
21253 | _M_range_initialize(_ForwardIterator __first, | |
21254 | _ForwardIterator __last, std::forward_iterator_tag) | |
21255 | { | |
21256 | const size_type __n = std::distance(__first, __last); | |
21257 | this->_M_impl._M_start = this->_M_allocate(__n); | |
21258 | this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; | |
21259 | this->_M_impl._M_finish = | |
21260 | std::__uninitialized_copy_a(__first, __last, | |
21261 | this->_M_impl._M_start, | |
21262 | _M_get_Tp_allocator()); | |
21263 | } | |
21264 | void | |
21265 | _M_fill_initialize(size_type __n, const value_type& __value) | |
21266 | { | |
21267 | std::__uninitialized_fill_n_a(this->_M_impl._M_start, __n, __value, | |
21268 | _M_get_Tp_allocator()); | |
21269 | this->_M_impl._M_finish = this->_M_impl._M_end_of_storage; | |
21270 | } | |
21271 | template<typename _Integer> | |
21272 | void | |
21273 | _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
21274 | { _M_fill_assign(__n, __val); } | |
21275 | template<typename _InputIterator> | |
21276 | void | |
21277 | _M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
21278 | __false_type) | |
21279 | { | |
21280 | typedef typename std::iterator_traits<_InputIterator>:: | |
21281 | iterator_category _IterCategory; | |
21282 | _M_assign_aux(__first, __last, _IterCategory()); | |
21283 | } | |
21284 | template<typename _InputIterator> | |
21285 | void | |
21286 | _M_assign_aux(_InputIterator __first, _InputIterator __last, | |
21287 | std::input_iterator_tag); | |
21288 | template<typename _ForwardIterator> | |
21289 | void | |
21290 | _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
21291 | std::forward_iterator_tag); | |
21292 | void | |
21293 | _M_fill_assign(size_type __n, const value_type& __val); | |
21294 | template<typename _Integer> | |
21295 | void | |
21296 | _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __val, | |
21297 | __true_type) | |
21298 | { _M_fill_insert(__pos, __n, __val); } | |
21299 | template<typename _InputIterator> | |
21300 | void | |
21301 | _M_insert_dispatch(iterator __pos, _InputIterator __first, | |
21302 | _InputIterator __last, __false_type) | |
21303 | { | |
21304 | typedef typename std::iterator_traits<_InputIterator>:: | |
21305 | iterator_category _IterCategory; | |
21306 | _M_range_insert(__pos, __first, __last, _IterCategory()); | |
21307 | } | |
21308 | template<typename _InputIterator> | |
21309 | void | |
21310 | _M_range_insert(iterator __pos, _InputIterator __first, | |
21311 | _InputIterator __last, std::input_iterator_tag); | |
21312 | template<typename _ForwardIterator> | |
21313 | void | |
21314 | _M_range_insert(iterator __pos, _ForwardIterator __first, | |
21315 | _ForwardIterator __last, std::forward_iterator_tag); | |
21316 | void | |
21317 | _M_fill_insert(iterator __pos, size_type __n, const value_type& __x); | |
21318 | void | |
21319 | _M_insert_aux(iterator __position, const value_type& __x); | |
21320 | size_type | |
21321 | _M_check_len(size_type __n, const char* __s) const | |
21322 | { | |
21323 | if (max_size() - size() < __n) | |
21324 | __throw_length_error((__s)); | |
21325 | const size_type __len = size() + std::max(size(), __n); | |
21326 | return (__len < size() || __len > max_size()) ? max_size() : __len; | |
21327 | } | |
21328 | void | |
21329 | _M_erase_at_end(pointer __pos) | |
21330 | { | |
21331 | std::_Destroy(__pos, this->_M_impl._M_finish, _M_get_Tp_allocator()); | |
21332 | this->_M_impl._M_finish = __pos; | |
21333 | } | |
21334 | }; | |
21335 | template<typename _Tp, typename _Alloc> | |
21336 | inline bool | |
21337 | operator==(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
21338 | { return (__x.size() == __y.size() | |
21339 | && std::equal(__x.begin(), __x.end(), __y.begin())); } | |
21340 | template<typename _Tp, typename _Alloc> | |
21341 | inline bool | |
21342 | operator<(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
21343 | { return std::lexicographical_compare(__x.begin(), __x.end(), | |
21344 | __y.begin(), __y.end()); } | |
21345 | template<typename _Tp, typename _Alloc> | |
21346 | inline bool | |
21347 | operator!=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
21348 | { return !(__x == __y); } | |
21349 | template<typename _Tp, typename _Alloc> | |
21350 | inline bool | |
21351 | operator>(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
21352 | { return __y < __x; } | |
21353 | template<typename _Tp, typename _Alloc> | |
21354 | inline bool | |
21355 | operator<=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
21356 | { return !(__y < __x); } | |
21357 | template<typename _Tp, typename _Alloc> | |
21358 | inline bool | |
21359 | operator>=(const vector<_Tp, _Alloc>& __x, const vector<_Tp, _Alloc>& __y) | |
21360 | { return !(__x < __y); } | |
21361 | template<typename _Tp, typename _Alloc> | |
21362 | inline void | |
21363 | swap(vector<_Tp, _Alloc>& __x, vector<_Tp, _Alloc>& __y) | |
21364 | { __x.swap(__y); } | |
21365 | } | |
21366 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
21367 | typedef unsigned long _Bit_type; | |
21368 | enum { _S_word_bit = int(8 * sizeof(_Bit_type)) }; | |
21369 | struct _Bit_reference | |
21370 | { | |
21371 | _Bit_type * _M_p; | |
21372 | _Bit_type _M_mask; | |
21373 | _Bit_reference(_Bit_type * __x, _Bit_type __y) | |
21374 | : _M_p(__x), _M_mask(__y) { } | |
21375 | _Bit_reference() : _M_p(0), _M_mask(0) { } | |
21376 | operator bool() const | |
21377 | { return !!(*_M_p & _M_mask); } | |
21378 | _Bit_reference& | |
21379 | operator=(bool __x) | |
21380 | { | |
21381 | if (__x) | |
21382 | *_M_p |= _M_mask; | |
21383 | else | |
21384 | *_M_p &= ~_M_mask; | |
21385 | return *this; | |
21386 | } | |
21387 | _Bit_reference& | |
21388 | operator=(const _Bit_reference& __x) | |
21389 | { return *this = bool(__x); } | |
21390 | bool | |
21391 | operator==(const _Bit_reference& __x) const | |
21392 | { return bool(*this) == bool(__x); } | |
21393 | bool | |
21394 | operator<(const _Bit_reference& __x) const | |
21395 | { return !bool(*this) && bool(__x); } | |
21396 | void | |
21397 | flip() | |
21398 | { *_M_p ^= _M_mask; } | |
21399 | }; | |
21400 | struct _Bit_iterator_base | |
21401 | : public std::iterator<std::random_access_iterator_tag, bool> | |
21402 | { | |
21403 | _Bit_type * _M_p; | |
21404 | unsigned int _M_offset; | |
21405 | _Bit_iterator_base(_Bit_type * __x, unsigned int __y) | |
21406 | : _M_p(__x), _M_offset(__y) { } | |
21407 | void | |
21408 | _M_bump_up() | |
21409 | { | |
21410 | if (_M_offset++ == int(_S_word_bit) - 1) | |
21411 | { | |
21412 | _M_offset = 0; | |
21413 | ++_M_p; | |
21414 | } | |
21415 | } | |
21416 | void | |
21417 | _M_bump_down() | |
21418 | { | |
21419 | if (_M_offset-- == 0) | |
21420 | { | |
21421 | _M_offset = int(_S_word_bit) - 1; | |
21422 | --_M_p; | |
21423 | } | |
21424 | } | |
21425 | void | |
21426 | _M_incr(ptrdiff_t __i) | |
21427 | { | |
21428 | difference_type __n = __i + _M_offset; | |
21429 | _M_p += __n / int(_S_word_bit); | |
21430 | __n = __n % int(_S_word_bit); | |
21431 | if (__n < 0) | |
21432 | { | |
21433 | __n += int(_S_word_bit); | |
21434 | --_M_p; | |
21435 | } | |
21436 | _M_offset = static_cast<unsigned int>(__n); | |
21437 | } | |
21438 | bool | |
21439 | operator==(const _Bit_iterator_base& __i) const | |
21440 | { return _M_p == __i._M_p && _M_offset == __i._M_offset; } | |
21441 | bool | |
21442 | operator<(const _Bit_iterator_base& __i) const | |
21443 | { | |
21444 | return _M_p < __i._M_p | |
21445 | || (_M_p == __i._M_p && _M_offset < __i._M_offset); | |
21446 | } | |
21447 | bool | |
21448 | operator!=(const _Bit_iterator_base& __i) const | |
21449 | { return !(*this == __i); } | |
21450 | bool | |
21451 | operator>(const _Bit_iterator_base& __i) const | |
21452 | { return __i < *this; } | |
21453 | bool | |
21454 | operator<=(const _Bit_iterator_base& __i) const | |
21455 | { return !(__i < *this); } | |
21456 | bool | |
21457 | operator>=(const _Bit_iterator_base& __i) const | |
21458 | { return !(*this < __i); } | |
21459 | }; | |
21460 | inline ptrdiff_t | |
21461 | operator-(const _Bit_iterator_base& __x, const _Bit_iterator_base& __y) | |
21462 | { | |
21463 | return (int(_S_word_bit) * (__x._M_p - __y._M_p) | |
21464 | + __x._M_offset - __y._M_offset); | |
21465 | } | |
21466 | struct _Bit_iterator : public _Bit_iterator_base | |
21467 | { | |
21468 | typedef _Bit_reference reference; | |
21469 | typedef _Bit_reference* pointer; | |
21470 | typedef _Bit_iterator iterator; | |
21471 | _Bit_iterator() : _Bit_iterator_base(0, 0) { } | |
21472 | _Bit_iterator(_Bit_type * __x, unsigned int __y) | |
21473 | : _Bit_iterator_base(__x, __y) { } | |
21474 | reference | |
21475 | operator*() const | |
21476 | { return reference(_M_p, 1UL << _M_offset); } | |
21477 | iterator& | |
21478 | operator++() | |
21479 | { | |
21480 | _M_bump_up(); | |
21481 | return *this; | |
21482 | } | |
21483 | iterator | |
21484 | operator++(int) | |
21485 | { | |
21486 | iterator __tmp = *this; | |
21487 | _M_bump_up(); | |
21488 | return __tmp; | |
21489 | } | |
21490 | iterator& | |
21491 | operator--() | |
21492 | { | |
21493 | _M_bump_down(); | |
21494 | return *this; | |
21495 | } | |
21496 | iterator | |
21497 | operator--(int) | |
21498 | { | |
21499 | iterator __tmp = *this; | |
21500 | _M_bump_down(); | |
21501 | return __tmp; | |
21502 | } | |
21503 | iterator& | |
21504 | operator+=(difference_type __i) | |
21505 | { | |
21506 | _M_incr(__i); | |
21507 | return *this; | |
21508 | } | |
21509 | iterator& | |
21510 | operator-=(difference_type __i) | |
21511 | { | |
21512 | *this += -__i; | |
21513 | return *this; | |
21514 | } | |
21515 | iterator | |
21516 | operator+(difference_type __i) const | |
21517 | { | |
21518 | iterator __tmp = *this; | |
21519 | return __tmp += __i; | |
21520 | } | |
21521 | iterator | |
21522 | operator-(difference_type __i) const | |
21523 | { | |
21524 | iterator __tmp = *this; | |
21525 | return __tmp -= __i; | |
21526 | } | |
21527 | reference | |
21528 | operator[](difference_type __i) const | |
21529 | { return *(*this + __i); } | |
21530 | }; | |
21531 | inline _Bit_iterator | |
21532 | operator+(ptrdiff_t __n, const _Bit_iterator& __x) | |
21533 | { return __x + __n; } | |
21534 | struct _Bit_const_iterator : public _Bit_iterator_base | |
21535 | { | |
21536 | typedef bool reference; | |
21537 | typedef bool const_reference; | |
21538 | typedef const bool* pointer; | |
21539 | typedef _Bit_const_iterator const_iterator; | |
21540 | _Bit_const_iterator() : _Bit_iterator_base(0, 0) { } | |
21541 | _Bit_const_iterator(_Bit_type * __x, unsigned int __y) | |
21542 | : _Bit_iterator_base(__x, __y) { } | |
21543 | _Bit_const_iterator(const _Bit_iterator& __x) | |
21544 | : _Bit_iterator_base(__x._M_p, __x._M_offset) { } | |
21545 | const_reference | |
21546 | operator*() const | |
21547 | { return _Bit_reference(_M_p, 1UL << _M_offset); } | |
21548 | const_iterator& | |
21549 | operator++() | |
21550 | { | |
21551 | _M_bump_up(); | |
21552 | return *this; | |
21553 | } | |
21554 | const_iterator | |
21555 | operator++(int) | |
21556 | { | |
21557 | const_iterator __tmp = *this; | |
21558 | _M_bump_up(); | |
21559 | return __tmp; | |
21560 | } | |
21561 | const_iterator& | |
21562 | operator--() | |
21563 | { | |
21564 | _M_bump_down(); | |
21565 | return *this; | |
21566 | } | |
21567 | const_iterator | |
21568 | operator--(int) | |
21569 | { | |
21570 | const_iterator __tmp = *this; | |
21571 | _M_bump_down(); | |
21572 | return __tmp; | |
21573 | } | |
21574 | const_iterator& | |
21575 | operator+=(difference_type __i) | |
21576 | { | |
21577 | _M_incr(__i); | |
21578 | return *this; | |
21579 | } | |
21580 | const_iterator& | |
21581 | operator-=(difference_type __i) | |
21582 | { | |
21583 | *this += -__i; | |
21584 | return *this; | |
21585 | } | |
21586 | const_iterator | |
21587 | operator+(difference_type __i) const | |
21588 | { | |
21589 | const_iterator __tmp = *this; | |
21590 | return __tmp += __i; | |
21591 | } | |
21592 | const_iterator | |
21593 | operator-(difference_type __i) const | |
21594 | { | |
21595 | const_iterator __tmp = *this; | |
21596 | return __tmp -= __i; | |
21597 | } | |
21598 | const_reference | |
21599 | operator[](difference_type __i) const | |
21600 | { return *(*this + __i); } | |
21601 | }; | |
21602 | inline _Bit_const_iterator | |
21603 | operator+(ptrdiff_t __n, const _Bit_const_iterator& __x) | |
21604 | { return __x + __n; } | |
21605 | inline void | |
21606 | __fill_bvector(_Bit_iterator __first, _Bit_iterator __last, bool __x) | |
21607 | { | |
21608 | for (; __first != __last; ++__first) | |
21609 | *__first = __x; | |
21610 | } | |
21611 | inline void | |
21612 | fill(_Bit_iterator __first, _Bit_iterator __last, const bool& __x) | |
21613 | { | |
21614 | if (__first._M_p != __last._M_p) | |
21615 | { | |
21616 | std::fill(__first._M_p + 1, __last._M_p, __x ? ~0 : 0); | |
21617 | __fill_bvector(__first, _Bit_iterator(__first._M_p + 1, 0), __x); | |
21618 | __fill_bvector(_Bit_iterator(__last._M_p, 0), __last, __x); | |
21619 | } | |
21620 | else | |
21621 | __fill_bvector(__first, __last, __x); | |
21622 | } | |
21623 | template<typename _Alloc> | |
21624 | struct _Bvector_base | |
21625 | { | |
21626 | typedef typename _Alloc::template rebind<_Bit_type>::other | |
21627 | _Bit_alloc_type; | |
21628 | struct _Bvector_impl | |
21629 | : public _Bit_alloc_type | |
21630 | { | |
21631 | _Bit_iterator _M_start; | |
21632 | _Bit_iterator _M_finish; | |
21633 | _Bit_type* _M_end_of_storage; | |
21634 | _Bvector_impl() | |
21635 | : _Bit_alloc_type(), _M_start(), _M_finish(), _M_end_of_storage(0) | |
21636 | { } | |
21637 | _Bvector_impl(const _Bit_alloc_type& __a) | |
21638 | : _Bit_alloc_type(__a), _M_start(), _M_finish(), _M_end_of_storage(0) | |
21639 | { } | |
21640 | }; | |
21641 | public: | |
21642 | typedef _Alloc allocator_type; | |
21643 | _Bit_alloc_type& | |
21644 | _M_get_Bit_allocator() | |
21645 | { return *static_cast<_Bit_alloc_type*>(&this->_M_impl); } | |
21646 | const _Bit_alloc_type& | |
21647 | _M_get_Bit_allocator() const | |
21648 | { return *static_cast<const _Bit_alloc_type*>(&this->_M_impl); } | |
21649 | allocator_type | |
21650 | get_allocator() const | |
21651 | { return allocator_type(_M_get_Bit_allocator()); } | |
21652 | _Bvector_base() | |
21653 | : _M_impl() { } | |
21654 | _Bvector_base(const allocator_type& __a) | |
21655 | : _M_impl(__a) { } | |
21656 | ~_Bvector_base() | |
21657 | { this->_M_deallocate(); } | |
21658 | protected: | |
21659 | _Bvector_impl _M_impl; | |
21660 | _Bit_type* | |
21661 | _M_allocate(size_t __n) | |
21662 | { return _M_impl.allocate((__n + int(_S_word_bit) - 1) | |
21663 | / int(_S_word_bit)); } | |
21664 | void | |
21665 | _M_deallocate() | |
21666 | { | |
21667 | if (_M_impl._M_start._M_p) | |
21668 | _M_impl.deallocate(_M_impl._M_start._M_p, | |
21669 | _M_impl._M_end_of_storage - _M_impl._M_start._M_p); | |
21670 | } | |
21671 | }; | |
21672 | } | |
21673 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
21674 | template<typename _Alloc> | |
21675 | class vector<bool, _Alloc> : protected _Bvector_base<_Alloc> | |
21676 | { | |
21677 | typedef _Bvector_base<_Alloc> _Base; | |
21678 | public: | |
21679 | typedef bool value_type; | |
21680 | typedef size_t size_type; | |
21681 | typedef ptrdiff_t difference_type; | |
21682 | typedef _Bit_reference reference; | |
21683 | typedef bool const_reference; | |
21684 | typedef _Bit_reference* pointer; | |
21685 | typedef const bool* const_pointer; | |
21686 | typedef _Bit_iterator iterator; | |
21687 | typedef _Bit_const_iterator const_iterator; | |
21688 | typedef std::reverse_iterator<const_iterator> const_reverse_iterator; | |
21689 | typedef std::reverse_iterator<iterator> reverse_iterator; | |
21690 | typedef _Alloc allocator_type; | |
21691 | allocator_type get_allocator() const | |
21692 | { return _Base::get_allocator(); } | |
21693 | protected: | |
21694 | using _Base::_M_allocate; | |
21695 | using _Base::_M_deallocate; | |
21696 | using _Base::_M_get_Bit_allocator; | |
21697 | public: | |
21698 | vector() | |
21699 | : _Base() { } | |
21700 | explicit | |
21701 | vector(const allocator_type& __a) | |
21702 | : _Base(__a) { } | |
21703 | explicit | |
21704 | vector(size_type __n, const bool& __value = bool(), | |
21705 | const allocator_type& __a = allocator_type()) | |
21706 | : _Base(__a) | |
21707 | { | |
21708 | _M_initialize(__n); | |
21709 | std::fill(this->_M_impl._M_start._M_p, this->_M_impl._M_end_of_storage, | |
21710 | __value ? ~0 : 0); | |
21711 | } | |
21712 | vector(const vector& __x) | |
21713 | : _Base(__x._M_get_Bit_allocator()) | |
21714 | { | |
21715 | _M_initialize(__x.size()); | |
21716 | _M_copy_aligned(__x.begin(), __x.end(), this->_M_impl._M_start); | |
21717 | } | |
21718 | template<typename _InputIterator> | |
21719 | vector(_InputIterator __first, _InputIterator __last, | |
21720 | const allocator_type& __a = allocator_type()) | |
21721 | : _Base(__a) | |
21722 | { | |
21723 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
21724 | _M_initialize_dispatch(__first, __last, _Integral()); | |
21725 | } | |
21726 | ~vector() { } | |
21727 | vector& | |
21728 | operator=(const vector& __x) | |
21729 | { | |
21730 | if (&__x == this) | |
21731 | return *this; | |
21732 | if (__x.size() > capacity()) | |
21733 | { | |
21734 | this->_M_deallocate(); | |
21735 | _M_initialize(__x.size()); | |
21736 | } | |
21737 | this->_M_impl._M_finish = _M_copy_aligned(__x.begin(), __x.end(), | |
21738 | begin()); | |
21739 | return *this; | |
21740 | } | |
21741 | void | |
21742 | assign(size_type __n, const bool& __x) | |
21743 | { _M_fill_assign(__n, __x); } | |
21744 | template<typename _InputIterator> | |
21745 | void | |
21746 | assign(_InputIterator __first, _InputIterator __last) | |
21747 | { | |
21748 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
21749 | _M_assign_dispatch(__first, __last, _Integral()); | |
21750 | } | |
21751 | iterator | |
21752 | begin() | |
21753 | { return this->_M_impl._M_start; } | |
21754 | const_iterator | |
21755 | begin() const | |
21756 | { return this->_M_impl._M_start; } | |
21757 | iterator | |
21758 | end() | |
21759 | { return this->_M_impl._M_finish; } | |
21760 | const_iterator | |
21761 | end() const | |
21762 | { return this->_M_impl._M_finish; } | |
21763 | reverse_iterator | |
21764 | rbegin() | |
21765 | { return reverse_iterator(end()); } | |
21766 | const_reverse_iterator | |
21767 | rbegin() const | |
21768 | { return const_reverse_iterator(end()); } | |
21769 | reverse_iterator | |
21770 | rend() | |
21771 | { return reverse_iterator(begin()); } | |
21772 | const_reverse_iterator | |
21773 | rend() const | |
21774 | { return const_reverse_iterator(begin()); } | |
21775 | size_type | |
21776 | size() const | |
21777 | { return size_type(end() - begin()); } | |
21778 | size_type | |
21779 | max_size() const | |
21780 | { | |
21781 | const size_type __isize = | |
21782 | __gnu_cxx::__numeric_traits<difference_type>::__max | |
21783 | - int(_S_word_bit) + 1; | |
21784 | const size_type __asize = _M_get_Bit_allocator().max_size(); | |
21785 | return (__asize <= __isize / int(_S_word_bit) | |
21786 | ? __asize * int(_S_word_bit) : __isize); | |
21787 | } | |
21788 | size_type | |
21789 | capacity() const | |
21790 | { return size_type(const_iterator(this->_M_impl._M_end_of_storage, 0) | |
21791 | - begin()); } | |
21792 | bool | |
21793 | empty() const | |
21794 | { return begin() == end(); } | |
21795 | reference | |
21796 | operator[](size_type __n) | |
21797 | { | |
21798 | return *iterator(this->_M_impl._M_start._M_p | |
21799 | + __n / int(_S_word_bit), __n % int(_S_word_bit)); | |
21800 | } | |
21801 | const_reference | |
21802 | operator[](size_type __n) const | |
21803 | { | |
21804 | return *const_iterator(this->_M_impl._M_start._M_p | |
21805 | + __n / int(_S_word_bit), __n % int(_S_word_bit)); | |
21806 | } | |
21807 | protected: | |
21808 | void | |
21809 | _M_range_check(size_type __n) const | |
21810 | { | |
21811 | if (__n >= this->size()) | |
21812 | __throw_out_of_range(("vector<bool>::_M_range_check")); | |
21813 | } | |
21814 | public: | |
21815 | reference | |
21816 | at(size_type __n) | |
21817 | { _M_range_check(__n); return (*this)[__n]; } | |
21818 | const_reference | |
21819 | at(size_type __n) const | |
21820 | { _M_range_check(__n); return (*this)[__n]; } | |
21821 | void | |
21822 | reserve(size_type __n); | |
21823 | reference | |
21824 | front() | |
21825 | { return *begin(); } | |
21826 | const_reference | |
21827 | front() const | |
21828 | { return *begin(); } | |
21829 | reference | |
21830 | back() | |
21831 | { return *(end() - 1); } | |
21832 | const_reference | |
21833 | back() const | |
21834 | { return *(end() - 1); } | |
21835 | void | |
21836 | data() { } | |
21837 | void | |
21838 | push_back(bool __x) | |
21839 | { | |
21840 | if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage) | |
21841 | *this->_M_impl._M_finish++ = __x; | |
21842 | else | |
21843 | _M_insert_aux(end(), __x); | |
21844 | } | |
21845 | void | |
21846 | swap(vector& __x) | |
21847 | { | |
21848 | std::swap(this->_M_impl._M_start, __x._M_impl._M_start); | |
21849 | std::swap(this->_M_impl._M_finish, __x._M_impl._M_finish); | |
21850 | std::swap(this->_M_impl._M_end_of_storage, | |
21851 | __x._M_impl._M_end_of_storage); | |
21852 | std::__alloc_swap<typename _Base::_Bit_alloc_type>:: | |
21853 | _S_do_it(_M_get_Bit_allocator(), __x._M_get_Bit_allocator()); | |
21854 | } | |
21855 | static void | |
21856 | swap(reference __x, reference __y) | |
21857 | { | |
21858 | bool __tmp = __x; | |
21859 | __x = __y; | |
21860 | __y = __tmp; | |
21861 | } | |
21862 | iterator | |
21863 | insert(iterator __position, const bool& __x = bool()) | |
21864 | { | |
21865 | const difference_type __n = __position - begin(); | |
21866 | if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage | |
21867 | && __position == end()) | |
21868 | *this->_M_impl._M_finish++ = __x; | |
21869 | else | |
21870 | _M_insert_aux(__position, __x); | |
21871 | return begin() + __n; | |
21872 | } | |
21873 | template<typename _InputIterator> | |
21874 | void | |
21875 | insert(iterator __position, | |
21876 | _InputIterator __first, _InputIterator __last) | |
21877 | { | |
21878 | typedef typename std::__is_integer<_InputIterator>::__type _Integral; | |
21879 | _M_insert_dispatch(__position, __first, __last, _Integral()); | |
21880 | } | |
21881 | void | |
21882 | insert(iterator __position, size_type __n, const bool& __x) | |
21883 | { _M_fill_insert(__position, __n, __x); } | |
21884 | void | |
21885 | pop_back() | |
21886 | { --this->_M_impl._M_finish; } | |
21887 | iterator | |
21888 | erase(iterator __position) | |
21889 | { | |
21890 | if (__position + 1 != end()) | |
21891 | std::copy(__position + 1, end(), __position); | |
21892 | --this->_M_impl._M_finish; | |
21893 | return __position; | |
21894 | } | |
21895 | iterator | |
21896 | erase(iterator __first, iterator __last) | |
21897 | { | |
21898 | _M_erase_at_end(std::copy(__last, end(), __first)); | |
21899 | return __first; | |
21900 | } | |
21901 | void | |
21902 | resize(size_type __new_size, bool __x = bool()) | |
21903 | { | |
21904 | if (__new_size < size()) | |
21905 | _M_erase_at_end(begin() + difference_type(__new_size)); | |
21906 | else | |
21907 | insert(end(), __new_size - size(), __x); | |
21908 | } | |
21909 | void | |
21910 | flip() | |
21911 | { | |
21912 | for (_Bit_type * __p = this->_M_impl._M_start._M_p; | |
21913 | __p != this->_M_impl._M_end_of_storage; ++__p) | |
21914 | *__p = ~*__p; | |
21915 | } | |
21916 | void | |
21917 | clear() | |
21918 | { _M_erase_at_end(begin()); } | |
21919 | protected: | |
21920 | iterator | |
21921 | _M_copy_aligned(const_iterator __first, const_iterator __last, | |
21922 | iterator __result) | |
21923 | { | |
21924 | _Bit_type* __q = std::copy(__first._M_p, __last._M_p, __result._M_p); | |
21925 | return std::copy(const_iterator(__last._M_p, 0), __last, | |
21926 | iterator(__q, 0)); | |
21927 | } | |
21928 | void | |
21929 | _M_initialize(size_type __n) | |
21930 | { | |
21931 | _Bit_type* __q = this->_M_allocate(__n); | |
21932 | this->_M_impl._M_end_of_storage = (__q | |
21933 | + ((__n + int(_S_word_bit) - 1) | |
21934 | / int(_S_word_bit))); | |
21935 | this->_M_impl._M_start = iterator(__q, 0); | |
21936 | this->_M_impl._M_finish = this->_M_impl._M_start + difference_type(__n); | |
21937 | } | |
21938 | template<typename _Integer> | |
21939 | void | |
21940 | _M_initialize_dispatch(_Integer __n, _Integer __x, __true_type) | |
21941 | { | |
21942 | _M_initialize(static_cast<size_type>(__n)); | |
21943 | std::fill(this->_M_impl._M_start._M_p, | |
21944 | this->_M_impl._M_end_of_storage, __x ? ~0 : 0); | |
21945 | } | |
21946 | template<typename _InputIterator> | |
21947 | void | |
21948 | _M_initialize_dispatch(_InputIterator __first, _InputIterator __last, | |
21949 | __false_type) | |
21950 | { _M_initialize_range(__first, __last, | |
21951 | std::__iterator_category(__first)); } | |
21952 | template<typename _InputIterator> | |
21953 | void | |
21954 | _M_initialize_range(_InputIterator __first, _InputIterator __last, | |
21955 | std::input_iterator_tag) | |
21956 | { | |
21957 | for (; __first != __last; ++__first) | |
21958 | push_back(*__first); | |
21959 | } | |
21960 | template<typename _ForwardIterator> | |
21961 | void | |
21962 | _M_initialize_range(_ForwardIterator __first, _ForwardIterator __last, | |
21963 | std::forward_iterator_tag) | |
21964 | { | |
21965 | const size_type __n = std::distance(__first, __last); | |
21966 | _M_initialize(__n); | |
21967 | std::copy(__first, __last, this->_M_impl._M_start); | |
21968 | } | |
21969 | template<typename _Integer> | |
21970 | void | |
21971 | _M_assign_dispatch(_Integer __n, _Integer __val, __true_type) | |
21972 | { _M_fill_assign(__n, __val); } | |
21973 | template<class _InputIterator> | |
21974 | void | |
21975 | _M_assign_dispatch(_InputIterator __first, _InputIterator __last, | |
21976 | __false_type) | |
21977 | { _M_assign_aux(__first, __last, std::__iterator_category(__first)); } | |
21978 | void | |
21979 | _M_fill_assign(size_t __n, bool __x) | |
21980 | { | |
21981 | if (__n > size()) | |
21982 | { | |
21983 | std::fill(this->_M_impl._M_start._M_p, | |
21984 | this->_M_impl._M_end_of_storage, __x ? ~0 : 0); | |
21985 | insert(end(), __n - size(), __x); | |
21986 | } | |
21987 | else | |
21988 | { | |
21989 | _M_erase_at_end(begin() + __n); | |
21990 | std::fill(this->_M_impl._M_start._M_p, | |
21991 | this->_M_impl._M_end_of_storage, __x ? ~0 : 0); | |
21992 | } | |
21993 | } | |
21994 | template<typename _InputIterator> | |
21995 | void | |
21996 | _M_assign_aux(_InputIterator __first, _InputIterator __last, | |
21997 | std::input_iterator_tag) | |
21998 | { | |
21999 | iterator __cur = begin(); | |
22000 | for (; __first != __last && __cur != end(); ++__cur, ++__first) | |
22001 | *__cur = *__first; | |
22002 | if (__first == __last) | |
22003 | _M_erase_at_end(__cur); | |
22004 | else | |
22005 | insert(end(), __first, __last); | |
22006 | } | |
22007 | template<typename _ForwardIterator> | |
22008 | void | |
22009 | _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
22010 | std::forward_iterator_tag) | |
22011 | { | |
22012 | const size_type __len = std::distance(__first, __last); | |
22013 | if (__len < size()) | |
22014 | _M_erase_at_end(std::copy(__first, __last, begin())); | |
22015 | else | |
22016 | { | |
22017 | _ForwardIterator __mid = __first; | |
22018 | std::advance(__mid, size()); | |
22019 | std::copy(__first, __mid, begin()); | |
22020 | insert(end(), __mid, __last); | |
22021 | } | |
22022 | } | |
22023 | template<typename _Integer> | |
22024 | void | |
22025 | _M_insert_dispatch(iterator __pos, _Integer __n, _Integer __x, | |
22026 | __true_type) | |
22027 | { _M_fill_insert(__pos, __n, __x); } | |
22028 | template<typename _InputIterator> | |
22029 | void | |
22030 | _M_insert_dispatch(iterator __pos, | |
22031 | _InputIterator __first, _InputIterator __last, | |
22032 | __false_type) | |
22033 | { _M_insert_range(__pos, __first, __last, | |
22034 | std::__iterator_category(__first)); } | |
22035 | void | |
22036 | _M_fill_insert(iterator __position, size_type __n, bool __x); | |
22037 | template<typename _InputIterator> | |
22038 | void | |
22039 | _M_insert_range(iterator __pos, _InputIterator __first, | |
22040 | _InputIterator __last, std::input_iterator_tag) | |
22041 | { | |
22042 | for (; __first != __last; ++__first) | |
22043 | { | |
22044 | __pos = insert(__pos, *__first); | |
22045 | ++__pos; | |
22046 | } | |
22047 | } | |
22048 | template<typename _ForwardIterator> | |
22049 | void | |
22050 | _M_insert_range(iterator __position, _ForwardIterator __first, | |
22051 | _ForwardIterator __last, std::forward_iterator_tag); | |
22052 | void | |
22053 | _M_insert_aux(iterator __position, bool __x); | |
22054 | size_type | |
22055 | _M_check_len(size_type __n, const char* __s) const | |
22056 | { | |
22057 | if (max_size() - size() < __n) | |
22058 | __throw_length_error((__s)); | |
22059 | const size_type __len = size() + std::max(size(), __n); | |
22060 | return (__len < size() || __len > max_size()) ? max_size() : __len; | |
22061 | } | |
22062 | void | |
22063 | _M_erase_at_end(iterator __pos) | |
22064 | { this->_M_impl._M_finish = __pos; } | |
22065 | }; | |
22066 | } | |
22067 | namespace std __attribute__ ((__visibility__ ("default"))) { | |
22068 | template<typename _Tp, typename _Alloc> | |
22069 | void | |
22070 | vector<_Tp, _Alloc>:: | |
22071 | reserve(size_type __n) | |
22072 | { | |
22073 | if (__n > this->max_size()) | |
22074 | __throw_length_error(("vector::reserve")); | |
22075 | if (this->capacity() < __n) | |
22076 | { | |
22077 | const size_type __old_size = size(); | |
22078 | pointer __tmp = _M_allocate_and_copy(__n, | |
22079 | (this->_M_impl._M_start), | |
22080 | (this->_M_impl._M_finish)); | |
22081 | std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
22082 | _M_get_Tp_allocator()); | |
22083 | _M_deallocate(this->_M_impl._M_start, | |
22084 | this->_M_impl._M_end_of_storage | |
22085 | - this->_M_impl._M_start); | |
22086 | this->_M_impl._M_start = __tmp; | |
22087 | this->_M_impl._M_finish = __tmp + __old_size; | |
22088 | this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __n; | |
22089 | } | |
22090 | } | |
22091 | template<typename _Tp, typename _Alloc> | |
22092 | typename vector<_Tp, _Alloc>::iterator | |
22093 | vector<_Tp, _Alloc>:: | |
22094 | insert(iterator __position, const value_type& __x) | |
22095 | { | |
22096 | const size_type __n = __position - begin(); | |
22097 | if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage | |
22098 | && __position == end()) | |
22099 | { | |
22100 | this->_M_impl.construct(this->_M_impl._M_finish, __x); | |
22101 | ++this->_M_impl._M_finish; | |
22102 | } | |
22103 | else | |
22104 | { | |
22105 | _M_insert_aux(__position, __x); | |
22106 | } | |
22107 | return iterator(this->_M_impl._M_start + __n); | |
22108 | } | |
22109 | template<typename _Tp, typename _Alloc> | |
22110 | typename vector<_Tp, _Alloc>::iterator | |
22111 | vector<_Tp, _Alloc>:: | |
22112 | erase(iterator __position) | |
22113 | { | |
22114 | if (__position + 1 != end()) | |
22115 | std::copy(__position + 1, end(), __position); | |
22116 | --this->_M_impl._M_finish; | |
22117 | this->_M_impl.destroy(this->_M_impl._M_finish); | |
22118 | return __position; | |
22119 | } | |
22120 | template<typename _Tp, typename _Alloc> | |
22121 | typename vector<_Tp, _Alloc>::iterator | |
22122 | vector<_Tp, _Alloc>:: | |
22123 | erase(iterator __first, iterator __last) | |
22124 | { | |
22125 | if (__last != end()) | |
22126 | std::copy(__last, end(), __first); | |
22127 | _M_erase_at_end(__first.base() + (end() - __last)); | |
22128 | return __first; | |
22129 | } | |
22130 | template<typename _Tp, typename _Alloc> | |
22131 | vector<_Tp, _Alloc>& | |
22132 | vector<_Tp, _Alloc>:: | |
22133 | operator=(const vector<_Tp, _Alloc>& __x) | |
22134 | { | |
22135 | if (&__x != this) | |
22136 | { | |
22137 | const size_type __xlen = __x.size(); | |
22138 | if (__xlen > capacity()) | |
22139 | { | |
22140 | pointer __tmp = _M_allocate_and_copy(__xlen, __x.begin(), | |
22141 | __x.end()); | |
22142 | std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
22143 | _M_get_Tp_allocator()); | |
22144 | _M_deallocate(this->_M_impl._M_start, | |
22145 | this->_M_impl._M_end_of_storage | |
22146 | - this->_M_impl._M_start); | |
22147 | this->_M_impl._M_start = __tmp; | |
22148 | this->_M_impl._M_end_of_storage = this->_M_impl._M_start + __xlen; | |
22149 | } | |
22150 | else if (size() >= __xlen) | |
22151 | { | |
22152 | std::_Destroy(std::copy(__x.begin(), __x.end(), begin()), | |
22153 | end(), _M_get_Tp_allocator()); | |
22154 | } | |
22155 | else | |
22156 | { | |
22157 | std::copy(__x._M_impl._M_start, __x._M_impl._M_start + size(), | |
22158 | this->_M_impl._M_start); | |
22159 | std::__uninitialized_copy_a(__x._M_impl._M_start + size(), | |
22160 | __x._M_impl._M_finish, | |
22161 | this->_M_impl._M_finish, | |
22162 | _M_get_Tp_allocator()); | |
22163 | } | |
22164 | this->_M_impl._M_finish = this->_M_impl._M_start + __xlen; | |
22165 | } | |
22166 | return *this; | |
22167 | } | |
22168 | template<typename _Tp, typename _Alloc> | |
22169 | void | |
22170 | vector<_Tp, _Alloc>:: | |
22171 | _M_fill_assign(size_t __n, const value_type& __val) | |
22172 | { | |
22173 | if (__n > capacity()) | |
22174 | { | |
22175 | vector __tmp(__n, __val, _M_get_Tp_allocator()); | |
22176 | __tmp.swap(*this); | |
22177 | } | |
22178 | else if (__n > size()) | |
22179 | { | |
22180 | std::fill(begin(), end(), __val); | |
22181 | std::__uninitialized_fill_n_a(this->_M_impl._M_finish, | |
22182 | __n - size(), __val, | |
22183 | _M_get_Tp_allocator()); | |
22184 | this->_M_impl._M_finish += __n - size(); | |
22185 | } | |
22186 | else | |
22187 | _M_erase_at_end(std::fill_n(this->_M_impl._M_start, __n, __val)); | |
22188 | } | |
22189 | template<typename _Tp, typename _Alloc> | |
22190 | template<typename _InputIterator> | |
22191 | void | |
22192 | vector<_Tp, _Alloc>:: | |
22193 | _M_assign_aux(_InputIterator __first, _InputIterator __last, | |
22194 | std::input_iterator_tag) | |
22195 | { | |
22196 | pointer __cur(this->_M_impl._M_start); | |
22197 | for (; __first != __last && __cur != this->_M_impl._M_finish; | |
22198 | ++__cur, ++__first) | |
22199 | *__cur = *__first; | |
22200 | if (__first == __last) | |
22201 | _M_erase_at_end(__cur); | |
22202 | else | |
22203 | insert(end(), __first, __last); | |
22204 | } | |
22205 | template<typename _Tp, typename _Alloc> | |
22206 | template<typename _ForwardIterator> | |
22207 | void | |
22208 | vector<_Tp, _Alloc>:: | |
22209 | _M_assign_aux(_ForwardIterator __first, _ForwardIterator __last, | |
22210 | std::forward_iterator_tag) | |
22211 | { | |
22212 | const size_type __len = std::distance(__first, __last); | |
22213 | if (__len > capacity()) | |
22214 | { | |
22215 | pointer __tmp(_M_allocate_and_copy(__len, __first, __last)); | |
22216 | std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
22217 | _M_get_Tp_allocator()); | |
22218 | _M_deallocate(this->_M_impl._M_start, | |
22219 | this->_M_impl._M_end_of_storage | |
22220 | - this->_M_impl._M_start); | |
22221 | this->_M_impl._M_start = __tmp; | |
22222 | this->_M_impl._M_finish = this->_M_impl._M_start + __len; | |
22223 | this->_M_impl._M_end_of_storage = this->_M_impl._M_finish; | |
22224 | } | |
22225 | else if (size() >= __len) | |
22226 | _M_erase_at_end(std::copy(__first, __last, this->_M_impl._M_start)); | |
22227 | else | |
22228 | { | |
22229 | _ForwardIterator __mid = __first; | |
22230 | std::advance(__mid, size()); | |
22231 | std::copy(__first, __mid, this->_M_impl._M_start); | |
22232 | this->_M_impl._M_finish = | |
22233 | std::__uninitialized_copy_a(__mid, __last, | |
22234 | this->_M_impl._M_finish, | |
22235 | _M_get_Tp_allocator()); | |
22236 | } | |
22237 | } | |
22238 | template<typename _Tp, typename _Alloc> | |
22239 | void | |
22240 | vector<_Tp, _Alloc>:: | |
22241 | _M_insert_aux(iterator __position, const _Tp& __x) | |
22242 | { | |
22243 | if (this->_M_impl._M_finish != this->_M_impl._M_end_of_storage) | |
22244 | { | |
22245 | this->_M_impl.construct(this->_M_impl._M_finish, | |
22246 | (*(this->_M_impl._M_finish - 1))); | |
22247 | ++this->_M_impl._M_finish; | |
22248 | _Tp __x_copy = __x; | |
22249 | std::copy_backward(__position.base(), this->_M_impl._M_finish - 2, this->_M_impl._M_finish - 1); | |
22250 | *__position = __x_copy; | |
22251 | } | |
22252 | else | |
22253 | { | |
22254 | const size_type __len = | |
22255 | _M_check_len(size_type(1), "vector::_M_insert_aux"); | |
22256 | pointer __new_start(this->_M_allocate(__len)); | |
22257 | pointer __new_finish(__new_start); | |
22258 | try | |
22259 | { | |
22260 | __new_finish = | |
22261 | std::__uninitialized_move_a(this->_M_impl._M_start, | |
22262 | __position.base(), __new_start, | |
22263 | _M_get_Tp_allocator()); | |
22264 | this->_M_impl.construct(__new_finish, __x); | |
22265 | ++__new_finish; | |
22266 | __new_finish = | |
22267 | std::__uninitialized_move_a(__position.base(), | |
22268 | this->_M_impl._M_finish, | |
22269 | __new_finish, | |
22270 | _M_get_Tp_allocator()); | |
22271 | } | |
22272 | catch(...) | |
22273 | { | |
22274 | std::_Destroy(__new_start, __new_finish, _M_get_Tp_allocator()); | |
22275 | _M_deallocate(__new_start, __len); | |
22276 | throw; | |
22277 | } | |
22278 | std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
22279 | _M_get_Tp_allocator()); | |
22280 | _M_deallocate(this->_M_impl._M_start, | |
22281 | this->_M_impl._M_end_of_storage | |
22282 | - this->_M_impl._M_start); | |
22283 | this->_M_impl._M_start = __new_start; | |
22284 | this->_M_impl._M_finish = __new_finish; | |
22285 | this->_M_impl._M_end_of_storage = __new_start + __len; | |
22286 | } | |
22287 | } | |
22288 | template<typename _Tp, typename _Alloc> | |
22289 | void | |
22290 | vector<_Tp, _Alloc>:: | |
22291 | _M_fill_insert(iterator __position, size_type __n, const value_type& __x) | |
22292 | { | |
22293 | if (__n != 0) | |
22294 | { | |
22295 | if (size_type(this->_M_impl._M_end_of_storage | |
22296 | - this->_M_impl._M_finish) >= __n) | |
22297 | { | |
22298 | value_type __x_copy = __x; | |
22299 | const size_type __elems_after = end() - __position; | |
22300 | pointer __old_finish(this->_M_impl._M_finish); | |
22301 | if (__elems_after > __n) | |
22302 | { | |
22303 | std::__uninitialized_move_a(this->_M_impl._M_finish - __n, | |
22304 | this->_M_impl._M_finish, | |
22305 | this->_M_impl._M_finish, | |
22306 | _M_get_Tp_allocator()); | |
22307 | this->_M_impl._M_finish += __n; | |
22308 | std::copy_backward(__position.base(), __old_finish - __n, __old_finish); | |
22309 | std::fill(__position.base(), __position.base() + __n, | |
22310 | __x_copy); | |
22311 | } | |
22312 | else | |
22313 | { | |
22314 | std::__uninitialized_fill_n_a(this->_M_impl._M_finish, | |
22315 | __n - __elems_after, | |
22316 | __x_copy, | |
22317 | _M_get_Tp_allocator()); | |
22318 | this->_M_impl._M_finish += __n - __elems_after; | |
22319 | std::__uninitialized_move_a(__position.base(), __old_finish, | |
22320 | this->_M_impl._M_finish, | |
22321 | _M_get_Tp_allocator()); | |
22322 | this->_M_impl._M_finish += __elems_after; | |
22323 | std::fill(__position.base(), __old_finish, __x_copy); | |
22324 | } | |
22325 | } | |
22326 | else | |
22327 | { | |
22328 | const size_type __len = | |
22329 | _M_check_len(__n, "vector::_M_fill_insert"); | |
22330 | pointer __new_start(this->_M_allocate(__len)); | |
22331 | pointer __new_finish(__new_start); | |
22332 | try | |
22333 | { | |
22334 | __new_finish = | |
22335 | std::__uninitialized_move_a(this->_M_impl._M_start, | |
22336 | __position.base(), | |
22337 | __new_start, | |
22338 | _M_get_Tp_allocator()); | |
22339 | std::__uninitialized_fill_n_a(__new_finish, __n, __x, | |
22340 | _M_get_Tp_allocator()); | |
22341 | __new_finish += __n; | |
22342 | __new_finish = | |
22343 | std::__uninitialized_move_a(__position.base(), | |
22344 | this->_M_impl._M_finish, | |
22345 | __new_finish, | |
22346 | _M_get_Tp_allocator()); | |
22347 | } | |
22348 | catch(...) | |
22349 | { | |
22350 | std::_Destroy(__new_start, __new_finish, | |
22351 | _M_get_Tp_allocator()); | |
22352 | _M_deallocate(__new_start, __len); | |
22353 | throw; | |
22354 | } | |
22355 | std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
22356 | _M_get_Tp_allocator()); | |
22357 | _M_deallocate(this->_M_impl._M_start, | |
22358 | this->_M_impl._M_end_of_storage | |
22359 | - this->_M_impl._M_start); | |
22360 | this->_M_impl._M_start = __new_start; | |
22361 | this->_M_impl._M_finish = __new_finish; | |
22362 | this->_M_impl._M_end_of_storage = __new_start + __len; | |
22363 | } | |
22364 | } | |
22365 | } | |
22366 | template<typename _Tp, typename _Alloc> | |
22367 | template<typename _InputIterator> | |
22368 | void | |
22369 | vector<_Tp, _Alloc>:: | |
22370 | _M_range_insert(iterator __pos, _InputIterator __first, | |
22371 | _InputIterator __last, std::input_iterator_tag) | |
22372 | { | |
22373 | for (; __first != __last; ++__first) | |
22374 | { | |
22375 | __pos = insert(__pos, *__first); | |
22376 | ++__pos; | |
22377 | } | |
22378 | } | |
22379 | template<typename _Tp, typename _Alloc> | |
22380 | template<typename _ForwardIterator> | |
22381 | void | |
22382 | vector<_Tp, _Alloc>:: | |
22383 | _M_range_insert(iterator __position, _ForwardIterator __first, | |
22384 | _ForwardIterator __last, std::forward_iterator_tag) | |
22385 | { | |
22386 | if (__first != __last) | |
22387 | { | |
22388 | const size_type __n = std::distance(__first, __last); | |
22389 | if (size_type(this->_M_impl._M_end_of_storage | |
22390 | - this->_M_impl._M_finish) >= __n) | |
22391 | { | |
22392 | const size_type __elems_after = end() - __position; | |
22393 | pointer __old_finish(this->_M_impl._M_finish); | |
22394 | if (__elems_after > __n) | |
22395 | { | |
22396 | std::__uninitialized_move_a(this->_M_impl._M_finish - __n, | |
22397 | this->_M_impl._M_finish, | |
22398 | this->_M_impl._M_finish, | |
22399 | _M_get_Tp_allocator()); | |
22400 | this->_M_impl._M_finish += __n; | |
22401 | std::copy_backward(__position.base(), __old_finish - __n, __old_finish); | |
22402 | std::copy(__first, __last, __position); | |
22403 | } | |
22404 | else | |
22405 | { | |
22406 | _ForwardIterator __mid = __first; | |
22407 | std::advance(__mid, __elems_after); | |
22408 | std::__uninitialized_copy_a(__mid, __last, | |
22409 | this->_M_impl._M_finish, | |
22410 | _M_get_Tp_allocator()); | |
22411 | this->_M_impl._M_finish += __n - __elems_after; | |
22412 | std::__uninitialized_move_a(__position.base(), | |
22413 | __old_finish, | |
22414 | this->_M_impl._M_finish, | |
22415 | _M_get_Tp_allocator()); | |
22416 | this->_M_impl._M_finish += __elems_after; | |
22417 | std::copy(__first, __mid, __position); | |
22418 | } | |
22419 | } | |
22420 | else | |
22421 | { | |
22422 | const size_type __len = | |
22423 | _M_check_len(__n, "vector::_M_range_insert"); | |
22424 | pointer __new_start(this->_M_allocate(__len)); | |
22425 | pointer __new_finish(__new_start); | |
22426 | try | |
22427 | { | |
22428 | __new_finish = | |
22429 | std::__uninitialized_move_a(this->_M_impl._M_start, | |
22430 | __position.base(), | |
22431 | __new_start, | |
22432 | _M_get_Tp_allocator()); | |
22433 | __new_finish = | |
22434 | std::__uninitialized_copy_a(__first, __last, | |
22435 | __new_finish, | |
22436 | _M_get_Tp_allocator()); | |
22437 | __new_finish = | |
22438 | std::__uninitialized_move_a(__position.base(), | |
22439 | this->_M_impl._M_finish, | |
22440 | __new_finish, | |
22441 | _M_get_Tp_allocator()); | |
22442 | } | |
22443 | catch(...) | |
22444 | { | |
22445 | std::_Destroy(__new_start, __new_finish, | |
22446 | _M_get_Tp_allocator()); | |
22447 | _M_deallocate(__new_start, __len); | |
22448 | throw; | |
22449 | } | |
22450 | std::_Destroy(this->_M_impl._M_start, this->_M_impl._M_finish, | |
22451 | _M_get_Tp_allocator()); | |
22452 | _M_deallocate(this->_M_impl._M_start, | |
22453 | this->_M_impl._M_end_of_storage | |
22454 | - this->_M_impl._M_start); | |
22455 | this->_M_impl._M_start = __new_start; | |
22456 | this->_M_impl._M_finish = __new_finish; | |
22457 | this->_M_impl._M_end_of_storage = __new_start + __len; | |
22458 | } | |
22459 | } | |
22460 | } | |
22461 | template<typename _Alloc> | |
22462 | void | |
22463 | vector<bool, _Alloc>:: | |
22464 | reserve(size_type __n) | |
22465 | { | |
22466 | if (__n > this->max_size()) | |
22467 | __throw_length_error(("vector::reserve")); | |
22468 | if (this->capacity() < __n) | |
22469 | { | |
22470 | _Bit_type* __q = this->_M_allocate(__n); | |
22471 | this->_M_impl._M_finish = _M_copy_aligned(begin(), end(), | |
22472 | iterator(__q, 0)); | |
22473 | this->_M_deallocate(); | |
22474 | this->_M_impl._M_start = iterator(__q, 0); | |
22475 | this->_M_impl._M_end_of_storage = (__q + (__n + int(_S_word_bit) - 1) | |
22476 | / int(_S_word_bit)); | |
22477 | } | |
22478 | } | |
22479 | template<typename _Alloc> | |
22480 | void | |
22481 | vector<bool, _Alloc>:: | |
22482 | _M_fill_insert(iterator __position, size_type __n, bool __x) | |
22483 | { | |
22484 | if (__n == 0) | |
22485 | return; | |
22486 | if (capacity() - size() >= __n) | |
22487 | { | |
22488 | std::copy_backward(__position, end(), | |
22489 | this->_M_impl._M_finish + difference_type(__n)); | |
22490 | std::fill(__position, __position + difference_type(__n), __x); | |
22491 | this->_M_impl._M_finish += difference_type(__n); | |
22492 | } | |
22493 | else | |
22494 | { | |
22495 | const size_type __len = | |
22496 | _M_check_len(__n, "vector<bool>::_M_fill_insert"); | |
22497 | _Bit_type * __q = this->_M_allocate(__len); | |
22498 | iterator __i = _M_copy_aligned(begin(), __position, | |
22499 | iterator(__q, 0)); | |
22500 | std::fill(__i, __i + difference_type(__n), __x); | |
22501 | this->_M_impl._M_finish = std::copy(__position, end(), | |
22502 | __i + difference_type(__n)); | |
22503 | this->_M_deallocate(); | |
22504 | this->_M_impl._M_end_of_storage = (__q + ((__len | |
22505 | + int(_S_word_bit) - 1) | |
22506 | / int(_S_word_bit))); | |
22507 | this->_M_impl._M_start = iterator(__q, 0); | |
22508 | } | |
22509 | } | |
22510 | template<typename _Alloc> | |
22511 | template<typename _ForwardIterator> | |
22512 | void | |
22513 | vector<bool, _Alloc>:: | |
22514 | _M_insert_range(iterator __position, _ForwardIterator __first, | |
22515 | _ForwardIterator __last, std::forward_iterator_tag) | |
22516 | { | |
22517 | if (__first != __last) | |
22518 | { | |
22519 | size_type __n = std::distance(__first, __last); | |
22520 | if (capacity() - size() >= __n) | |
22521 | { | |
22522 | std::copy_backward(__position, end(), | |
22523 | this->_M_impl._M_finish | |
22524 | + difference_type(__n)); | |
22525 | std::copy(__first, __last, __position); | |
22526 | this->_M_impl._M_finish += difference_type(__n); | |
22527 | } | |
22528 | else | |
22529 | { | |
22530 | const size_type __len = | |
22531 | _M_check_len(__n, "vector<bool>::_M_insert_range"); | |
22532 | _Bit_type * __q = this->_M_allocate(__len); | |
22533 | iterator __i = _M_copy_aligned(begin(), __position, | |
22534 | iterator(__q, 0)); | |
22535 | __i = std::copy(__first, __last, __i); | |
22536 | this->_M_impl._M_finish = std::copy(__position, end(), __i); | |
22537 | this->_M_deallocate(); | |
22538 | this->_M_impl._M_end_of_storage = (__q | |
22539 | + ((__len | |
22540 | + int(_S_word_bit) - 1) | |
22541 | / int(_S_word_bit))); | |
22542 | this->_M_impl._M_start = iterator(__q, 0); | |
22543 | } | |
22544 | } | |
22545 | } | |
22546 | template<typename _Alloc> | |
22547 | void | |
22548 | vector<bool, _Alloc>:: | |
22549 | _M_insert_aux(iterator __position, bool __x) | |
22550 | { | |
22551 | if (this->_M_impl._M_finish._M_p != this->_M_impl._M_end_of_storage) | |
22552 | { | |
22553 | std::copy_backward(__position, this->_M_impl._M_finish, | |
22554 | this->_M_impl._M_finish + 1); | |
22555 | *__position = __x; | |
22556 | ++this->_M_impl._M_finish; | |
22557 | } | |
22558 | else | |
22559 | { | |
22560 | const size_type __len = | |
22561 | _M_check_len(size_type(1), "vector<bool>::_M_insert_aux"); | |
22562 | _Bit_type * __q = this->_M_allocate(__len); | |
22563 | iterator __i = _M_copy_aligned(begin(), __position, | |
22564 | iterator(__q, 0)); | |
22565 | *__i++ = __x; | |
22566 | this->_M_impl._M_finish = std::copy(__position, end(), __i); | |
22567 | this->_M_deallocate(); | |
22568 | this->_M_impl._M_end_of_storage = (__q + ((__len | |
22569 | + int(_S_word_bit) - 1) | |
22570 | / int(_S_word_bit))); | |
22571 | this->_M_impl._M_start = iterator(__q, 0); | |
22572 | } | |
22573 | } | |
22574 | } | |
22575 | extern "C" { | |
22576 | union wait | |
22577 | { | |
22578 | int w_status; | |
22579 | struct | |
22580 | { | |
22581 | unsigned int __w_termsig:7; | |
22582 | unsigned int __w_coredump:1; | |
22583 | unsigned int __w_retcode:8; | |
22584 | unsigned int:16; | |
22585 | } __wait_terminated; | |
22586 | struct | |
22587 | { | |
22588 | unsigned int __w_stopval:8; | |
22589 | unsigned int __w_stopsig:8; | |
22590 | unsigned int:16; | |
22591 | } __wait_stopped; | |
22592 | }; | |
22593 | typedef struct | |
22594 | { | |
22595 | int quot; | |
22596 | int rem; | |
22597 | } div_t; | |
22598 | typedef struct | |
22599 | { | |
22600 | long int quot; | |
22601 | long int rem; | |
22602 | } ldiv_t; | |
22603 | __extension__ typedef struct | |
22604 | { | |
22605 | long long int quot; | |
22606 | long long int rem; | |
22607 | } lldiv_t; | |
22608 | extern double atof (__const char *__nptr) | |
22609 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
22610 | extern int atoi (__const char *__nptr) | |
22611 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
22612 | extern long int atol (__const char *__nptr) | |
22613 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
22614 | __extension__ extern long long int atoll (__const char *__nptr) | |
22615 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
22616 | extern double strtod (__const char *__restrict __nptr, | |
22617 | char **__restrict __endptr) | |
22618 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22619 | extern float strtof (__const char *__restrict __nptr, | |
22620 | char **__restrict __endptr) throw () __attribute__ ((__nonnull__ (1))) ; | |
22621 | extern long double strtold (__const char *__restrict __nptr, | |
22622 | char **__restrict __endptr) | |
22623 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22624 | extern long int strtol (__const char *__restrict __nptr, | |
22625 | char **__restrict __endptr, int __base) | |
22626 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22627 | extern unsigned long int strtoul (__const char *__restrict __nptr, | |
22628 | char **__restrict __endptr, int __base) | |
22629 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22630 | __extension__ | |
22631 | extern long long int strtoq (__const char *__restrict __nptr, | |
22632 | char **__restrict __endptr, int __base) | |
22633 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22634 | __extension__ | |
22635 | extern unsigned long long int strtouq (__const char *__restrict __nptr, | |
22636 | char **__restrict __endptr, int __base) | |
22637 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22638 | __extension__ | |
22639 | extern long long int strtoll (__const char *__restrict __nptr, | |
22640 | char **__restrict __endptr, int __base) | |
22641 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22642 | __extension__ | |
22643 | extern unsigned long long int strtoull (__const char *__restrict __nptr, | |
22644 | char **__restrict __endptr, int __base) | |
22645 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22646 | extern char *l64a (long int __n) throw () ; | |
22647 | extern long int a64l (__const char *__s) | |
22648 | throw () __attribute__ ((__pure__)) __attribute__ ((__nonnull__ (1))) ; | |
22649 | extern "C" { | |
22650 | typedef __u_char u_char; | |
22651 | typedef __u_short u_short; | |
22652 | typedef __u_int u_int; | |
22653 | typedef __u_long u_long; | |
22654 | typedef __quad_t quad_t; | |
22655 | typedef __u_quad_t u_quad_t; | |
22656 | typedef __fsid_t fsid_t; | |
22657 | typedef __loff_t loff_t; | |
22658 | typedef __ino_t ino_t; | |
22659 | typedef __ino64_t ino64_t; | |
22660 | typedef __dev_t dev_t; | |
22661 | typedef __mode_t mode_t; | |
22662 | typedef __nlink_t nlink_t; | |
22663 | typedef __id_t id_t; | |
22664 | typedef __daddr_t daddr_t; | |
22665 | typedef __caddr_t caddr_t; | |
22666 | typedef __key_t key_t; | |
22667 | typedef __suseconds_t suseconds_t; | |
22668 | typedef unsigned long int ulong; | |
22669 | typedef unsigned short int ushort; | |
22670 | typedef unsigned int uint; | |
22671 | typedef unsigned int u_int8_t __attribute__ ((__mode__ (__QI__))); | |
22672 | typedef unsigned int u_int16_t __attribute__ ((__mode__ (__HI__))); | |
22673 | typedef unsigned int u_int32_t __attribute__ ((__mode__ (__SI__))); | |
22674 | typedef unsigned int u_int64_t __attribute__ ((__mode__ (__DI__))); | |
22675 | typedef int register_t __attribute__ ((__mode__ (__word__))); | |
22676 | struct timeval | |
22677 | { | |
22678 | __time_t tv_sec; | |
22679 | __suseconds_t tv_usec; | |
22680 | }; | |
22681 | typedef long int __fd_mask; | |
22682 | typedef struct | |
22683 | { | |
22684 | __fd_mask fds_bits[1024 / (8 * sizeof (__fd_mask))]; | |
22685 | } fd_set; | |
22686 | typedef __fd_mask fd_mask; | |
22687 | extern "C" { | |
22688 | extern int select (int __nfds, fd_set *__restrict __readfds, | |
22689 | fd_set *__restrict __writefds, | |
22690 | fd_set *__restrict __exceptfds, | |
22691 | struct timeval *__restrict __timeout); | |
22692 | extern int pselect (int __nfds, fd_set *__restrict __readfds, | |
22693 | fd_set *__restrict __writefds, | |
22694 | fd_set *__restrict __exceptfds, | |
22695 | const struct timespec *__restrict __timeout, | |
22696 | const __sigset_t *__restrict __sigmask); | |
22697 | } | |
22698 | __extension__ | |
22699 | static __inline unsigned int gnu_dev_major (unsigned long long int __dev) | |
22700 | throw (); | |
22701 | __extension__ | |
22702 | static __inline unsigned int gnu_dev_minor (unsigned long long int __dev) | |
22703 | throw (); | |
22704 | __extension__ | |
22705 | static __inline unsigned long long int gnu_dev_makedev (unsigned int __major, | |
22706 | unsigned int __minor) | |
22707 | throw (); | |
22708 | __extension__ static __inline unsigned int | |
22709 | gnu_dev_major (unsigned long long int __dev) throw () | |
22710 | { | |
22711 | return ((__dev >> 8) & 0xfff) | ((unsigned int) (__dev >> 32) & ~0xfff); | |
22712 | } | |
22713 | __extension__ static __inline unsigned int | |
22714 | gnu_dev_minor (unsigned long long int __dev) throw () | |
22715 | { | |
22716 | return (__dev & 0xff) | ((unsigned int) (__dev >> 12) & ~0xff); | |
22717 | } | |
22718 | __extension__ static __inline unsigned long long int | |
22719 | gnu_dev_makedev (unsigned int __major, unsigned int __minor) throw () | |
22720 | { | |
22721 | return ((__minor & 0xff) | ((__major & 0xfff) << 8) | |
22722 | | (((unsigned long long int) (__minor & ~0xff)) << 12) | |
22723 | | (((unsigned long long int) (__major & ~0xfff)) << 32)); | |
22724 | } | |
22725 | typedef __blksize_t blksize_t; | |
22726 | typedef __blkcnt_t blkcnt_t; | |
22727 | typedef __fsblkcnt_t fsblkcnt_t; | |
22728 | typedef __fsfilcnt_t fsfilcnt_t; | |
22729 | typedef __blkcnt64_t blkcnt64_t; | |
22730 | typedef __fsblkcnt64_t fsblkcnt64_t; | |
22731 | typedef __fsfilcnt64_t fsfilcnt64_t; | |
22732 | } | |
22733 | extern long int random (void) throw (); | |
22734 | extern void srandom (unsigned int __seed) throw (); | |
22735 | extern char *initstate (unsigned int __seed, char *__statebuf, | |
22736 | size_t __statelen) throw () __attribute__ ((__nonnull__ (2))); | |
22737 | extern char *setstate (char *__statebuf) throw () __attribute__ ((__nonnull__ (1))); | |
22738 | struct random_data | |
22739 | { | |
22740 | int32_t *fptr; | |
22741 | int32_t *rptr; | |
22742 | int32_t *state; | |
22743 | int rand_type; | |
22744 | int rand_deg; | |
22745 | int rand_sep; | |
22746 | int32_t *end_ptr; | |
22747 | }; | |
22748 | extern int random_r (struct random_data *__restrict __buf, | |
22749 | int32_t *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); | |
22750 | extern int srandom_r (unsigned int __seed, struct random_data *__buf) | |
22751 | throw () __attribute__ ((__nonnull__ (2))); | |
22752 | extern int initstate_r (unsigned int __seed, char *__restrict __statebuf, | |
22753 | size_t __statelen, | |
22754 | struct random_data *__restrict __buf) | |
22755 | throw () __attribute__ ((__nonnull__ (2, 4))); | |
22756 | extern int setstate_r (char *__restrict __statebuf, | |
22757 | struct random_data *__restrict __buf) | |
22758 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
22759 | extern int rand (void) throw (); | |
22760 | extern void srand (unsigned int __seed) throw (); | |
22761 | extern int rand_r (unsigned int *__seed) throw (); | |
22762 | extern double drand48 (void) throw (); | |
22763 | extern double erand48 (unsigned short int __xsubi[3]) throw () __attribute__ ((__nonnull__ (1))); | |
22764 | extern long int lrand48 (void) throw (); | |
22765 | extern long int nrand48 (unsigned short int __xsubi[3]) | |
22766 | throw () __attribute__ ((__nonnull__ (1))); | |
22767 | extern long int mrand48 (void) throw (); | |
22768 | extern long int jrand48 (unsigned short int __xsubi[3]) | |
22769 | throw () __attribute__ ((__nonnull__ (1))); | |
22770 | extern void srand48 (long int __seedval) throw (); | |
22771 | extern unsigned short int *seed48 (unsigned short int __seed16v[3]) | |
22772 | throw () __attribute__ ((__nonnull__ (1))); | |
22773 | extern void lcong48 (unsigned short int __param[7]) throw () __attribute__ ((__nonnull__ (1))); | |
22774 | struct drand48_data | |
22775 | { | |
22776 | unsigned short int __x[3]; | |
22777 | unsigned short int __old_x[3]; | |
22778 | unsigned short int __c; | |
22779 | unsigned short int __init; | |
22780 | unsigned long long int __a; | |
22781 | }; | |
22782 | extern int drand48_r (struct drand48_data *__restrict __buffer, | |
22783 | double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); | |
22784 | extern int erand48_r (unsigned short int __xsubi[3], | |
22785 | struct drand48_data *__restrict __buffer, | |
22786 | double *__restrict __result) throw () __attribute__ ((__nonnull__ (1, 2))); | |
22787 | extern int lrand48_r (struct drand48_data *__restrict __buffer, | |
22788 | long int *__restrict __result) | |
22789 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
22790 | extern int nrand48_r (unsigned short int __xsubi[3], | |
22791 | struct drand48_data *__restrict __buffer, | |
22792 | long int *__restrict __result) | |
22793 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
22794 | extern int mrand48_r (struct drand48_data *__restrict __buffer, | |
22795 | long int *__restrict __result) | |
22796 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
22797 | extern int jrand48_r (unsigned short int __xsubi[3], | |
22798 | struct drand48_data *__restrict __buffer, | |
22799 | long int *__restrict __result) | |
22800 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
22801 | extern int srand48_r (long int __seedval, struct drand48_data *__buffer) | |
22802 | throw () __attribute__ ((__nonnull__ (2))); | |
22803 | extern int seed48_r (unsigned short int __seed16v[3], | |
22804 | struct drand48_data *__buffer) throw () __attribute__ ((__nonnull__ (1, 2))); | |
22805 | extern int lcong48_r (unsigned short int __param[7], | |
22806 | struct drand48_data *__buffer) | |
22807 | throw () __attribute__ ((__nonnull__ (1, 2))); | |
22808 | extern void *malloc (size_t __size) throw () __attribute__ ((__malloc__)) ; | |
22809 | extern void *calloc (size_t __nmemb, size_t __size) | |
22810 | throw () __attribute__ ((__malloc__)) ; | |
22811 | extern void *realloc (void *__ptr, size_t __size) | |
22812 | throw () __attribute__ ((__malloc__)) __attribute__ ((__warn_unused_result__)); | |
22813 | extern void free (void *__ptr) throw (); | |
22814 | extern void cfree (void *__ptr) throw (); | |
22815 | extern "C" { | |
22816 | extern void *alloca (size_t __size) throw (); | |
22817 | } | |
22818 | extern void *valloc (size_t __size) throw () __attribute__ ((__malloc__)) ; | |
22819 | extern int posix_memalign (void **__memptr, size_t __alignment, size_t __size) | |
22820 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22821 | extern void abort (void) throw () __attribute__ ((__noreturn__)); | |
22822 | extern int atexit (void (*__func) (void)) throw () __attribute__ ((__nonnull__ (1))); | |
22823 | extern int on_exit (void (*__func) (int __status, void *__arg), void *__arg) | |
22824 | throw () __attribute__ ((__nonnull__ (1))); | |
22825 | extern void exit (int __status) throw () __attribute__ ((__noreturn__)); | |
22826 | extern void _Exit (int __status) throw () __attribute__ ((__noreturn__)); | |
22827 | extern char *getenv (__const char *__name) throw () __attribute__ ((__nonnull__ (1))) ; | |
22828 | extern char *__secure_getenv (__const char *__name) | |
22829 | throw () __attribute__ ((__nonnull__ (1))) ; | |
22830 | extern int putenv (char *__string) throw () __attribute__ ((__nonnull__ (1))); | |
22831 | extern int setenv (__const char *__name, __const char *__value, int __replace) | |
22832 | throw () __attribute__ ((__nonnull__ (2))); | |
22833 | extern int unsetenv (__const char *__name) throw (); | |
22834 | extern int clearenv (void) throw (); | |
22835 | extern char *mktemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; | |
22836 | extern int mkstemp (char *__template) __attribute__ ((__nonnull__ (1))) ; | |
22837 | extern int mkstemp64 (char *__template) __attribute__ ((__nonnull__ (1))) ; | |
22838 | extern char *mkdtemp (char *__template) throw () __attribute__ ((__nonnull__ (1))) ; | |
22839 | extern int system (__const char *__command) ; | |
22840 | extern char *realpath (__const char *__restrict __name, | |
22841 | char *__restrict __resolved) throw () __attribute__ ((__nonnull__ (2))); | |
22842 | typedef int (*__compar_fn_t) (__const void *, __const void *); | |
22843 | typedef __compar_fn_t comparison_fn_t; | |
22844 | extern void *bsearch (__const void *__key, __const void *__base, | |
22845 | size_t __nmemb, size_t __size, __compar_fn_t __compar) | |
22846 | __attribute__ ((__nonnull__ (1, 2, 5))) ; | |
22847 | extern void qsort (void *__base, size_t __nmemb, size_t __size, | |
22848 | __compar_fn_t __compar) __attribute__ ((__nonnull__ (1, 4))); | |
22849 | extern int abs (int __x) throw () __attribute__ ((__const__)) ; | |
22850 | extern long int labs (long int __x) throw () __attribute__ ((__const__)) ; | |
22851 | __extension__ extern long long int llabs (long long int __x) | |
22852 | throw () __attribute__ ((__const__)) ; | |
22853 | extern div_t div (int __numer, int __denom) | |
22854 | throw () __attribute__ ((__const__)) ; | |
22855 | extern ldiv_t ldiv (long int __numer, long int __denom) | |
22856 | throw () __attribute__ ((__const__)) ; | |
22857 | __extension__ extern lldiv_t lldiv (long long int __numer, | |
22858 | long long int __denom) | |
22859 | throw () __attribute__ ((__const__)) ; | |
22860 | extern char *gcvt (double __value, int __ndigit, char *__buf) | |
22861 | throw () __attribute__ ((__nonnull__ (3))) ; | |
22862 | extern int rpmatch (__const char *__response) throw () __attribute__ ((__nonnull__ (1))) ; | |
22863 | extern int getsubopt (char **__restrict __optionp, | |
22864 | char *__const *__restrict __tokens, | |
22865 | char **__restrict __valuep) | |
22866 | throw () __attribute__ ((__nonnull__ (1, 2, 3))) ; | |
22867 | extern void setkey (__const char *__key) throw () __attribute__ ((__nonnull__ (1))); | |
22868 | extern int posix_openpt (int __oflag) ; | |
22869 | extern int grantpt (int __fd) throw (); | |
22870 | extern int unlockpt (int __fd) throw (); | |
22871 | extern char *ptsname (int __fd) throw () ; | |
22872 | extern int ptsname_r (int __fd, char *__buf, size_t __buflen) | |
22873 | throw () __attribute__ ((__nonnull__ (2))); | |
22874 | } | |
22875 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
22876 | struct __attribute__((visibility("default"))) QVectorData | |
22877 | { | |
22878 | QBasicAtomicInt ref; | |
22879 | int alloc; | |
22880 | int size; | |
22881 | uint sharable : 1; | |
22882 | uint capacity : 1; | |
22883 | static QVectorData shared_null; | |
22884 | static QVectorData *malloc(int sizeofTypedData, int size, int sizeofT, QVectorData *init); | |
22885 | static int grow(int sizeofTypedData, int size, int sizeofT, bool excessive); | |
22886 | }; | |
22887 | template <typename T> | |
22888 | struct QVectorTypedData | |
22889 | { | |
22890 | QBasicAtomicInt ref; | |
22891 | int alloc; | |
22892 | int size; | |
22893 | uint sharable : 1; | |
22894 | uint capacity : 1; | |
22895 | T array[1]; | |
22896 | }; | |
22897 | class QRegion; | |
22898 | template <typename T> | |
22899 | class QVector | |
22900 | { | |
22901 | typedef QVectorTypedData<T> Data; | |
22902 | union { QVectorData *p; QVectorTypedData<T> *d; }; | |
22903 | public: | |
22904 | inline QVector() : p(&QVectorData::shared_null) { d->ref.ref(); } | |
22905 | explicit QVector(int size); | |
22906 | QVector(int size, const T &t); | |
22907 | inline QVector(const QVector<T> &v) : d(v.d) { d->ref.ref(); if (!d->sharable) detach_helper(); } | |
22908 | inline ~QVector() { if (!d) return; if (!d->ref.deref()) free(d); } | |
22909 | QVector<T> &operator=(const QVector<T> &v); | |
22910 | bool operator==(const QVector<T> &v) const; | |
22911 | inline bool operator!=(const QVector<T> &v) const { return !(*this == v); } | |
22912 | inline int size() const { return d->size; } | |
22913 | inline bool isEmpty() const { return d->size == 0; } | |
22914 | void resize(int size); | |
22915 | inline int capacity() const { return d->alloc; } | |
22916 | void reserve(int size); | |
22917 | inline void squeeze() { realloc(d->size, d->size); d->capacity = 0; } | |
22918 | inline void detach() { if (d->ref != 1) detach_helper(); } | |
22919 | inline bool isDetached() const { return d->ref == 1; } | |
22920 | inline void setSharable(bool sharable) { if (!sharable) detach(); d->sharable = sharable; } | |
22921 | inline T *data() { detach(); return d->array; } | |
22922 | inline const T *data() const { return d->array; } | |
22923 | inline const T *constData() const { return d->array; } | |
22924 | void clear(); | |
22925 | const T &at(int i) const; | |
22926 | T &operator[](int i); | |
22927 | const T &operator[](int i) const; | |
22928 | void append(const T &t); | |
22929 | void prepend(const T &t); | |
22930 | void insert(int i, const T &t); | |
22931 | void insert(int i, int n, const T &t); | |
22932 | void replace(int i, const T &t); | |
22933 | void remove(int i); | |
22934 | void remove(int i, int n); | |
22935 | QVector<T> &fill(const T &t, int size = -1); | |
22936 | int indexOf(const T &t, int from = 0) const; | |
22937 | int lastIndexOf(const T &t, int from = -1) const; | |
22938 | bool contains(const T &t) const; | |
22939 | int count(const T &t) const; | |
22940 | typedef T* iterator; | |
22941 | typedef const T* const_iterator; | |
22942 | inline iterator begin() { detach(); return d->array; } | |
22943 | inline const_iterator begin() const { return d->array; } | |
22944 | inline const_iterator constBegin() const { return d->array; } | |
22945 | inline iterator end() { detach(); return d->array + d->size; } | |
22946 | inline const_iterator end() const { return d->array + d->size; } | |
22947 | inline const_iterator constEnd() const { return d->array + d->size; } | |
22948 | iterator insert(iterator before, int n, const T &x); | |
22949 | inline iterator insert(iterator before, const T &x) { return insert(before, 1, x); } | |
22950 | iterator erase(iterator begin, iterator end); | |
22951 | inline iterator erase(iterator pos) { return erase(pos, pos+1); } | |
22952 | inline int count() const { return d->size; } | |
22953 | inline T& first() { qt_noop(); return *begin(); } | |
22954 | inline const T &first() const { qt_noop(); return *begin(); } | |
22955 | inline T& last() { qt_noop(); return *(end()-1); } | |
22956 | inline const T &last() const { qt_noop(); return *(end()-1); } | |
22957 | inline bool startsWith(const T &t) const { return !isEmpty() && first() == t; } | |
22958 | inline bool endsWith(const T &t) const { return !isEmpty() && last() == t; } | |
22959 | QVector<T> mid(int pos, int length = -1) const; | |
22960 | T value(int i) const; | |
22961 | T value(int i, const T &defaultValue) const; | |
22962 | typedef T value_type; | |
22963 | typedef value_type* pointer; | |
22964 | typedef const value_type* const_pointer; | |
22965 | typedef value_type& reference; | |
22966 | typedef const value_type& const_reference; | |
22967 | typedef ptrdiff_t difference_type; | |
22968 | typedef iterator Iterator; | |
22969 | typedef const_iterator ConstIterator; | |
22970 | typedef int size_type; | |
22971 | inline void push_back(const T &t) { append(t); } | |
22972 | inline void push_front(const T &t) { prepend(t); } | |
22973 | void pop_back() { qt_noop(); erase(end()-1); } | |
22974 | void pop_front() { qt_noop(); erase(begin()); } | |
22975 | inline bool empty() const | |
22976 | { return d->size == 0; } | |
22977 | inline T& front() { return first(); } | |
22978 | inline const_reference front() const { return first(); } | |
22979 | inline reference back() { return last(); } | |
22980 | inline const_reference back() const { return last(); } | |
22981 | QVector<T> &operator+=(const QVector<T> &l); | |
22982 | inline QVector<T> operator+(const QVector<T> &l) const | |
22983 | { QVector n = *this; n += l; return n; } | |
22984 | inline QVector<T> &operator+=(const T &t) | |
22985 | { append(t); return *this; } | |
22986 | inline QVector<T> &operator<< (const T &t) | |
22987 | { append(t); return *this; } | |
22988 | inline QVector<T> &operator<<(const QVector<T> &l) | |
22989 | { *this += l; return *this; } | |
22990 | QList<T> toList() const; | |
22991 | static QVector<T> fromList(const QList<T> &list); | |
22992 | static inline QVector<T> fromStdVector(const std::vector<T> &vector) | |
22993 | { QVector<T> tmp; qCopy(vector.begin(), vector.end(), std::back_inserter(tmp)); return tmp; } | |
22994 | inline std::vector<T> toStdVector() const | |
22995 | { std::vector<T> tmp; qCopy(constBegin(), constEnd(), std::back_inserter(tmp)); return tmp; } | |
22996 | private: | |
22997 | friend class QRegion; | |
22998 | void detach_helper(); | |
22999 | QVectorData *malloc(int alloc); | |
23000 | void realloc(int size, int alloc); | |
23001 | void free(Data *d); | |
23002 | int sizeOfTypedData() { | |
23003 | return reinterpret_cast<const char *>(&(reinterpret_cast<const Data *>(this))->array[1]) - reinterpret_cast<const char *>(this); | |
23004 | } | |
23005 | }; | |
23006 | template <typename T> | |
23007 | void QVector<T>::detach_helper() | |
23008 | { realloc(d->size, d->alloc); } | |
23009 | template <typename T> | |
23010 | void QVector<T>::reserve(int asize) | |
23011 | { if (asize > d->alloc) realloc(d->size, asize); d->capacity = 1; } | |
23012 | template <typename T> | |
23013 | void QVector<T>::resize(int asize) | |
23014 | { realloc(asize, (asize > d->alloc || (!d->capacity && asize < d->size && asize < (d->alloc >> 1))) ? | |
23015 | QVectorData::grow(sizeOfTypedData(), asize, sizeof(T), QTypeInfo<T>::isStatic) | |
23016 | : d->alloc); } | |
23017 | template <typename T> | |
23018 | inline void QVector<T>::clear() | |
23019 | { *this = QVector<T>(); } | |
23020 | template <typename T> | |
23021 | inline const T &QVector<T>::at(int i) const | |
23022 | { qt_noop(); | |
23023 | return d->array[i]; } | |
23024 | template <typename T> | |
23025 | inline const T &QVector<T>::operator[](int i) const | |
23026 | { qt_noop(); | |
23027 | return d->array[i]; } | |
23028 | template <typename T> | |
23029 | inline T &QVector<T>::operator[](int i) | |
23030 | { qt_noop(); | |
23031 | return data()[i]; } | |
23032 | template <typename T> | |
23033 | inline void QVector<T>::insert(int i, const T &t) | |
23034 | { qt_noop(); | |
23035 | insert(begin() + i, 1, t); } | |
23036 | template <typename T> | |
23037 | inline void QVector<T>::insert(int i, int n, const T &t) | |
23038 | { qt_noop(); | |
23039 | insert(begin() + i, n, t); } | |
23040 | template <typename T> | |
23041 | inline void QVector<T>::remove(int i, int n) | |
23042 | { qt_noop(); | |
23043 | erase(begin() + i, begin() + i + n); } | |
23044 | template <typename T> | |
23045 | inline void QVector<T>::remove(int i) | |
23046 | { qt_noop(); | |
23047 | erase(begin() + i, begin() + i + 1); } | |
23048 | template <typename T> | |
23049 | inline void QVector<T>::prepend(const T &t) | |
23050 | { insert(begin(), 1, t); } | |
23051 | template <typename T> | |
23052 | inline void QVector<T>::replace(int i, const T &t) | |
23053 | { | |
23054 | qt_noop(); | |
23055 | const T copy(t); | |
23056 | data()[i] = copy; | |
23057 | } | |
23058 | template <typename T> | |
23059 | QVector<T> &QVector<T>::operator=(const QVector<T> &v) | |
23060 | { | |
23061 | v.d->ref.ref(); | |
23062 | if (!d->ref.deref()) | |
23063 | free(d); | |
23064 | d = v.d; | |
23065 | if (!d->sharable) | |
23066 | detach_helper(); | |
23067 | return *this; | |
23068 | } | |
23069 | template <typename T> | |
23070 | inline QVectorData *QVector<T>::malloc(int aalloc) | |
23071 | { | |
23072 | return static_cast<QVectorData *>(qMalloc(sizeOfTypedData() + (aalloc - 1) * sizeof(T))); | |
23073 | } | |
23074 | template <typename T> | |
23075 | QVector<T>::QVector(int asize) | |
23076 | { | |
23077 | p = malloc(asize); | |
23078 | d->ref = 1; | |
23079 | d->alloc = d->size = asize; | |
23080 | d->sharable = true; | |
23081 | d->capacity = false; | |
23082 | if (QTypeInfo<T>::isComplex) { | |
23083 | T* b = d->array; | |
23084 | T* i = d->array + d->size; | |
23085 | while (i != b) | |
23086 | new (--i) T; | |
23087 | } else { | |
23088 | qMemSet(d->array, 0, asize * sizeof(T)); | |
23089 | } | |
23090 | } | |
23091 | template <typename T> | |
23092 | QVector<T>::QVector(int asize, const T &t) | |
23093 | { | |
23094 | p = malloc(asize); | |
23095 | d->ref = 1; | |
23096 | d->alloc = d->size = asize; | |
23097 | d->sharable = true; | |
23098 | d->capacity = false; | |
23099 | T* i = d->array + d->size; | |
23100 | while (i != d->array) | |
23101 | new (--i) T(t); | |
23102 | } | |
23103 | template <typename T> | |
23104 | void QVector<T>::free(Data *x) | |
23105 | { | |
23106 | if (QTypeInfo<T>::isComplex) { | |
23107 | T* b = x->array; | |
23108 | T* i = b + x->size; | |
23109 | while (i-- != b) | |
23110 | i->~T(); | |
23111 | } | |
23112 | qFree(x); | |
23113 | } | |
23114 | template <typename T> | |
23115 | void QVector<T>::realloc(int asize, int aalloc) | |
23116 | { | |
23117 | T *j, *i, *b; | |
23118 | union { QVectorData *p; Data *d; } x; | |
23119 | x.d = d; | |
23120 | if (QTypeInfo<T>::isComplex && aalloc == d->alloc && d->ref == 1) { | |
23121 | i = d->array + d->size; | |
23122 | j = d->array + asize; | |
23123 | if (i > j) { | |
23124 | while (i-- != j) | |
23125 | i->~T(); | |
23126 | } else { | |
23127 | while (j-- != i) | |
23128 | new (j) T; | |
23129 | } | |
23130 | d->size = asize; | |
23131 | return; | |
23132 | } | |
23133 | if (aalloc != d->alloc || d->ref != 1) { | |
23134 | if (QTypeInfo<T>::isStatic) { | |
23135 | x.p = malloc(aalloc); | |
23136 | } else if (d->ref != 1) { | |
23137 | x.p = QVectorData::malloc(sizeOfTypedData(), aalloc, sizeof(T), p); | |
23138 | } else { | |
23139 | if (QTypeInfo<T>::isComplex) { | |
23140 | if (asize < d->size) { | |
23141 | j = d->array + asize; | |
23142 | i = d->array + d->size; | |
23143 | while (i-- != j) | |
23144 | i->~T(); | |
23145 | i = d->array + asize; | |
23146 | } | |
23147 | } | |
23148 | x.p = p = static_cast<QVectorData *>(qRealloc(p, sizeOfTypedData() + (aalloc - 1) * sizeof(T))); | |
23149 | } | |
23150 | x.d->ref = 1; | |
23151 | x.d->sharable = true; | |
23152 | x.d->capacity = d->capacity; | |
23153 | } | |
23154 | if (QTypeInfo<T>::isComplex) { | |
23155 | if (asize < d->size) { | |
23156 | j = d->array + asize; | |
23157 | i = x.d->array + asize; | |
23158 | } else { | |
23159 | i = x.d->array + asize; | |
23160 | j = x.d->array + d->size; | |
23161 | while (i != j) | |
23162 | new (--i) T; | |
23163 | j = d->array + d->size; | |
23164 | } | |
23165 | if (i != j) { | |
23166 | b = x.d->array; | |
23167 | while (i != b) | |
23168 | new (--i) T(*--j); | |
23169 | } | |
23170 | } else if (asize > d->size) { | |
23171 | qMemSet(x.d->array + d->size, 0, (asize - d->size) * sizeof(T)); | |
23172 | } | |
23173 | x.d->size = asize; | |
23174 | x.d->alloc = aalloc; | |
23175 | if (d != x.d) { | |
23176 | if (!d->ref.deref()) | |
23177 | free(d); | |
23178 | d = x.d; | |
23179 | } | |
23180 | } | |
23181 | template<typename T> | |
23182 | T QVector<T>::value(int i) const | |
23183 | { | |
23184 | if (i < 0 || i >= p->size) { | |
23185 | return T(); | |
23186 | } | |
23187 | return d->array[i]; | |
23188 | } | |
23189 | template<typename T> | |
23190 | T QVector<T>::value(int i, const T &defaultValue) const | |
23191 | { | |
23192 | return ((i < 0 || i >= p->size) ? defaultValue : d->array[i]); | |
23193 | } | |
23194 | template <typename T> | |
23195 | void QVector<T>::append(const T &t) | |
23196 | { | |
23197 | if (d->ref != 1 || d->size + 1 > d->alloc) { | |
23198 | const T copy(t); | |
23199 | realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + 1, sizeof(T), | |
23200 | QTypeInfo<T>::isStatic)); | |
23201 | if (QTypeInfo<T>::isComplex) | |
23202 | new (d->array + d->size) T(copy); | |
23203 | else | |
23204 | d->array[d->size] = copy; | |
23205 | } else { | |
23206 | if (QTypeInfo<T>::isComplex) | |
23207 | new (d->array + d->size) T(t); | |
23208 | else | |
23209 | d->array[d->size] = t; | |
23210 | } | |
23211 | ++d->size; | |
23212 | } | |
23213 | template <typename T> | |
23214 | typename QVector<T>::iterator QVector<T>::insert(iterator before, size_type n, const T &t) | |
23215 | { | |
23216 | int offset = before - d->array; | |
23217 | if (n != 0) { | |
23218 | const T copy(t); | |
23219 | if (d->ref != 1 || d->size + n > d->alloc) | |
23220 | realloc(d->size, QVectorData::grow(sizeOfTypedData(), d->size + n, sizeof(T), | |
23221 | QTypeInfo<T>::isStatic)); | |
23222 | if (QTypeInfo<T>::isStatic) { | |
23223 | T *b = d->array + d->size; | |
23224 | T *i = d->array + d->size + n; | |
23225 | while (i != b) | |
23226 | new (--i) T; | |
23227 | i = d->array + d->size; | |
23228 | T *j = i + n; | |
23229 | b = d->array + offset; | |
23230 | while (i != b) | |
23231 | *--j = *--i; | |
23232 | i = b+n; | |
23233 | while (i != b) | |
23234 | *--i = copy; | |
23235 | } else { | |
23236 | T *b = d->array + offset; | |
23237 | T *i = b + n; | |
23238 | memmove(i, b, (d->size - offset) * sizeof(T)); | |
23239 | while (i != b) | |
23240 | new (--i) T(copy); | |
23241 | } | |
23242 | d->size += n; | |
23243 | } | |
23244 | return d->array + offset; | |
23245 | } | |
23246 | template <typename T> | |
23247 | typename QVector<T>::iterator QVector<T>::erase(iterator abegin, iterator aend) | |
23248 | { | |
23249 | int f = abegin - d->array; | |
23250 | int l = aend - d->array; | |
23251 | int n = l - f; | |
23252 | detach(); | |
23253 | if (QTypeInfo<T>::isComplex) { | |
23254 | qCopy(d->array+l, d->array+d->size, d->array+f); | |
23255 | T *i = d->array+d->size; | |
23256 | T* b = d->array+d->size-n; | |
23257 | while (i != b) { | |
23258 | --i; | |
23259 | i->~T(); | |
23260 | } | |
23261 | } else { | |
23262 | memmove(d->array + f, d->array + l, (d->size-l)*sizeof(T)); | |
23263 | } | |
23264 | d->size -= n; | |
23265 | return d->array + f; | |
23266 | } | |
23267 | template <typename T> | |
23268 | bool QVector<T>::operator==(const QVector<T> &v) const | |
23269 | { | |
23270 | if (d->size != v.d->size) | |
23271 | return false; | |
23272 | if (d == v.d) | |
23273 | return true; | |
23274 | T* b = d->array; | |
23275 | T* i = b + d->size; | |
23276 | T* j = v.d->array + d->size; | |
23277 | while (i != b) | |
23278 | if (!(*--i == *--j)) | |
23279 | return false; | |
23280 | return true; | |
23281 | } | |
23282 | template <typename T> | |
23283 | QVector<T> &QVector<T>::fill(const T &from, int asize) | |
23284 | { | |
23285 | const T copy(from); | |
23286 | resize(asize < 0 ? d->size : asize); | |
23287 | if (d->size) { | |
23288 | T *i = d->array + d->size; | |
23289 | T *b = d->array; | |
23290 | while (i != b) | |
23291 | *--i = copy; | |
23292 | } | |
23293 | return *this; | |
23294 | } | |
23295 | template <typename T> | |
23296 | QVector<T> &QVector<T>::operator+=(const QVector &l) | |
23297 | { | |
23298 | int newSize = d->size + l.d->size; | |
23299 | realloc(d->size, newSize); | |
23300 | T *w = d->array + newSize; | |
23301 | T *i = l.d->array + l.d->size; | |
23302 | T *b = l.d->array; | |
23303 | while (i != b) { | |
23304 | if (QTypeInfo<T>::isComplex) | |
23305 | new (--w) T(*--i); | |
23306 | else | |
23307 | *--w = *--i; | |
23308 | } | |
23309 | d->size = newSize; | |
23310 | return *this; | |
23311 | } | |
23312 | template <typename T> | |
23313 | int QVector<T>::indexOf(const T &t, int from) const | |
23314 | { | |
23315 | if (from < 0) | |
23316 | from = qMax(from + d->size, 0); | |
23317 | if (from < d->size) { | |
23318 | T* n = d->array + from - 1; | |
23319 | T* e = d->array + d->size; | |
23320 | while (++n != e) | |
23321 | if (*n == t) | |
23322 | return n - d->array; | |
23323 | } | |
23324 | return -1; | |
23325 | } | |
23326 | template <typename T> | |
23327 | int QVector<T>::lastIndexOf(const T &t, int from) const | |
23328 | { | |
23329 | if (from < 0) | |
23330 | from += d->size; | |
23331 | else if (from >= d->size) | |
23332 | from = d->size-1; | |
23333 | if (from >= 0) { | |
23334 | T* b = d->array; | |
23335 | T* n = d->array + from + 1; | |
23336 | while (n != b) { | |
23337 | if (*--n == t) | |
23338 | return n - b; | |
23339 | } | |
23340 | } | |
23341 | return -1; | |
23342 | } | |
23343 | template <typename T> | |
23344 | bool QVector<T>::contains(const T &t) const | |
23345 | { | |
23346 | T* b = d->array; | |
23347 | T* i = d->array + d->size; | |
23348 | while (i != b) | |
23349 | if (*--i == t) | |
23350 | return true; | |
23351 | return false; | |
23352 | } | |
23353 | template <typename T> | |
23354 | int QVector<T>::count(const T &t) const | |
23355 | { | |
23356 | int c = 0; | |
23357 | T* b = d->array; | |
23358 | T* i = d->array + d->size; | |
23359 | while (i != b) | |
23360 | if (*--i == t) | |
23361 | ++c; | |
23362 | return c; | |
23363 | } | |
23364 | template <typename T> | |
23365 | QVector<T> QVector<T>::mid(int pos, int length) const | |
23366 | { | |
23367 | if (length < 0) | |
23368 | length = size() - pos; | |
23369 | if (pos == 0 && length == size()) | |
23370 | return *this; | |
23371 | QVector<T> copy; | |
23372 | if (pos + length > size()) | |
23373 | length = size() - pos; | |
23374 | for (int i = pos; i < pos + length; ++i) | |
23375 | copy += at(i); | |
23376 | return copy; | |
23377 | } | |
23378 | template <typename T> | |
23379 | QList<T> QVector<T>::toList() const | |
23380 | { | |
23381 | QList<T> result; | |
23382 | for (int i = 0; i < size(); ++i) | |
23383 | result.append(at(i)); | |
23384 | return result; | |
23385 | } | |
23386 | template <typename T> | |
23387 | QVector<T> QList<T>::toVector() const | |
23388 | { | |
23389 | QVector<T> result(size()); | |
23390 | for (int i = 0; i < size(); ++i) | |
23391 | result[i] = at(i); | |
23392 | return result; | |
23393 | } | |
23394 | template <typename T> | |
23395 | QVector<T> QVector<T>::fromList(const QList<T> &list) | |
23396 | { | |
23397 | return list.toVector(); | |
23398 | } | |
23399 | template <typename T> | |
23400 | QList<T> QList<T>::fromVector(const QVector<T> &vector) | |
23401 | { | |
23402 | return vector.toList(); | |
23403 | } | |
23404 | template <class T> class QVectorIterator { typedef typename QVector<T>::const_iterator const_iterator; QVector<T> c; const_iterator i; public: inline QVectorIterator(const QVector<T> &container) : c(container), i(c.constBegin()) {} inline QVectorIterator &operator=(const QVector<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } }; | |
23405 | template <class T> class QMutableVectorIterator { typedef typename QVector<T>::iterator iterator; typedef typename QVector<T>::const_iterator const_iterator; QVector<T> *c; iterator i, n; inline bool item_exists() const { return const_iterator(n) != c->constEnd(); } public: inline QMutableVectorIterator(QVector<T> &container) : c(&container) { c->setSharable(false); i = c->begin(); n = c->end(); } inline ~QMutableVectorIterator() { c->setSharable(true); } inline QMutableVectorIterator &operator=(QVector<T> &container) { c->setSharable(true); c = &container; c->setSharable(false); i = c->begin(); n = c->end(); return *this; } inline void toFront() { i = c->begin(); n = c->end(); } inline void toBack() { i = c->end(); n = i; } inline bool hasNext() const { return c->constEnd() != const_iterator(i); } inline T &next() { n = i++; return *n; } inline T &peekNext() const { return *i; } inline bool hasPrevious() const { return c->constBegin() != const_iterator(i); } inline T &previous() { n = --i; return *n; } inline T &peekPrevious() const { iterator p = i; return *--p; } inline void remove() { if (c->constEnd() != const_iterator(n)) { i = c->erase(n); n = c->end(); } } inline void setValue(const T &t) const { if (c->constEnd() != const_iterator(n)) *n = t; } inline T &value() { qt_noop(); return *n; } inline const T &value() const { qt_noop(); return *n; } inline void insert(const T &t) { n = i = c->insert(i, t); ++i; } inline bool findNext(const T &t) { while (c->constEnd() != const_iterator(n = i)) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (c->constBegin() != const_iterator(i)) if (*(n = --i) == t) return true; n = c->end(); return false; } }; | |
23406 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
23407 | template <class T> | |
23408 | class QSet | |
23409 | { | |
23410 | typedef QHash<T, QHashDummyValue> Hash; | |
23411 | public: | |
23412 | inline QSet() {} | |
23413 | inline QSet(const QSet<T> &other) : q_hash(other.q_hash) {} | |
23414 | inline QSet<T> &operator=(const QSet<T> &other) | |
23415 | { q_hash = other.q_hash; return *this; } | |
23416 | inline bool operator==(const QSet<T> &other) const | |
23417 | { return q_hash == other.q_hash; } | |
23418 | inline bool operator!=(const QSet<T> &other) const | |
23419 | { return q_hash != other.q_hash; } | |
23420 | inline int size() const { return q_hash.size(); } | |
23421 | inline bool isEmpty() const { return q_hash.isEmpty(); } | |
23422 | inline int capacity() const { return q_hash.capacity(); } | |
23423 | inline void reserve(int size); | |
23424 | inline void squeeze() { q_hash.squeeze(); } | |
23425 | inline void detach() { q_hash.detach(); } | |
23426 | inline bool isDetached() const { return q_hash.isDetached(); } | |
23427 | inline void setSharable(bool sharable) { q_hash.setSharable(sharable); } | |
23428 | inline void clear() { q_hash.clear(); } | |
23429 | inline bool remove(const T &value) { return q_hash.remove(value) != 0; } | |
23430 | inline bool contains(const T &value) const { return q_hash.contains(value); } | |
23431 | class const_iterator; | |
23432 | class iterator | |
23433 | { | |
23434 | typedef QHash<T, QHashDummyValue> Hash; | |
23435 | typename Hash::iterator i; | |
23436 | friend class const_iterator; | |
23437 | public: | |
23438 | typedef std::bidirectional_iterator_tag iterator_category; | |
23439 | typedef ptrdiff_t difference_type; | |
23440 | typedef T value_type; | |
23441 | typedef const T *pointer; | |
23442 | typedef const T &reference; | |
23443 | inline iterator() {} | |
23444 | inline iterator(typename Hash::iterator o) : i(o) {} | |
23445 | inline iterator(const iterator &o) : i(o.i) {} | |
23446 | inline iterator &operator=(const iterator &o) { i = o.i; return *this; } | |
23447 | inline const T &operator*() const { return i.key(); } | |
23448 | inline const T *operator->() const { return &i.key(); } | |
23449 | inline bool operator==(const iterator &o) const { return i == o.i; } | |
23450 | inline bool operator!=(const iterator &o) const { return i != o.i; } | |
23451 | inline bool operator==(const const_iterator &o) const | |
23452 | { return i == o.i; } | |
23453 | inline bool operator!=(const const_iterator &o) const | |
23454 | { return i != o.i; } | |
23455 | inline iterator &operator++() { ++i; return *this; } | |
23456 | inline iterator operator++(int) { iterator r = *this; ++i; return r; } | |
23457 | inline iterator &operator--() { --i; return *this; } | |
23458 | inline iterator operator--(int) { iterator r = *this; --i; return r; } | |
23459 | inline iterator operator+(int j) const { return i + j; } | |
23460 | inline iterator operator-(int j) const { return i - j; } | |
23461 | inline iterator &operator+=(int j) { i += j; return *this; } | |
23462 | inline iterator &operator-=(int j) { i -= j; return *this; } | |
23463 | }; | |
23464 | class const_iterator | |
23465 | { | |
23466 | typedef QHash<T, QHashDummyValue> Hash; | |
23467 | typename Hash::const_iterator i; | |
23468 | friend class iterator; | |
23469 | public: | |
23470 | typedef std::bidirectional_iterator_tag iterator_category; | |
23471 | typedef ptrdiff_t difference_type; | |
23472 | typedef T value_type; | |
23473 | typedef const T *pointer; | |
23474 | typedef const T &reference; | |
23475 | inline const_iterator() {} | |
23476 | inline const_iterator(typename Hash::const_iterator o) : i(o) {} | |
23477 | inline const_iterator(const const_iterator &o) : i(o.i) {} | |
23478 | inline const_iterator(const iterator &o) | |
23479 | : i(o.i) {} | |
23480 | inline const_iterator &operator=(const const_iterator &o) { i = o.i; return *this; } | |
23481 | inline const T &operator*() const { return i.key(); } | |
23482 | inline const T *operator->() const { return &i.key(); } | |
23483 | inline bool operator==(const const_iterator &o) const { return i == o.i; } | |
23484 | inline bool operator!=(const const_iterator &o) const { return i != o.i; } | |
23485 | inline const_iterator &operator++() { ++i; return *this; } | |
23486 | inline const_iterator operator++(int) { const_iterator r = *this; ++i; return r; } | |
23487 | inline const_iterator &operator--() { --i; return *this; } | |
23488 | inline const_iterator operator--(int) { const_iterator r = *this; --i; return r; } | |
23489 | inline const_iterator operator+(int j) const { return i + j; } | |
23490 | inline const_iterator operator-(int j) const { return i - j; } | |
23491 | inline const_iterator &operator+=(int j) { i += j; return *this; } | |
23492 | inline const_iterator &operator-=(int j) { i -= j; return *this; } | |
23493 | }; | |
23494 | inline iterator begin() { return q_hash.begin(); } | |
23495 | inline const_iterator begin() const { return q_hash.begin(); } | |
23496 | inline const_iterator constBegin() const { return q_hash.constBegin(); } | |
23497 | inline iterator end() { return q_hash.end(); } | |
23498 | inline const_iterator end() const { return q_hash.end(); } | |
23499 | inline const_iterator constEnd() const { return q_hash.constEnd(); } | |
23500 | iterator erase(iterator i) | |
23501 | { return q_hash.erase(reinterpret_cast<typename Hash::iterator &>(i)); } | |
23502 | typedef iterator Iterator; | |
23503 | typedef const_iterator ConstIterator; | |
23504 | inline int count() const { return q_hash.count(); } | |
23505 | inline const_iterator insert(const T &value) | |
23506 | { return static_cast<typename Hash::const_iterator>(q_hash.insert(value, | |
23507 | QHashDummyValue())); } | |
23508 | iterator find(const T &value) { return q_hash.find(value); } | |
23509 | const_iterator find(const T &value) const { return q_hash.find(value); } | |
23510 | inline const_iterator constFind(const T &value) const { return find(value); } | |
23511 | QSet<T> &unite(const QSet<T> &other); | |
23512 | QSet<T> &intersect(const QSet<T> &other); | |
23513 | QSet<T> &subtract(const QSet<T> &other); | |
23514 | typedef T key_type; | |
23515 | typedef T value_type; | |
23516 | typedef value_type *pointer; | |
23517 | typedef const value_type *const_pointer; | |
23518 | typedef value_type &reference; | |
23519 | typedef const value_type &const_reference; | |
23520 | typedef ptrdiff_t difference_type; | |
23521 | typedef int size_type; | |
23522 | inline bool empty() const { return isEmpty(); } | |
23523 | inline QSet<T> &operator<<(const T &value) { insert(value); return *this; } | |
23524 | inline QSet<T> &operator|=(const QSet<T> &other) { unite(other); return *this; } | |
23525 | inline QSet<T> &operator|=(const T &value) { insert(value); return *this; } | |
23526 | inline QSet<T> &operator&=(const QSet<T> &other) { intersect(other); return *this; } | |
23527 | inline QSet<T> &operator&=(const T &value) | |
23528 | { QSet<T> result; if (contains(value)) result.insert(value); return (*this = result); } | |
23529 | inline QSet<T> &operator+=(const QSet<T> &other) { unite(other); return *this; } | |
23530 | inline QSet<T> &operator+=(const T &value) { insert(value); return *this; } | |
23531 | inline QSet<T> &operator-=(const QSet<T> &other) { subtract(other); return *this; } | |
23532 | inline QSet<T> &operator-=(const T &value) { remove(value); return *this; } | |
23533 | inline QSet<T> operator|(const QSet<T> &other) const | |
23534 | { QSet<T> result = *this; result |= other; return result; } | |
23535 | inline QSet<T> operator&(const QSet<T> &other) const | |
23536 | { QSet<T> result = *this; result &= other; return result; } | |
23537 | inline QSet<T> operator+(const QSet<T> &other) const | |
23538 | { QSet<T> result = *this; result += other; return result; } | |
23539 | inline QSet<T> operator-(const QSet<T> &other) const | |
23540 | { QSet<T> result = *this; result -= other; return result; } | |
23541 | inline QSet<T> operator|(const QSet<T> &other) | |
23542 | { QSet<T> result = *this; result |= other; return result; } | |
23543 | inline QSet<T> operator&(const QSet<T> &other) | |
23544 | { QSet<T> result = *this; result &= other; return result; } | |
23545 | inline QSet<T> operator+(const QSet<T> &other) | |
23546 | { QSet<T> result = *this; result += other; return result; } | |
23547 | inline QSet<T> operator-(const QSet<T> &other) | |
23548 | { QSet<T> result = *this; result -= other; return result; } | |
23549 | QList<T> toList() const; | |
23550 | inline QList<T> values() const { return toList(); } | |
23551 | static QSet<T> fromList(const QList<T> &list); | |
23552 | private: | |
23553 | Hash q_hash; | |
23554 | }; | |
23555 | template <class T> | |
23556 | inline void QSet<T>::reserve(int asize) { q_hash.reserve(asize); } | |
23557 | template <class T> | |
23558 | inline QSet<T> &QSet<T>::unite(const QSet<T> &other) | |
23559 | { | |
23560 | QSet<T> copy(other); | |
23561 | typename QSet<T>::const_iterator i = copy.constEnd(); | |
23562 | while (i != copy.constBegin()) { | |
23563 | --i; | |
23564 | insert(*i); | |
23565 | } | |
23566 | return *this; | |
23567 | } | |
23568 | template <class T> | |
23569 | inline QSet<T> &QSet<T>::intersect(const QSet<T> &other) | |
23570 | { | |
23571 | QSet<T> copy1(*this); | |
23572 | QSet<T> copy2(other); | |
23573 | typename QSet<T>::const_iterator i = copy1.constEnd(); | |
23574 | while (i != copy1.constBegin()) { | |
23575 | --i; | |
23576 | if (!copy2.contains(*i)) | |
23577 | remove(*i); | |
23578 | } | |
23579 | return *this; | |
23580 | } | |
23581 | template <class T> | |
23582 | inline QSet<T> &QSet<T>::subtract(const QSet<T> &other) | |
23583 | { | |
23584 | QSet<T> copy1(*this); | |
23585 | QSet<T> copy2(other); | |
23586 | typename QSet<T>::const_iterator i = copy1.constEnd(); | |
23587 | while (i != copy1.constBegin()) { | |
23588 | --i; | |
23589 | if (copy2.contains(*i)) | |
23590 | remove(*i); | |
23591 | } | |
23592 | return *this; | |
23593 | } | |
23594 | template <typename T> | |
23595 | QList<T> QSet<T>::toList() const | |
23596 | { | |
23597 | QList<T> result; | |
23598 | typename QSet<T>::const_iterator i = constBegin(); | |
23599 | while (i != constEnd()) { | |
23600 | result.append(*i); | |
23601 | ++i; | |
23602 | } | |
23603 | return result; | |
23604 | } | |
23605 | template <typename T> | |
23606 | QSet<T> QList<T>::toSet() const | |
23607 | { | |
23608 | QSet<T> result; | |
23609 | result.reserve(size()); | |
23610 | for (int i = 0; i < size(); ++i) | |
23611 | result.insert(at(i)); | |
23612 | return result; | |
23613 | } | |
23614 | template <typename T> | |
23615 | QSet<T> QSet<T>::fromList(const QList<T> &list) | |
23616 | { | |
23617 | return list.toSet(); | |
23618 | } | |
23619 | template <typename T> | |
23620 | QList<T> QList<T>::fromSet(const QSet<T> &set) | |
23621 | { | |
23622 | return set.toList(); | |
23623 | } | |
23624 | template <class T> class QSetIterator { typedef typename QSet<T>::const_iterator const_iterator; QSet<T> c; const_iterator i; public: inline QSetIterator(const QSet<T> &container) : c(container), i(c.constBegin()) {} inline QSetIterator &operator=(const QSet<T> &container) { c = container; i = c.constBegin(); return *this; } inline void toFront() { i = c.constBegin(); } inline void toBack() { i = c.constEnd(); } inline bool hasNext() const { return i != c.constEnd(); } inline const T &next() { return *i++; } inline const T &peekNext() const { return *i; } inline bool hasPrevious() const { return i != c.constBegin(); } inline const T &previous() { return *--i; } inline const T &peekPrevious() const { const_iterator p = i; return *--p; } inline bool findNext(const T &t) { while (i != c.constEnd()) if (*i++ == t) return true; return false; } inline bool findPrevious(const T &t) { while (i != c.constBegin()) if (*(--i) == t) return true; return false; } }; | |
23625 | template <typename T> | |
23626 | class QMutableSetIterator | |
23627 | { | |
23628 | typedef typename QSet<T>::iterator iterator; | |
23629 | QSet<T> *c; | |
23630 | iterator i, n; | |
23631 | inline bool item_exists() const { return n != c->constEnd(); } | |
23632 | public: | |
23633 | inline QMutableSetIterator(QSet<T> &container) | |
23634 | : c(&container) | |
23635 | { c->setSharable(false); i = c->begin(); n = c->end(); } | |
23636 | inline ~QMutableSetIterator() | |
23637 | { c->setSharable(true); } | |
23638 | inline QMutableSetIterator &operator=(QSet<T> &container) | |
23639 | { c->setSharable(true); c = &container; c->setSharable(false); | |
23640 | i = c->begin(); n = c->end(); return *this; } | |
23641 | inline void toFront() { i = c->begin(); n = c->end(); } | |
23642 | inline void toBack() { i = c->end(); n = i; } | |
23643 | inline bool hasNext() const { return c->constEnd() != i; } | |
23644 | inline const T &next() { n = i++; return *n; } | |
23645 | inline const T &peekNext() const { return *i; } | |
23646 | inline bool hasPrevious() const { return c->constBegin() != i; } | |
23647 | inline const T &previous() { n = --i; return *n; } | |
23648 | inline const T &peekPrevious() const { iterator p = i; return *--p; } | |
23649 | inline void remove() | |
23650 | { if (c->constEnd() != n) { i = c->erase(n); n = c->end(); } } | |
23651 | inline const T &value() const { qt_noop(); return *n; } | |
23652 | inline bool findNext(const T &t) | |
23653 | { while (c->constEnd() != (n = i)) if (*i++ == t) return true; return false; } | |
23654 | inline bool findPrevious(const T &t) | |
23655 | { while (c->constBegin() != i) if (*(n = --i) == t) return true; | |
23656 | n = c->end(); return false; } | |
23657 | }; | |
23658 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
23659 | class __attribute__((visibility("default"))) QDebug | |
23660 | { | |
23661 | struct Stream { | |
23662 | Stream(QIODevice *device) : ts(device), ref(1), type(QtDebugMsg), space(true), message_output(false) {} | |
23663 | Stream(QString *string) : ts(string, QIODevice::WriteOnly), ref(1), type(QtDebugMsg), space(true), message_output(false) {} | |
23664 | Stream(QtMsgType t) : ts(&buffer, QIODevice::WriteOnly), ref(1), type(t), space(true), message_output(true) {} | |
23665 | QTextStream ts; | |
23666 | QString buffer; | |
23667 | int ref; | |
23668 | QtMsgType type; | |
23669 | bool space; | |
23670 | bool message_output; | |
23671 | } *stream; | |
23672 | public: | |
23673 | inline QDebug(QIODevice *device) : stream(new Stream(device)) {} | |
23674 | inline QDebug(QString *string) : stream(new Stream(string)) {} | |
23675 | inline QDebug(QtMsgType t) : stream(new Stream(t)) {} | |
23676 | inline QDebug(const QDebug &o):stream(o.stream) { ++stream->ref; } | |
23677 | inline QDebug &operator=(const QDebug &other); | |
23678 | inline ~QDebug() { | |
23679 | if (!--stream->ref) { | |
23680 | if(stream->message_output) | |
23681 | qt_message_output(stream->type, stream->buffer.toLocal8Bit().data()); | |
23682 | delete stream; | |
23683 | } | |
23684 | } | |
23685 | inline QDebug &space() { stream->space = true; stream->ts << " "; return *this; } | |
23686 | inline QDebug &nospace() { stream->space = false; return *this; } | |
23687 | inline QDebug &maybeSpace() { if (stream->space) stream->ts << " "; return *this; } | |
23688 | inline QDebug &operator<<(QChar t) { stream->ts << "\'" << t << "\'"; return maybeSpace(); } | |
23689 | inline QDebug &operator<<(QBool t) { stream->ts << (bool(t) ? "true" : "false"); return maybeSpace(); } | |
23690 | inline QDebug &operator<<(bool t) { stream->ts << (t ? "true" : "false"); return maybeSpace(); } | |
23691 | inline QDebug &operator<<(char t) { stream->ts << t; return maybeSpace(); } | |
23692 | inline QDebug &operator<<(signed short t) { stream->ts << t; return maybeSpace(); } | |
23693 | inline QDebug &operator<<(unsigned short t) { stream->ts << t; return maybeSpace(); } | |
23694 | inline QDebug &operator<<(signed int t) { stream->ts << t; return maybeSpace(); } | |
23695 | inline QDebug &operator<<(unsigned int t) { stream->ts << t; return maybeSpace(); } | |
23696 | inline QDebug &operator<<(signed long t) { stream->ts << t; return maybeSpace(); } | |
23697 | inline QDebug &operator<<(unsigned long t) { stream->ts << t; return maybeSpace(); } | |
23698 | inline QDebug &operator<<(qint64 t) | |
23699 | { stream->ts << QString::number(t); return maybeSpace(); } | |
23700 | inline QDebug &operator<<(quint64 t) | |
23701 | { stream->ts << QString::number(t); return maybeSpace(); } | |
23702 | inline QDebug &operator<<(float t) { stream->ts << t; return maybeSpace(); } | |
23703 | inline QDebug &operator<<(double t) { stream->ts << t; return maybeSpace(); } | |
23704 | inline QDebug &operator<<(const char* t) { stream->ts << QString::fromAscii(t); return maybeSpace(); } | |
23705 | inline QDebug &operator<<(const QString & t) { stream->ts << "\"" << t << "\""; return maybeSpace(); } | |
23706 | inline QDebug &operator<<(const QStringRef & t) { return operator<<(t.toString()); } | |
23707 | inline QDebug &operator<<(const QLatin1String &t) { stream->ts << "\"" << t.latin1() << "\""; return maybeSpace(); } | |
23708 | inline QDebug &operator<<(const QByteArray & t) { stream->ts << "\"" << t << "\""; return maybeSpace(); } | |
23709 | inline QDebug &operator<<(const void * t) { stream->ts << t; return maybeSpace(); } | |
23710 | inline QDebug &operator<<(QTextStreamFunction f) { | |
23711 | stream->ts << f; | |
23712 | return *this; | |
23713 | } | |
23714 | inline QDebug &operator<<(QTextStreamManipulator m) | |
23715 | { stream->ts << m; return *this; } | |
23716 | }; | |
23717 | class QNoDebug | |
23718 | { | |
23719 | public: | |
23720 | inline QNoDebug(){} | |
23721 | inline QNoDebug(const QDebug &){} | |
23722 | inline ~QNoDebug(){} | |
23723 | inline QNoDebug &operator<<(QTextStreamFunction) { return *this; } | |
23724 | inline QNoDebug &operator<<(QTextStreamManipulator) { return *this; } | |
23725 | inline QNoDebug &space() { return *this; } | |
23726 | inline QNoDebug &nospace() { return *this; } | |
23727 | inline QNoDebug &maybeSpace() { return *this; } | |
23728 | template<typename T> | |
23729 | inline QNoDebug &operator<<(const T &) { return *this; } | |
23730 | }; | |
23731 | __attribute__((visibility("default"))) inline QDebug qCritical() { return QDebug(QtCriticalMsg); } | |
23732 | inline QDebug &QDebug::operator=(const QDebug &other) | |
23733 | { | |
23734 | if (this != &other) { | |
23735 | QDebug copy(other); | |
23736 | qSwap(stream, copy.stream); | |
23737 | } | |
23738 | return *this; | |
23739 | } | |
23740 | template <class T> | |
23741 | inline QDebug operator<<(QDebug debug, const QList<T> &list) | |
23742 | { | |
23743 | debug.nospace() << "("; | |
23744 | for (typename QList<T>::size_type i = 0; i < list.count(); ++i) { | |
23745 | if (i) | |
23746 | debug << ", "; | |
23747 | debug << list.at(i); | |
23748 | } | |
23749 | debug << ")"; | |
23750 | return debug.space(); | |
23751 | } | |
23752 | template <typename T> | |
23753 | inline QDebug operator<<(QDebug debug, const QVector<T> &vec) | |
23754 | { | |
23755 | debug.nospace() << "QVector"; | |
23756 | return operator<<(debug, vec.toList()); | |
23757 | } | |
23758 | template <class aKey, class aT> | |
23759 | inline QDebug operator<<(QDebug debug, const QMap<aKey, aT> &map) | |
23760 | { | |
23761 | debug.nospace() << "QMap("; | |
23762 | for (typename QMap<aKey, aT>::const_iterator it = map.constBegin(); | |
23763 | it != map.constEnd(); ++it) { | |
23764 | debug << "(" << it.key() << ", " << it.value() << ")"; | |
23765 | } | |
23766 | debug << ")"; | |
23767 | return debug.space(); | |
23768 | } | |
23769 | template <class aKey, class aT> | |
23770 | inline QDebug operator<<(QDebug debug, const QHash<aKey, aT> &hash) | |
23771 | { | |
23772 | debug.nospace() << "QHash("; | |
23773 | for (typename QHash<aKey, aT>::const_iterator it = hash.constBegin(); | |
23774 | it != hash.constEnd(); ++it) | |
23775 | debug << "(" << it.key() << ", " << it.value() << ")"; | |
23776 | debug << ")"; | |
23777 | return debug.space(); | |
23778 | } | |
23779 | template <class T1, class T2> | |
23780 | inline QDebug operator<<(QDebug debug, const QPair<T1, T2> &pair) | |
23781 | { | |
23782 | debug.nospace() << "QPair(" << pair.first << "," << pair.second << ")"; | |
23783 | return debug.space(); | |
23784 | } | |
23785 | template <typename T> | |
23786 | inline QDebug operator<<(QDebug debug, const QSet<T> &set) | |
23787 | { | |
23788 | debug.nospace() << "QSet"; | |
23789 | return operator<<(debug, set.toList()); | |
23790 | } | |
23791 | __attribute__((visibility("default"))) inline QDebug qDebug() { return QDebug(QtDebugMsg); } | |
23792 | __attribute__((visibility("default"))) inline QDebug qWarning() { return QDebug(QtWarningMsg); } | |
23793 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
23794 | template <class Key, class T> class QCache; | |
23795 | template <class Key, class T> class QHash; | |
23796 | template <class T> class QLinkedList; | |
23797 | template <class T> class QList; | |
23798 | template <class Key, class T> class QMap; | |
23799 | template <class Key, class T> class QMultiHash; | |
23800 | template <class Key, class T> class QMultiMap; | |
23801 | template <class T1, class T2> struct QPair; | |
23802 | template <class T> class QQueue; | |
23803 | template <class T> class QSet; | |
23804 | template <class T> class QStack; | |
23805 | template<class T, int Prealloc = 256> class QVarLengthArray; | |
23806 | template <class T> class QVector; | |
23807 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
23808 | template<class T, int Prealloc> | |
23809 | class QVarLengthArray | |
23810 | { | |
23811 | public: | |
23812 | inline explicit QVarLengthArray(int size = 0); | |
23813 | inline QVarLengthArray(const QVarLengthArray<T, Prealloc> &other) | |
23814 | : a(Prealloc), s(0), ptr(reinterpret_cast<T *>(array)) | |
23815 | { | |
23816 | append(other.constData(), other.size()); | |
23817 | } | |
23818 | inline ~QVarLengthArray() { | |
23819 | if (QTypeInfo<T>::isComplex) { | |
23820 | T *i = ptr + s; | |
23821 | while (i-- != ptr) | |
23822 | i->~T(); | |
23823 | } | |
23824 | if (ptr != reinterpret_cast<T *>(array)) | |
23825 | qFree(ptr); | |
23826 | } | |
23827 | inline QVarLengthArray<T, Prealloc> &operator=(const QVarLengthArray<T, Prealloc> &other) | |
23828 | { | |
23829 | if (this != &other) { | |
23830 | clear(); | |
23831 | append(other.constData(), other.size()); | |
23832 | } | |
23833 | return *this; | |
23834 | } | |
23835 | inline void removeLast() { | |
23836 | qt_noop(); | |
23837 | realloc(s - 1, a); | |
23838 | } | |
23839 | inline int size() const { return s; } | |
23840 | inline int count() const { return s; } | |
23841 | inline bool isEmpty() const { return (s == 0); } | |
23842 | inline void resize(int size); | |
23843 | inline void clear() { resize(0); } | |
23844 | inline int capacity() const { return a; } | |
23845 | inline void reserve(int size); | |
23846 | inline T &operator[](int idx) { | |
23847 | qt_noop(); | |
23848 | return ptr[idx]; | |
23849 | } | |
23850 | inline const T &operator[](int idx) const { | |
23851 | qt_noop(); | |
23852 | return ptr[idx]; | |
23853 | } | |
23854 | inline void append(const T &t) { | |
23855 | if (s == a) | |
23856 | realloc(s, s<<1); | |
23857 | const int idx = s++; | |
23858 | if (QTypeInfo<T>::isComplex) { | |
23859 | new (ptr + idx) T(t); | |
23860 | } else { | |
23861 | ptr[idx] = t; | |
23862 | } | |
23863 | } | |
23864 | void append(const T *buf, int size); | |
23865 | inline T *data() { return ptr; } | |
23866 | inline const T *data() const { return ptr; } | |
23867 | inline const T * constData() const { return ptr; } | |
23868 | private: | |
23869 | void realloc(int size, int alloc); | |
23870 | int a; | |
23871 | int s; | |
23872 | T *ptr; | |
23873 | union { | |
23874 | char array[sizeof(qint64) * (((Prealloc * sizeof(T)) / sizeof(qint64)) + 1)]; | |
23875 | qint64 q_for_alignment_1; | |
23876 | double q_for_alignment_2; | |
23877 | }; | |
23878 | }; | |
23879 | template <class T, int Prealloc> | |
23880 | inline QVarLengthArray<T, Prealloc>::QVarLengthArray(int asize) | |
23881 | : s(asize) { | |
23882 | if (s > Prealloc) { | |
23883 | ptr = reinterpret_cast<T *>(qMalloc(s * sizeof(T))); | |
23884 | a = s; | |
23885 | } else { | |
23886 | ptr = reinterpret_cast<T *>(array); | |
23887 | a = Prealloc; | |
23888 | } | |
23889 | if (QTypeInfo<T>::isComplex) { | |
23890 | T *i = ptr + s; | |
23891 | while (i != ptr) | |
23892 | new (--i) T; | |
23893 | } | |
23894 | } | |
23895 | template <class T, int Prealloc> | |
23896 | inline void QVarLengthArray<T, Prealloc>::resize(int asize) | |
23897 | { realloc(asize, qMax(asize, a)); } | |
23898 | template <class T, int Prealloc> | |
23899 | inline void QVarLengthArray<T, Prealloc>::reserve(int asize) | |
23900 | { if (asize > a) realloc(s, asize); } | |
23901 | template <class T, int Prealloc> | |
23902 | void QVarLengthArray<T, Prealloc>::append(const T *abuf, int asize) | |
23903 | { | |
23904 | qt_noop(); | |
23905 | if (asize <= 0) | |
23906 | return; | |
23907 | const int idx = s; | |
23908 | const int news = s + asize; | |
23909 | if (news >= a) | |
23910 | realloc(s, qMax(s<<1, news)); | |
23911 | s = news; | |
23912 | if (QTypeInfo<T>::isComplex) { | |
23913 | T *i = ptr + idx; | |
23914 | T *j = i + asize; | |
23915 | while (i < j) | |
23916 | new (i++) T(*abuf++); | |
23917 | } else { | |
23918 | qMemCopy(&ptr[idx], abuf, asize * sizeof(T)); | |
23919 | } | |
23920 | } | |
23921 | template <class T, int Prealloc> | |
23922 | void QVarLengthArray<T, Prealloc>::realloc(int asize, int aalloc) | |
23923 | { | |
23924 | qt_noop(); | |
23925 | T *oldPtr = ptr; | |
23926 | int osize = s; | |
23927 | s = asize; | |
23928 | if (aalloc != a) { | |
23929 | ptr = reinterpret_cast<T *>(qMalloc(aalloc * sizeof(T))); | |
23930 | if (ptr) { | |
23931 | a = aalloc; | |
23932 | if (QTypeInfo<T>::isStatic) { | |
23933 | T *i = ptr + osize; | |
23934 | T *j = oldPtr + osize; | |
23935 | while (i != ptr) { | |
23936 | new (--i) T(*--j); | |
23937 | j->~T(); | |
23938 | } | |
23939 | } else { | |
23940 | qMemCopy(ptr, oldPtr, osize * sizeof(T)); | |
23941 | } | |
23942 | } else { | |
23943 | ptr = oldPtr; | |
23944 | s = 0; | |
23945 | asize = 0; | |
23946 | } | |
23947 | } | |
23948 | if (QTypeInfo<T>::isComplex) { | |
23949 | if (asize < osize) { | |
23950 | T *i = oldPtr + osize; | |
23951 | T *j = oldPtr + asize; | |
23952 | while (i-- != j) | |
23953 | i->~T(); | |
23954 | } else { | |
23955 | T *i = ptr + asize; | |
23956 | T *j = ptr + osize; | |
23957 | while (i != j) | |
23958 | new (--i) T; | |
23959 | } | |
23960 | } | |
23961 | if (oldPtr != reinterpret_cast<T *>(array) && oldPtr != ptr) | |
23962 | qFree(oldPtr); | |
23963 | } | |
23964 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
23965 | class __attribute__((visibility("default"))) QSize | |
23966 | { | |
23967 | public: | |
23968 | QSize(); | |
23969 | QSize(int w, int h); | |
23970 | bool isNull() const; | |
23971 | bool isEmpty() const; | |
23972 | bool isValid() const; | |
23973 | int width() const; | |
23974 | int height() const; | |
23975 | void setWidth(int w); | |
23976 | void setHeight(int h); | |
23977 | void transpose(); | |
23978 | void scale(int w, int h, Qt::AspectRatioMode mode); | |
23979 | void scale(const QSize &s, Qt::AspectRatioMode mode); | |
23980 | QSize expandedTo(const QSize &) const; | |
23981 | QSize boundedTo(const QSize &) const; | |
23982 | int &rwidth(); | |
23983 | int &rheight(); | |
23984 | QSize &operator+=(const QSize &); | |
23985 | QSize &operator-=(const QSize &); | |
23986 | QSize &operator*=(qreal c); | |
23987 | QSize &operator/=(qreal c); | |
23988 | friend inline bool operator==(const QSize &, const QSize &); | |
23989 | friend inline bool operator!=(const QSize &, const QSize &); | |
23990 | friend inline const QSize operator+(const QSize &, const QSize &); | |
23991 | friend inline const QSize operator-(const QSize &, const QSize &); | |
23992 | friend inline const QSize operator*(const QSize &, qreal); | |
23993 | friend inline const QSize operator*(qreal, const QSize &); | |
23994 | friend inline const QSize operator/(const QSize &, qreal); | |
23995 | private: | |
23996 | int wd; | |
23997 | int ht; | |
23998 | }; | |
23999 | template <> class QTypeInfo<QSize> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSize)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSize"; } }; | |
24000 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QSize &); | |
24001 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QSize &); | |
24002 | inline QSize::QSize() | |
24003 | { wd = ht = -1; } | |
24004 | inline QSize::QSize(int w, int h) | |
24005 | { wd = w; ht = h; } | |
24006 | inline bool QSize::isNull() const | |
24007 | { return wd==0 && ht==0; } | |
24008 | inline bool QSize::isEmpty() const | |
24009 | { return wd<1 || ht<1; } | |
24010 | inline bool QSize::isValid() const | |
24011 | { return wd>=0 && ht>=0; } | |
24012 | inline int QSize::width() const | |
24013 | { return wd; } | |
24014 | inline int QSize::height() const | |
24015 | { return ht; } | |
24016 | inline void QSize::setWidth(int w) | |
24017 | { wd = w; } | |
24018 | inline void QSize::setHeight(int h) | |
24019 | { ht = h; } | |
24020 | inline void QSize::scale(int w, int h, Qt::AspectRatioMode mode) | |
24021 | { scale(QSize(w, h), mode); } | |
24022 | inline int &QSize::rwidth() | |
24023 | { return wd; } | |
24024 | inline int &QSize::rheight() | |
24025 | { return ht; } | |
24026 | inline QSize &QSize::operator+=(const QSize &s) | |
24027 | { wd+=s.wd; ht+=s.ht; return *this; } | |
24028 | inline QSize &QSize::operator-=(const QSize &s) | |
24029 | { wd-=s.wd; ht-=s.ht; return *this; } | |
24030 | inline QSize &QSize::operator*=(qreal c) | |
24031 | { wd = qRound(wd*c); ht = qRound(ht*c); return *this; } | |
24032 | inline bool operator==(const QSize &s1, const QSize &s2) | |
24033 | { return s1.wd == s2.wd && s1.ht == s2.ht; } | |
24034 | inline bool operator!=(const QSize &s1, const QSize &s2) | |
24035 | { return s1.wd != s2.wd || s1.ht != s2.ht; } | |
24036 | inline const QSize operator+(const QSize & s1, const QSize & s2) | |
24037 | { return QSize(s1.wd+s2.wd, s1.ht+s2.ht); } | |
24038 | inline const QSize operator-(const QSize &s1, const QSize &s2) | |
24039 | { return QSize(s1.wd-s2.wd, s1.ht-s2.ht); } | |
24040 | inline const QSize operator*(const QSize &s, qreal c) | |
24041 | { return QSize(qRound(s.wd*c), qRound(s.ht*c)); } | |
24042 | inline const QSize operator*(qreal c, const QSize &s) | |
24043 | { return QSize(qRound(s.wd*c), qRound(s.ht*c)); } | |
24044 | inline QSize &QSize::operator/=(qreal c) | |
24045 | { | |
24046 | qt_noop(); | |
24047 | wd = qRound(wd/c); ht = qRound(ht/c); | |
24048 | return *this; | |
24049 | } | |
24050 | inline const QSize operator/(const QSize &s, qreal c) | |
24051 | { | |
24052 | qt_noop(); | |
24053 | return QSize(qRound(s.wd/c), qRound(s.ht/c)); | |
24054 | } | |
24055 | inline QSize QSize::expandedTo(const QSize & otherSize) const | |
24056 | { | |
24057 | return QSize(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht)); | |
24058 | } | |
24059 | inline QSize QSize::boundedTo(const QSize & otherSize) const | |
24060 | { | |
24061 | return QSize(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht)); | |
24062 | } | |
24063 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QSize &); | |
24064 | class __attribute__((visibility("default"))) QSizeF | |
24065 | { | |
24066 | public: | |
24067 | QSizeF(); | |
24068 | QSizeF(const QSize &sz); | |
24069 | QSizeF(qreal w, qreal h); | |
24070 | bool isNull() const; | |
24071 | bool isEmpty() const; | |
24072 | bool isValid() const; | |
24073 | qreal width() const; | |
24074 | qreal height() const; | |
24075 | void setWidth(qreal w); | |
24076 | void setHeight(qreal h); | |
24077 | void transpose(); | |
24078 | void scale(qreal w, qreal h, Qt::AspectRatioMode mode); | |
24079 | void scale(const QSizeF &s, Qt::AspectRatioMode mode); | |
24080 | QSizeF expandedTo(const QSizeF &) const; | |
24081 | QSizeF boundedTo(const QSizeF &) const; | |
24082 | qreal &rwidth(); | |
24083 | qreal &rheight(); | |
24084 | QSizeF &operator+=(const QSizeF &); | |
24085 | QSizeF &operator-=(const QSizeF &); | |
24086 | QSizeF &operator*=(qreal c); | |
24087 | QSizeF &operator/=(qreal c); | |
24088 | friend inline bool operator==(const QSizeF &, const QSizeF &); | |
24089 | friend inline bool operator!=(const QSizeF &, const QSizeF &); | |
24090 | friend inline const QSizeF operator+(const QSizeF &, const QSizeF &); | |
24091 | friend inline const QSizeF operator-(const QSizeF &, const QSizeF &); | |
24092 | friend inline const QSizeF operator*(const QSizeF &, qreal); | |
24093 | friend inline const QSizeF operator*(qreal, const QSizeF &); | |
24094 | friend inline const QSizeF operator/(const QSizeF &, qreal); | |
24095 | inline QSize toSize() const; | |
24096 | private: | |
24097 | qreal wd; | |
24098 | qreal ht; | |
24099 | }; | |
24100 | template <> class QTypeInfo<QSizeF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QSizeF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QSizeF"; } }; | |
24101 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QSizeF &); | |
24102 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QSizeF &); | |
24103 | inline QSizeF::QSizeF() | |
24104 | { wd = ht = -1.; } | |
24105 | inline QSizeF::QSizeF(const QSize &sz) | |
24106 | : wd(sz.width()), ht(sz.height()) | |
24107 | { | |
24108 | } | |
24109 | inline QSizeF::QSizeF(qreal w, qreal h) | |
24110 | { wd = w; ht = h; } | |
24111 | inline bool QSizeF::isNull() const | |
24112 | { return qIsNull(wd) && qIsNull(ht); } | |
24113 | inline bool QSizeF::isEmpty() const | |
24114 | { return wd <= 0. || ht <= 0.; } | |
24115 | inline bool QSizeF::isValid() const | |
24116 | { return wd >= 0. && ht >= 0.; } | |
24117 | inline qreal QSizeF::width() const | |
24118 | { return wd; } | |
24119 | inline qreal QSizeF::height() const | |
24120 | { return ht; } | |
24121 | inline void QSizeF::setWidth(qreal w) | |
24122 | { wd = w; } | |
24123 | inline void QSizeF::setHeight(qreal h) | |
24124 | { ht = h; } | |
24125 | inline void QSizeF::scale(qreal w, qreal h, Qt::AspectRatioMode mode) | |
24126 | { scale(QSizeF(w, h), mode); } | |
24127 | inline qreal &QSizeF::rwidth() | |
24128 | { return wd; } | |
24129 | inline qreal &QSizeF::rheight() | |
24130 | { return ht; } | |
24131 | inline QSizeF &QSizeF::operator+=(const QSizeF &s) | |
24132 | { wd += s.wd; ht += s.ht; return *this; } | |
24133 | inline QSizeF &QSizeF::operator-=(const QSizeF &s) | |
24134 | { wd -= s.wd; ht -= s.ht; return *this; } | |
24135 | inline QSizeF &QSizeF::operator*=(qreal c) | |
24136 | { wd *= c; ht *= c; return *this; } | |
24137 | inline bool operator==(const QSizeF &s1, const QSizeF &s2) | |
24138 | { return qFuzzyCompare(s1.wd, s2.wd) && qFuzzyCompare(s1.ht, s2.ht); } | |
24139 | inline bool operator!=(const QSizeF &s1, const QSizeF &s2) | |
24140 | { return !qFuzzyCompare(s1.wd, s2.wd) || !qFuzzyCompare(s1.ht, s2.ht); } | |
24141 | inline const QSizeF operator+(const QSizeF & s1, const QSizeF & s2) | |
24142 | { return QSizeF(s1.wd+s2.wd, s1.ht+s2.ht); } | |
24143 | inline const QSizeF operator-(const QSizeF &s1, const QSizeF &s2) | |
24144 | { return QSizeF(s1.wd-s2.wd, s1.ht-s2.ht); } | |
24145 | inline const QSizeF operator*(const QSizeF &s, qreal c) | |
24146 | { return QSizeF(s.wd*c, s.ht*c); } | |
24147 | inline const QSizeF operator*(qreal c, const QSizeF &s) | |
24148 | { return QSizeF(s.wd*c, s.ht*c); } | |
24149 | inline QSizeF &QSizeF::operator/=(qreal c) | |
24150 | { | |
24151 | qt_noop(); | |
24152 | wd = wd/c; ht = ht/c; | |
24153 | return *this; | |
24154 | } | |
24155 | inline const QSizeF operator/(const QSizeF &s, qreal c) | |
24156 | { | |
24157 | qt_noop(); | |
24158 | return QSizeF(s.wd/c, s.ht/c); | |
24159 | } | |
24160 | inline QSizeF QSizeF::expandedTo(const QSizeF & otherSize) const | |
24161 | { | |
24162 | return QSizeF(qMax(wd,otherSize.wd), qMax(ht,otherSize.ht)); | |
24163 | } | |
24164 | inline QSizeF QSizeF::boundedTo(const QSizeF & otherSize) const | |
24165 | { | |
24166 | return QSizeF(qMin(wd,otherSize.wd), qMin(ht,otherSize.ht)); | |
24167 | } | |
24168 | inline QSize QSizeF::toSize() const | |
24169 | { | |
24170 | return QSize(qRound(wd), qRound(ht)); | |
24171 | } | |
24172 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QSizeF &); | |
24173 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
24174 | class __attribute__((visibility("default"))) QPoint | |
24175 | { | |
24176 | public: | |
24177 | QPoint(); | |
24178 | QPoint(int xpos, int ypos); | |
24179 | bool isNull() const; | |
24180 | int x() const; | |
24181 | int y() const; | |
24182 | void setX(int x); | |
24183 | void setY(int y); | |
24184 | int manhattanLength() const; | |
24185 | int &rx(); | |
24186 | int &ry(); | |
24187 | QPoint &operator+=(const QPoint &p); | |
24188 | QPoint &operator-=(const QPoint &p); | |
24189 | QPoint &operator*=(qreal c); | |
24190 | QPoint &operator/=(qreal c); | |
24191 | friend inline bool operator==(const QPoint &, const QPoint &); | |
24192 | friend inline bool operator!=(const QPoint &, const QPoint &); | |
24193 | friend inline const QPoint operator+(const QPoint &, const QPoint &); | |
24194 | friend inline const QPoint operator-(const QPoint &, const QPoint &); | |
24195 | friend inline const QPoint operator*(const QPoint &, qreal); | |
24196 | friend inline const QPoint operator*(qreal, const QPoint &); | |
24197 | friend inline const QPoint operator-(const QPoint &); | |
24198 | friend inline const QPoint operator/(const QPoint &, qreal); | |
24199 | private: | |
24200 | friend class QTransform; | |
24201 | int xp; | |
24202 | int yp; | |
24203 | }; | |
24204 | template <> class QTypeInfo<QPoint> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPoint"; } }; | |
24205 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPoint &); | |
24206 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPoint &); | |
24207 | inline QPoint::QPoint() | |
24208 | { xp=0; yp=0; } | |
24209 | inline QPoint::QPoint(int xpos, int ypos) | |
24210 | { xp = xpos; yp = ypos; } | |
24211 | inline bool QPoint::isNull() const | |
24212 | { return xp == 0 && yp == 0; } | |
24213 | inline int QPoint::x() const | |
24214 | { return xp; } | |
24215 | inline int QPoint::y() const | |
24216 | { return yp; } | |
24217 | inline void QPoint::setX(int xpos) | |
24218 | { xp = xpos; } | |
24219 | inline void QPoint::setY(int ypos) | |
24220 | { yp = ypos; } | |
24221 | inline int &QPoint::rx() | |
24222 | { return xp; } | |
24223 | inline int &QPoint::ry() | |
24224 | { return yp; } | |
24225 | inline QPoint &QPoint::operator+=(const QPoint &p) | |
24226 | { xp+=p.xp; yp+=p.yp; return *this; } | |
24227 | inline QPoint &QPoint::operator-=(const QPoint &p) | |
24228 | { xp-=p.xp; yp-=p.yp; return *this; } | |
24229 | inline QPoint &QPoint::operator*=(qreal c) | |
24230 | { xp = qRound(xp*c); yp = qRound(yp*c); return *this; } | |
24231 | inline bool operator==(const QPoint &p1, const QPoint &p2) | |
24232 | { return p1.xp == p2.xp && p1.yp == p2.yp; } | |
24233 | inline bool operator!=(const QPoint &p1, const QPoint &p2) | |
24234 | { return p1.xp != p2.xp || p1.yp != p2.yp; } | |
24235 | inline const QPoint operator+(const QPoint &p1, const QPoint &p2) | |
24236 | { return QPoint(p1.xp+p2.xp, p1.yp+p2.yp); } | |
24237 | inline const QPoint operator-(const QPoint &p1, const QPoint &p2) | |
24238 | { return QPoint(p1.xp-p2.xp, p1.yp-p2.yp); } | |
24239 | inline const QPoint operator*(const QPoint &p, qreal c) | |
24240 | { return QPoint(qRound(p.xp*c), qRound(p.yp*c)); } | |
24241 | inline const QPoint operator*(qreal c, const QPoint &p) | |
24242 | { return QPoint(qRound(p.xp*c), qRound(p.yp*c)); } | |
24243 | inline const QPoint operator-(const QPoint &p) | |
24244 | { return QPoint(-p.xp, -p.yp); } | |
24245 | inline QPoint &QPoint::operator/=(qreal c) | |
24246 | { | |
24247 | xp = qRound(xp/c); | |
24248 | yp = qRound(yp/c); | |
24249 | return *this; | |
24250 | } | |
24251 | inline const QPoint operator/(const QPoint &p, qreal c) | |
24252 | { | |
24253 | return QPoint(qRound(p.xp/c), qRound(p.yp/c)); | |
24254 | } | |
24255 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QPoint &); | |
24256 | class __attribute__((visibility("default"))) QPointF | |
24257 | { | |
24258 | public: | |
24259 | QPointF(); | |
24260 | QPointF(const QPoint &p); | |
24261 | QPointF(qreal xpos, qreal ypos); | |
24262 | bool isNull() const; | |
24263 | qreal x() const; | |
24264 | qreal y() const; | |
24265 | void setX(qreal x); | |
24266 | void setY(qreal y); | |
24267 | qreal &rx(); | |
24268 | qreal &ry(); | |
24269 | QPointF &operator+=(const QPointF &p); | |
24270 | QPointF &operator-=(const QPointF &p); | |
24271 | QPointF &operator*=(qreal c); | |
24272 | QPointF &operator/=(qreal c); | |
24273 | friend inline bool operator==(const QPointF &, const QPointF &); | |
24274 | friend inline bool operator!=(const QPointF &, const QPointF &); | |
24275 | friend inline const QPointF operator+(const QPointF &, const QPointF &); | |
24276 | friend inline const QPointF operator-(const QPointF &, const QPointF &); | |
24277 | friend inline const QPointF operator*(qreal, const QPointF &); | |
24278 | friend inline const QPointF operator*(const QPointF &, qreal); | |
24279 | friend inline const QPointF operator-(const QPointF &); | |
24280 | friend inline const QPointF operator/(const QPointF &, qreal); | |
24281 | QPoint toPoint() const; | |
24282 | private: | |
24283 | friend class QMatrix; | |
24284 | friend class QTransform; | |
24285 | qreal xp; | |
24286 | qreal yp; | |
24287 | }; | |
24288 | template <> class QTypeInfo<QPointF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPointF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPointF"; } }; | |
24289 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPointF &); | |
24290 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPointF &); | |
24291 | inline QPointF::QPointF() : xp(0), yp(0) { } | |
24292 | inline QPointF::QPointF(qreal xpos, qreal ypos) : xp(xpos), yp(ypos) { } | |
24293 | inline QPointF::QPointF(const QPoint &p) : xp(p.x()), yp(p.y()) { } | |
24294 | inline bool QPointF::isNull() const | |
24295 | { | |
24296 | return qIsNull(xp) && qIsNull(yp); | |
24297 | } | |
24298 | inline qreal QPointF::x() const | |
24299 | { | |
24300 | return xp; | |
24301 | } | |
24302 | inline qreal QPointF::y() const | |
24303 | { | |
24304 | return yp; | |
24305 | } | |
24306 | inline void QPointF::setX(qreal xpos) | |
24307 | { | |
24308 | xp = xpos; | |
24309 | } | |
24310 | inline void QPointF::setY(qreal ypos) | |
24311 | { | |
24312 | yp = ypos; | |
24313 | } | |
24314 | inline qreal &QPointF::rx() | |
24315 | { | |
24316 | return xp; | |
24317 | } | |
24318 | inline qreal &QPointF::ry() | |
24319 | { | |
24320 | return yp; | |
24321 | } | |
24322 | inline QPointF &QPointF::operator+=(const QPointF &p) | |
24323 | { | |
24324 | xp+=p.xp; | |
24325 | yp+=p.yp; | |
24326 | return *this; | |
24327 | } | |
24328 | inline QPointF &QPointF::operator-=(const QPointF &p) | |
24329 | { | |
24330 | xp-=p.xp; yp-=p.yp; return *this; | |
24331 | } | |
24332 | inline QPointF &QPointF::operator*=(qreal c) | |
24333 | { | |
24334 | xp*=c; yp*=c; return *this; | |
24335 | } | |
24336 | inline bool operator==(const QPointF &p1, const QPointF &p2) | |
24337 | { | |
24338 | return qFuzzyCompare(p1.xp, p2.xp) && qFuzzyCompare(p1.yp, p2.yp); | |
24339 | } | |
24340 | inline bool operator!=(const QPointF &p1, const QPointF &p2) | |
24341 | { | |
24342 | return !qFuzzyCompare(p1.xp, p2.xp) || !qFuzzyCompare(p1.yp, p2.yp); | |
24343 | } | |
24344 | inline const QPointF operator+(const QPointF &p1, const QPointF &p2) | |
24345 | { | |
24346 | return QPointF(p1.xp+p2.xp, p1.yp+p2.yp); | |
24347 | } | |
24348 | inline const QPointF operator-(const QPointF &p1, const QPointF &p2) | |
24349 | { | |
24350 | return QPointF(p1.xp-p2.xp, p1.yp-p2.yp); | |
24351 | } | |
24352 | inline const QPointF operator*(const QPointF &p, qreal c) | |
24353 | { | |
24354 | return QPointF(p.xp*c, p.yp*c); | |
24355 | } | |
24356 | inline const QPointF operator*(qreal c, const QPointF &p) | |
24357 | { | |
24358 | return QPointF(p.xp*c, p.yp*c); | |
24359 | } | |
24360 | inline const QPointF operator-(const QPointF &p) | |
24361 | { | |
24362 | return QPointF(-p.xp, -p.yp); | |
24363 | } | |
24364 | inline QPointF &QPointF::operator/=(qreal c) | |
24365 | { | |
24366 | xp/=c; | |
24367 | yp/=c; | |
24368 | return *this; | |
24369 | } | |
24370 | inline const QPointF operator/(const QPointF &p, qreal c) | |
24371 | { | |
24372 | return QPointF(p.xp/c, p.yp/c); | |
24373 | } | |
24374 | inline QPoint QPointF::toPoint() const | |
24375 | { | |
24376 | return QPoint(qRound(xp), qRound(yp)); | |
24377 | } | |
24378 | __attribute__((visibility("default"))) QDebug operator<<(QDebug d, const QPointF &p); | |
24379 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
24380 | class __attribute__((visibility("default"))) QRect | |
24381 | { | |
24382 | public: | |
24383 | QRect() { x1 = y1 = 0; x2 = y2 = -1; } | |
24384 | QRect(const QPoint &topleft, const QPoint &bottomright); | |
24385 | QRect(const QPoint &topleft, const QSize &size); | |
24386 | QRect(int left, int top, int width, int height); | |
24387 | bool isNull() const; | |
24388 | bool isEmpty() const; | |
24389 | bool isValid() const; | |
24390 | int left() const; | |
24391 | int top() const; | |
24392 | int right() const; | |
24393 | int bottom() const; | |
24394 | QRect normalized() const; | |
24395 | int x() const; | |
24396 | int y() const; | |
24397 | void setLeft(int pos); | |
24398 | void setTop(int pos); | |
24399 | void setRight(int pos); | |
24400 | void setBottom(int pos); | |
24401 | void setX(int x); | |
24402 | void setY(int y); | |
24403 | void setTopLeft(const QPoint &p); | |
24404 | void setBottomRight(const QPoint &p); | |
24405 | void setTopRight(const QPoint &p); | |
24406 | void setBottomLeft(const QPoint &p); | |
24407 | QPoint topLeft() const; | |
24408 | QPoint bottomRight() const; | |
24409 | QPoint topRight() const; | |
24410 | QPoint bottomLeft() const; | |
24411 | QPoint center() const; | |
24412 | void moveLeft(int pos); | |
24413 | void moveTop(int pos); | |
24414 | void moveRight(int pos); | |
24415 | void moveBottom(int pos); | |
24416 | void moveTopLeft(const QPoint &p); | |
24417 | void moveBottomRight(const QPoint &p); | |
24418 | void moveTopRight(const QPoint &p); | |
24419 | void moveBottomLeft(const QPoint &p); | |
24420 | void moveCenter(const QPoint &p); | |
24421 | inline void translate(int dx, int dy); | |
24422 | inline void translate(const QPoint &p); | |
24423 | inline QRect translated(int dx, int dy) const; | |
24424 | inline QRect translated(const QPoint &p) const; | |
24425 | void moveTo(int x, int t); | |
24426 | void moveTo(const QPoint &p); | |
24427 | void setRect(int x, int y, int w, int h); | |
24428 | inline void getRect(int *x, int *y, int *w, int *h) const; | |
24429 | void setCoords(int x1, int y1, int x2, int y2); | |
24430 | inline void getCoords(int *x1, int *y1, int *x2, int *y2) const; | |
24431 | inline void adjust(int x1, int y1, int x2, int y2); | |
24432 | inline QRect adjusted(int x1, int y1, int x2, int y2) const; | |
24433 | QSize size() const; | |
24434 | int width() const; | |
24435 | int height() const; | |
24436 | void setWidth(int w); | |
24437 | void setHeight(int h); | |
24438 | void setSize(const QSize &s); | |
24439 | QRect operator|(const QRect &r) const; | |
24440 | QRect operator&(const QRect &r) const; | |
24441 | QRect& operator|=(const QRect &r); | |
24442 | QRect& operator&=(const QRect &r); | |
24443 | bool contains(const QPoint &p, bool proper=false) const; | |
24444 | bool contains(int x, int y) const; | |
24445 | bool contains(int x, int y, bool proper) const; | |
24446 | bool contains(const QRect &r, bool proper = false) const; | |
24447 | QRect unite(const QRect &r) const; | |
24448 | QRect united(const QRect &other) const; | |
24449 | QRect intersect(const QRect &r) const; | |
24450 | QRect intersected(const QRect &other) const; | |
24451 | bool intersects(const QRect &r) const; | |
24452 | friend __attribute__((visibility("default"))) inline bool operator==(const QRect &, const QRect &); | |
24453 | friend __attribute__((visibility("default"))) inline bool operator!=(const QRect &, const QRect &); | |
24454 | private: | |
24455 | int x1; | |
24456 | int y1; | |
24457 | int x2; | |
24458 | int y2; | |
24459 | }; | |
24460 | template <> class QTypeInfo<QRect> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRect)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRect"; } }; | |
24461 | __attribute__((visibility("default"))) inline bool operator==(const QRect &, const QRect &); | |
24462 | __attribute__((visibility("default"))) inline bool operator!=(const QRect &, const QRect &); | |
24463 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QRect &); | |
24464 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QRect &); | |
24465 | inline QRect::QRect(int aleft, int atop, int awidth, int aheight) | |
24466 | { | |
24467 | x1 = aleft; | |
24468 | y1 = atop; | |
24469 | x2 = (aleft + awidth - 1); | |
24470 | y2 = (atop + aheight - 1); | |
24471 | } | |
24472 | inline QRect::QRect(const QPoint &atopLeft, const QPoint &abottomRight) | |
24473 | { | |
24474 | x1 = atopLeft.x(); | |
24475 | y1 = atopLeft.y(); | |
24476 | x2 = abottomRight.x(); | |
24477 | y2 = abottomRight.y(); | |
24478 | } | |
24479 | inline QRect::QRect(const QPoint &atopLeft, const QSize &asize) | |
24480 | { | |
24481 | x1 = atopLeft.x(); | |
24482 | y1 = atopLeft.y(); | |
24483 | x2 = (x1+asize.width() - 1); | |
24484 | y2 = (y1+asize.height() - 1); | |
24485 | } | |
24486 | inline bool QRect::isNull() const | |
24487 | { return x2 == x1 - 1 && y2 == y1 - 1; } | |
24488 | inline bool QRect::isEmpty() const | |
24489 | { return x1 > x2 || y1 > y2; } | |
24490 | inline bool QRect::isValid() const | |
24491 | { return x1 <= x2 && y1 <= y2; } | |
24492 | inline int QRect::left() const | |
24493 | { return x1; } | |
24494 | inline int QRect::top() const | |
24495 | { return y1; } | |
24496 | inline int QRect::right() const | |
24497 | { return x2; } | |
24498 | inline int QRect::bottom() const | |
24499 | { return y2; } | |
24500 | inline int QRect::x() const | |
24501 | { return x1; } | |
24502 | inline int QRect::y() const | |
24503 | { return y1; } | |
24504 | inline void QRect::setLeft(int pos) | |
24505 | { x1 = pos; } | |
24506 | inline void QRect::setTop(int pos) | |
24507 | { y1 = pos; } | |
24508 | inline void QRect::setRight(int pos) | |
24509 | { x2 = pos; } | |
24510 | inline void QRect::setBottom(int pos) | |
24511 | { y2 = pos; } | |
24512 | inline void QRect::setTopLeft(const QPoint &p) | |
24513 | { x1 = p.x(); y1 = p.y(); } | |
24514 | inline void QRect::setBottomRight(const QPoint &p) | |
24515 | { x2 = p.x(); y2 = p.y(); } | |
24516 | inline void QRect::setTopRight(const QPoint &p) | |
24517 | { x2 = p.x(); y1 = p.y(); } | |
24518 | inline void QRect::setBottomLeft(const QPoint &p) | |
24519 | { x1 = p.x(); y2 = p.y(); } | |
24520 | inline void QRect::setX(int ax) | |
24521 | { x1 = ax; } | |
24522 | inline void QRect::setY(int ay) | |
24523 | { y1 = ay; } | |
24524 | inline QPoint QRect::topLeft() const | |
24525 | { return QPoint(x1, y1); } | |
24526 | inline QPoint QRect::bottomRight() const | |
24527 | { return QPoint(x2, y2); } | |
24528 | inline QPoint QRect::topRight() const | |
24529 | { return QPoint(x2, y1); } | |
24530 | inline QPoint QRect::bottomLeft() const | |
24531 | { return QPoint(x1, y2); } | |
24532 | inline QPoint QRect::center() const | |
24533 | { return QPoint((x1+x2)/2, (y1+y2)/2); } | |
24534 | inline int QRect::width() const | |
24535 | { return x2 - x1 + 1; } | |
24536 | inline int QRect::height() const | |
24537 | { return y2 - y1 + 1; } | |
24538 | inline QSize QRect::size() const | |
24539 | { return QSize(width(), height()); } | |
24540 | inline void QRect::translate(int dx, int dy) | |
24541 | { | |
24542 | x1 += dx; | |
24543 | y1 += dy; | |
24544 | x2 += dx; | |
24545 | y2 += dy; | |
24546 | } | |
24547 | inline void QRect::translate(const QPoint &p) | |
24548 | { | |
24549 | x1 += p.x(); | |
24550 | y1 += p.y(); | |
24551 | x2 += p.x(); | |
24552 | y2 += p.y(); | |
24553 | } | |
24554 | inline QRect QRect::translated(int dx, int dy) const | |
24555 | { return QRect(QPoint(x1 + dx, y1 + dy), QPoint(x2 + dx, y2 + dy)); } | |
24556 | inline QRect QRect::translated(const QPoint &p) const | |
24557 | { return QRect(QPoint(x1 + p.x(), y1 + p.y()), QPoint(x2 + p.x(), y2 + p.y())); } | |
24558 | inline void QRect::moveTo(int ax, int ay) | |
24559 | { | |
24560 | x2 += ax - x1; | |
24561 | y2 += ay - y1; | |
24562 | x1 = ax; | |
24563 | y1 = ay; | |
24564 | } | |
24565 | inline void QRect::moveTo(const QPoint &p) | |
24566 | { | |
24567 | x2 += p.x() - x1; | |
24568 | y2 += p.y() - y1; | |
24569 | x1 = p.x(); | |
24570 | y1 = p.y(); | |
24571 | } | |
24572 | inline void QRect::moveLeft(int pos) | |
24573 | { x2 += (pos - x1); x1 = pos; } | |
24574 | inline void QRect::moveTop(int pos) | |
24575 | { y2 += (pos - y1); y1 = pos; } | |
24576 | inline void QRect::moveRight(int pos) | |
24577 | { | |
24578 | x1 += (pos - x2); | |
24579 | x2 = pos; | |
24580 | } | |
24581 | inline void QRect::moveBottom(int pos) | |
24582 | { | |
24583 | y1 += (pos - y2); | |
24584 | y2 = pos; | |
24585 | } | |
24586 | inline void QRect::moveTopLeft(const QPoint &p) | |
24587 | { | |
24588 | moveLeft(p.x()); | |
24589 | moveTop(p.y()); | |
24590 | } | |
24591 | inline void QRect::moveBottomRight(const QPoint &p) | |
24592 | { | |
24593 | moveRight(p.x()); | |
24594 | moveBottom(p.y()); | |
24595 | } | |
24596 | inline void QRect::moveTopRight(const QPoint &p) | |
24597 | { | |
24598 | moveRight(p.x()); | |
24599 | moveTop(p.y()); | |
24600 | } | |
24601 | inline void QRect::moveBottomLeft(const QPoint &p) | |
24602 | { | |
24603 | moveLeft(p.x()); | |
24604 | moveBottom(p.y()); | |
24605 | } | |
24606 | inline void QRect::getRect(int *ax, int *ay, int *aw, int *ah) const | |
24607 | { | |
24608 | *ax = x1; | |
24609 | *ay = y1; | |
24610 | *aw = x2 - x1 + 1; | |
24611 | *ah = y2 - y1 + 1; | |
24612 | } | |
24613 | inline void QRect::setRect(int ax, int ay, int aw, int ah) | |
24614 | { | |
24615 | x1 = ax; | |
24616 | y1 = ay; | |
24617 | x2 = (ax + aw - 1); | |
24618 | y2 = (ay + ah - 1); | |
24619 | } | |
24620 | inline void QRect::getCoords(int *xp1, int *yp1, int *xp2, int *yp2) const | |
24621 | { | |
24622 | *xp1 = x1; | |
24623 | *yp1 = y1; | |
24624 | *xp2 = x2; | |
24625 | *yp2 = y2; | |
24626 | } | |
24627 | inline void QRect::setCoords(int xp1, int yp1, int xp2, int yp2) | |
24628 | { | |
24629 | x1 = xp1; | |
24630 | y1 = yp1; | |
24631 | x2 = xp2; | |
24632 | y2 = yp2; | |
24633 | } | |
24634 | inline QRect QRect::adjusted(int xp1, int yp1, int xp2, int yp2) const | |
24635 | { return QRect(QPoint(x1 + xp1, y1 + yp1), QPoint(x2 + xp2, y2 + yp2)); } | |
24636 | inline void QRect::adjust(int dx1, int dy1, int dx2, int dy2) | |
24637 | { | |
24638 | x1 += dx1; | |
24639 | y1 += dy1; | |
24640 | x2 += dx2; | |
24641 | y2 += dy2; | |
24642 | } | |
24643 | inline void QRect::setWidth(int w) | |
24644 | { x2 = (x1 + w - 1); } | |
24645 | inline void QRect::setHeight(int h) | |
24646 | { y2 = (y1 + h - 1); } | |
24647 | inline void QRect::setSize(const QSize &s) | |
24648 | { | |
24649 | x2 = (s.width() + x1 - 1); | |
24650 | y2 = (s.height() + y1 - 1); | |
24651 | } | |
24652 | inline bool QRect::contains(int ax, int ay, bool aproper) const | |
24653 | { | |
24654 | return contains(QPoint(ax, ay), aproper); | |
24655 | } | |
24656 | inline bool QRect::contains(int ax, int ay) const | |
24657 | { | |
24658 | return contains(QPoint(ax, ay), false); | |
24659 | } | |
24660 | inline QRect& QRect::operator|=(const QRect &r) | |
24661 | { | |
24662 | *this = *this | r; | |
24663 | return *this; | |
24664 | } | |
24665 | inline QRect& QRect::operator&=(const QRect &r) | |
24666 | { | |
24667 | *this = *this & r; | |
24668 | return *this; | |
24669 | } | |
24670 | inline QRect QRect::intersect(const QRect &r) const | |
24671 | { | |
24672 | return *this & r; | |
24673 | } | |
24674 | inline QRect QRect::intersected(const QRect &other) const | |
24675 | { | |
24676 | return intersect(other); | |
24677 | } | |
24678 | inline QRect QRect::unite(const QRect &r) const | |
24679 | { | |
24680 | return *this | r; | |
24681 | } | |
24682 | inline QRect QRect::united(const QRect &r) const | |
24683 | { | |
24684 | return unite(r); | |
24685 | } | |
24686 | inline bool operator==(const QRect &r1, const QRect &r2) | |
24687 | { | |
24688 | return r1.x1==r2.x1 && r1.x2==r2.x2 && r1.y1==r2.y1 && r1.y2==r2.y2; | |
24689 | } | |
24690 | inline bool operator!=(const QRect &r1, const QRect &r2) | |
24691 | { | |
24692 | return r1.x1!=r2.x1 || r1.x2!=r2.x2 || r1.y1!=r2.y1 || r1.y2!=r2.y2; | |
24693 | } | |
24694 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QRect &); | |
24695 | class __attribute__((visibility("default"))) QRectF | |
24696 | { | |
24697 | public: | |
24698 | QRectF() { xp = yp = 0.; w = h = 0.; } | |
24699 | QRectF(const QPointF &topleft, const QSizeF &size); | |
24700 | QRectF(const QPointF &topleft, const QPointF &bottomRight); | |
24701 | QRectF(qreal left, qreal top, qreal width, qreal height); | |
24702 | QRectF(const QRect &rect); | |
24703 | bool isNull() const; | |
24704 | bool isEmpty() const; | |
24705 | bool isValid() const; | |
24706 | QRectF normalized() const; | |
24707 | inline qreal left() const { return xp; } | |
24708 | inline qreal top() const { return yp; } | |
24709 | inline qreal right() const { return xp + w; } | |
24710 | inline qreal bottom() const { return yp + h; } | |
24711 | inline qreal x() const; | |
24712 | inline qreal y() const; | |
24713 | inline void setLeft(qreal pos); | |
24714 | inline void setTop(qreal pos); | |
24715 | inline void setRight(qreal pos); | |
24716 | inline void setBottom(qreal pos); | |
24717 | inline void setX(qreal pos) { setLeft(pos); } | |
24718 | inline void setY(qreal pos) { setTop(pos); } | |
24719 | inline QPointF topLeft() const { return QPointF(xp, yp); } | |
24720 | inline QPointF bottomRight() const { return QPointF(xp+w, yp+h); } | |
24721 | inline QPointF topRight() const { return QPointF(xp+w, yp); } | |
24722 | inline QPointF bottomLeft() const { return QPointF(xp, yp+h); } | |
24723 | inline QPointF center() const; | |
24724 | void setTopLeft(const QPointF &p); | |
24725 | void setBottomRight(const QPointF &p); | |
24726 | void setTopRight(const QPointF &p); | |
24727 | void setBottomLeft(const QPointF &p); | |
24728 | void moveLeft(qreal pos); | |
24729 | void moveTop(qreal pos); | |
24730 | void moveRight(qreal pos); | |
24731 | void moveBottom(qreal pos); | |
24732 | void moveTopLeft(const QPointF &p); | |
24733 | void moveBottomRight(const QPointF &p); | |
24734 | void moveTopRight(const QPointF &p); | |
24735 | void moveBottomLeft(const QPointF &p); | |
24736 | void moveCenter(const QPointF &p); | |
24737 | void translate(qreal dx, qreal dy); | |
24738 | void translate(const QPointF &p); | |
24739 | QRectF translated(qreal dx, qreal dy) const; | |
24740 | QRectF translated(const QPointF &p) const; | |
24741 | void moveTo(qreal x, qreal t); | |
24742 | void moveTo(const QPointF &p); | |
24743 | void setRect(qreal x, qreal y, qreal w, qreal h); | |
24744 | void getRect(qreal *x, qreal *y, qreal *w, qreal *h) const; | |
24745 | void setCoords(qreal x1, qreal y1, qreal x2, qreal y2); | |
24746 | void getCoords(qreal *x1, qreal *y1, qreal *x2, qreal *y2) const; | |
24747 | inline void adjust(qreal x1, qreal y1, qreal x2, qreal y2); | |
24748 | inline QRectF adjusted(qreal x1, qreal y1, qreal x2, qreal y2) const; | |
24749 | QSizeF size() const; | |
24750 | qreal width() const; | |
24751 | qreal height() const; | |
24752 | void setWidth(qreal w); | |
24753 | void setHeight(qreal h); | |
24754 | void setSize(const QSizeF &s); | |
24755 | QRectF operator|(const QRectF &r) const; | |
24756 | QRectF operator&(const QRectF &r) const; | |
24757 | QRectF& operator|=(const QRectF &r); | |
24758 | QRectF& operator&=(const QRectF &r); | |
24759 | bool contains(const QPointF &p) const; | |
24760 | bool contains(qreal x, qreal y) const; | |
24761 | bool contains(const QRectF &r) const; | |
24762 | QRectF unite(const QRectF &r) const; | |
24763 | QRectF united(const QRectF &other) const; | |
24764 | QRectF intersect(const QRectF &r) const; | |
24765 | QRectF intersected(const QRectF &other) const; | |
24766 | bool intersects(const QRectF &r) const; | |
24767 | friend __attribute__((visibility("default"))) inline bool operator==(const QRectF &, const QRectF &); | |
24768 | friend __attribute__((visibility("default"))) inline bool operator!=(const QRectF &, const QRectF &); | |
24769 | QRect toRect() const; | |
24770 | QRect toAlignedRect() const; | |
24771 | private: | |
24772 | qreal xp; | |
24773 | qreal yp; | |
24774 | qreal w; | |
24775 | qreal h; | |
24776 | }; | |
24777 | template <> class QTypeInfo<QRectF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRectF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRectF"; } }; | |
24778 | __attribute__((visibility("default"))) inline bool operator==(const QRectF &, const QRectF &); | |
24779 | __attribute__((visibility("default"))) inline bool operator!=(const QRectF &, const QRectF &); | |
24780 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QRectF &); | |
24781 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QRectF &); | |
24782 | inline QRectF::QRectF(qreal aleft, qreal atop, qreal awidth, qreal aheight) | |
24783 | : xp(aleft), yp(atop), w(awidth), h(aheight) | |
24784 | { | |
24785 | } | |
24786 | inline QRectF::QRectF(const QPointF &atopLeft, const QSizeF &asize) | |
24787 | { | |
24788 | xp = atopLeft.x(); | |
24789 | yp = atopLeft.y(); | |
24790 | w = asize.width(); | |
24791 | h = asize.height(); | |
24792 | } | |
24793 | inline QRectF::QRectF(const QPointF &atopLeft, const QPointF &abottomRight) | |
24794 | { | |
24795 | xp = atopLeft.x(); | |
24796 | yp = atopLeft.y(); | |
24797 | w = abottomRight.x() - xp; | |
24798 | h = abottomRight.y() - yp; | |
24799 | } | |
24800 | inline QRectF::QRectF(const QRect &r) | |
24801 | : xp(r.x()), yp(r.y()), w(r.width()), h(r.height()) | |
24802 | { | |
24803 | } | |
24804 | inline bool QRectF::isNull() const | |
24805 | { return qIsNull(w) && qIsNull(h); } | |
24806 | inline bool QRectF::isEmpty() const | |
24807 | { return w <= 0. || h <= 0.; } | |
24808 | inline bool QRectF::isValid() const | |
24809 | { return w > 0. && h > 0.; } | |
24810 | inline qreal QRectF::x() const | |
24811 | { return xp; } | |
24812 | inline qreal QRectF::y() const | |
24813 | { return yp; } | |
24814 | inline void QRectF::setLeft(qreal pos) { qreal diff = pos - xp; xp += diff; w -= diff; } | |
24815 | inline void QRectF::setRight(qreal pos) { w = pos - xp; } | |
24816 | inline void QRectF::setTop(qreal pos) { qreal diff = pos - yp; yp += diff; h -= diff; } | |
24817 | inline void QRectF::setBottom(qreal pos) { h = pos - yp; } | |
24818 | inline void QRectF::setTopLeft(const QPointF &p) { setLeft(p.x()); setTop(p.y()); } | |
24819 | inline void QRectF::setTopRight(const QPointF &p) { setRight(p.x()); setTop(p.y()); } | |
24820 | inline void QRectF::setBottomLeft(const QPointF &p) { setLeft(p.x()); setBottom(p.y()); } | |
24821 | inline void QRectF::setBottomRight(const QPointF &p) { setRight(p.x()); setBottom(p.y()); } | |
24822 | inline QPointF QRectF::center() const | |
24823 | { return QPointF(xp + w/2, yp + h/2); } | |
24824 | inline void QRectF::moveLeft(qreal pos) { xp = pos; } | |
24825 | inline void QRectF::moveTop(qreal pos) { yp = pos; } | |
24826 | inline void QRectF::moveRight(qreal pos) { xp = pos - w; } | |
24827 | inline void QRectF::moveBottom(qreal pos) { yp = pos - h; } | |
24828 | inline void QRectF::moveTopLeft(const QPointF &p) { moveLeft(p.x()); moveTop(p.y()); } | |
24829 | inline void QRectF::moveTopRight(const QPointF &p) { moveRight(p.x()); moveTop(p.y()); } | |
24830 | inline void QRectF::moveBottomLeft(const QPointF &p) { moveLeft(p.x()); moveBottom(p.y()); } | |
24831 | inline void QRectF::moveBottomRight(const QPointF &p) { moveRight(p.x()); moveBottom(p.y()); } | |
24832 | inline void QRectF::moveCenter(const QPointF &p) { xp = p.x() - w/2; yp = p.y() - h/2; } | |
24833 | inline qreal QRectF::width() const | |
24834 | { return w; } | |
24835 | inline qreal QRectF::height() const | |
24836 | { return h; } | |
24837 | inline QSizeF QRectF::size() const | |
24838 | { return QSizeF(w, h); } | |
24839 | inline void QRectF::translate(qreal dx, qreal dy) | |
24840 | { | |
24841 | xp += dx; | |
24842 | yp += dy; | |
24843 | } | |
24844 | inline void QRectF::translate(const QPointF &p) | |
24845 | { | |
24846 | xp += p.x(); | |
24847 | yp += p.y(); | |
24848 | } | |
24849 | inline void QRectF::moveTo(qreal ax, qreal ay) | |
24850 | { | |
24851 | xp = ax; | |
24852 | yp = ay; | |
24853 | } | |
24854 | inline void QRectF::moveTo(const QPointF &p) | |
24855 | { | |
24856 | xp = p.x(); | |
24857 | yp = p.y(); | |
24858 | } | |
24859 | inline QRectF QRectF::translated(qreal dx, qreal dy) const | |
24860 | { return QRectF(xp + dx, yp + dy, w, h); } | |
24861 | inline QRectF QRectF::translated(const QPointF &p) const | |
24862 | { return QRectF(xp + p.x(), yp + p.y(), w, h); } | |
24863 | inline void QRectF::getRect(qreal *ax, qreal *ay, qreal *aaw, qreal *aah) const | |
24864 | { | |
24865 | *ax = this->xp; | |
24866 | *ay = this->yp; | |
24867 | *aaw = this->w; | |
24868 | *aah = this->h; | |
24869 | } | |
24870 | inline void QRectF::setRect(qreal ax, qreal ay, qreal aaw, qreal aah) | |
24871 | { | |
24872 | this->xp = ax; | |
24873 | this->yp = ay; | |
24874 | this->w = aaw; | |
24875 | this->h = aah; | |
24876 | } | |
24877 | inline void QRectF::getCoords(qreal *xp1, qreal *yp1, qreal *xp2, qreal *yp2) const | |
24878 | { | |
24879 | *xp1 = xp; | |
24880 | *yp1 = yp; | |
24881 | *xp2 = xp + w; | |
24882 | *yp2 = yp + h; | |
24883 | } | |
24884 | inline void QRectF::setCoords(qreal xp1, qreal yp1, qreal xp2, qreal yp2) | |
24885 | { | |
24886 | xp = xp1; | |
24887 | yp = yp1; | |
24888 | w = xp2 - xp1; | |
24889 | h = yp2 - yp1; | |
24890 | } | |
24891 | inline void QRectF::adjust(qreal xp1, qreal yp1, qreal xp2, qreal yp2) | |
24892 | { xp += xp1; yp += yp1; w += xp2 - xp1; h += yp2 - yp1; } | |
24893 | inline QRectF QRectF::adjusted(qreal xp1, qreal yp1, qreal xp2, qreal yp2) const | |
24894 | { return QRectF(xp + xp1, yp + yp1, w + xp2 - xp1, h + yp2 - yp1); } | |
24895 | inline void QRectF::setWidth(qreal aw) | |
24896 | { this->w = aw; } | |
24897 | inline void QRectF::setHeight(qreal ah) | |
24898 | { this->h = ah; } | |
24899 | inline void QRectF::setSize(const QSizeF &s) | |
24900 | { | |
24901 | w = s.width(); | |
24902 | h = s.height(); | |
24903 | } | |
24904 | inline bool QRectF::contains(qreal ax, qreal ay) const | |
24905 | { | |
24906 | return contains(QPointF(ax, ay)); | |
24907 | } | |
24908 | inline QRectF& QRectF::operator|=(const QRectF &r) | |
24909 | { | |
24910 | *this = *this | r; | |
24911 | return *this; | |
24912 | } | |
24913 | inline QRectF& QRectF::operator&=(const QRectF &r) | |
24914 | { | |
24915 | *this = *this & r; | |
24916 | return *this; | |
24917 | } | |
24918 | inline QRectF QRectF::intersect(const QRectF &r) const | |
24919 | { | |
24920 | return *this & r; | |
24921 | } | |
24922 | inline QRectF QRectF::intersected(const QRectF &r) const | |
24923 | { | |
24924 | return intersect(r); | |
24925 | } | |
24926 | inline QRectF QRectF::unite(const QRectF &r) const | |
24927 | { | |
24928 | return *this | r; | |
24929 | } | |
24930 | inline QRectF QRectF::united(const QRectF &r) const | |
24931 | { | |
24932 | return unite(r); | |
24933 | } | |
24934 | inline bool operator==(const QRectF &r1, const QRectF &r2) | |
24935 | { | |
24936 | return qFuzzyCompare(r1.xp, r2.xp) && qFuzzyCompare(r1.yp, r2.yp) | |
24937 | && qFuzzyCompare(r1.w, r2.w) && qFuzzyCompare(r1.h, r2.h); | |
24938 | } | |
24939 | inline bool operator!=(const QRectF &r1, const QRectF &r2) | |
24940 | { | |
24941 | return !qFuzzyCompare(r1.xp, r2.xp) || !qFuzzyCompare(r1.yp, r2.yp) | |
24942 | || !qFuzzyCompare(r1.w, r2.w) || !qFuzzyCompare(r1.h, r2.h); | |
24943 | } | |
24944 | inline QRect QRectF::toRect() const | |
24945 | { | |
24946 | return QRect(qRound(xp), qRound(yp), qRound(w), qRound(h)); | |
24947 | } | |
24948 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QRectF &); | |
24949 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
24950 | typedef unsigned int QRgb; | |
24951 | const QRgb RGB_MASK = 0x00ffffff; | |
24952 | __attribute__((visibility("default"))) inline int qRed(QRgb rgb) | |
24953 | { return ((rgb >> 16) & 0xff); } | |
24954 | __attribute__((visibility("default"))) inline int qGreen(QRgb rgb) | |
24955 | { return ((rgb >> 8) & 0xff); } | |
24956 | __attribute__((visibility("default"))) inline int qBlue(QRgb rgb) | |
24957 | { return (rgb & 0xff); } | |
24958 | __attribute__((visibility("default"))) inline int qAlpha(QRgb rgb) | |
24959 | { return ((rgb >> 24) & 0xff); } | |
24960 | __attribute__((visibility("default"))) inline QRgb qRgb(int r, int g, int b) | |
24961 | { return (0xffu << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); } | |
24962 | __attribute__((visibility("default"))) inline QRgb qRgba(int r, int g, int b, int a) | |
24963 | { return ((a & 0xff) << 24) | ((r & 0xff) << 16) | ((g & 0xff) << 8) | (b & 0xff); } | |
24964 | __attribute__((visibility("default"))) inline int qGray(int r, int g, int b) | |
24965 | { return (r*11+g*16+b*5)/32; } | |
24966 | __attribute__((visibility("default"))) inline int qGray(QRgb rgb) | |
24967 | { return qGray(qRed(rgb), qGreen(rgb), qBlue(rgb)); } | |
24968 | __attribute__((visibility("default"))) inline bool qIsGray(QRgb rgb) | |
24969 | { return qRed(rgb) == qGreen(rgb) && qRed(rgb) == qBlue(rgb); } | |
24970 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
24971 | struct QRegExpPrivate; | |
24972 | class QStringList; | |
24973 | class __attribute__((visibility("default"))) QRegExp | |
24974 | { | |
24975 | public: | |
24976 | enum PatternSyntax { RegExp, Wildcard, FixedString, RegExp2 }; | |
24977 | enum CaretMode { CaretAtZero, CaretAtOffset, CaretWontMatch }; | |
24978 | QRegExp(); | |
24979 | explicit QRegExp(const QString &pattern, Qt::CaseSensitivity cs = Qt::CaseSensitive, | |
24980 | PatternSyntax syntax = RegExp); | |
24981 | QRegExp(const QRegExp &rx); | |
24982 | ~QRegExp(); | |
24983 | QRegExp &operator=(const QRegExp &rx); | |
24984 | bool operator==(const QRegExp &rx) const; | |
24985 | inline bool operator!=(const QRegExp &rx) const { return !operator==(rx); } | |
24986 | bool isEmpty() const; | |
24987 | bool isValid() const; | |
24988 | QString pattern() const; | |
24989 | void setPattern(const QString &pattern); | |
24990 | Qt::CaseSensitivity caseSensitivity() const; | |
24991 | void setCaseSensitivity(Qt::CaseSensitivity cs); | |
24992 | PatternSyntax patternSyntax() const; | |
24993 | void setPatternSyntax(PatternSyntax syntax); | |
24994 | bool isMinimal() const; | |
24995 | void setMinimal(bool minimal); | |
24996 | bool exactMatch(const QString &str) const; | |
24997 | int indexIn(const QString &str, int offset = 0, CaretMode caretMode = CaretAtZero) const; | |
24998 | int lastIndexIn(const QString &str, int offset = -1, CaretMode caretMode = CaretAtZero) const; | |
24999 | int matchedLength() const; | |
25000 | int numCaptures() const; | |
25001 | QStringList capturedTexts() const; | |
25002 | QStringList capturedTexts(); | |
25003 | QString cap(int nth = 0) const; | |
25004 | QString cap(int nth = 0); | |
25005 | int pos(int nth = 0) const; | |
25006 | int pos(int nth = 0); | |
25007 | QString errorString() const; | |
25008 | QString errorString(); | |
25009 | static QString escape(const QString &str); | |
25010 | private: | |
25011 | QRegExpPrivate *priv; | |
25012 | }; | |
25013 | template <> class QTypeInfo<QRegExp> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QRegExp)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QRegExp"; } }; | |
25014 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &out, const QRegExp ®Exp); | |
25015 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &in, QRegExp ®Exp); | |
25016 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
25017 | class QStringMatcherPrivate; | |
25018 | class __attribute__((visibility("default"))) QStringMatcher | |
25019 | { | |
25020 | public: | |
25021 | QStringMatcher(); | |
25022 | QStringMatcher(const QString &pattern, | |
25023 | Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
25024 | QStringMatcher(const QChar *uc, int len, | |
25025 | Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
25026 | QStringMatcher(const QStringMatcher &other); | |
25027 | ~QStringMatcher(); | |
25028 | QStringMatcher &operator=(const QStringMatcher &other); | |
25029 | void setPattern(const QString &pattern); | |
25030 | void setCaseSensitivity(Qt::CaseSensitivity cs); | |
25031 | int indexIn(const QString &str, int from = 0) const; | |
25032 | int indexIn(const QChar *str, int length, int from = 0) const; | |
25033 | QString pattern() const; | |
25034 | inline Qt::CaseSensitivity caseSensitivity() const { return q_cs; } | |
25035 | private: | |
25036 | QStringMatcherPrivate *d_ptr; | |
25037 | QString q_pattern; | |
25038 | Qt::CaseSensitivity q_cs; | |
25039 | union { | |
25040 | uint q_data[256]; | |
25041 | struct { | |
25042 | uchar q_skiptable[256]; | |
25043 | const QChar *uc; | |
25044 | int len; | |
25045 | } p; | |
25046 | }; | |
25047 | }; | |
25048 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
25049 | class QRegExp; | |
25050 | typedef QListIterator<QString> QStringListIterator; | |
25051 | typedef QMutableListIterator<QString> QMutableStringListIterator; | |
25052 | class QStringList : public QList<QString> | |
25053 | { | |
25054 | public: | |
25055 | inline QStringList() { } | |
25056 | inline explicit QStringList(const QString &i) { append(i); } | |
25057 | inline QStringList(const QStringList &l) : QList<QString>(l) { } | |
25058 | inline QStringList(const QList<QString> &l) : QList<QString>(l) { } | |
25059 | inline void sort(); | |
25060 | inline int removeDuplicates(); | |
25061 | inline QString join(const QString &sep) const; | |
25062 | inline QStringList filter(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
25063 | inline QBool contains(const QString &str, Qt::CaseSensitivity cs = Qt::CaseSensitive) const; | |
25064 | inline QStringList &replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs = Qt::CaseSensitive); | |
25065 | inline QStringList operator+(const QStringList &other) const | |
25066 | { QStringList n = *this; n += other; return n; } | |
25067 | inline QStringList &operator<<(const QString &str) | |
25068 | { append(str); return *this; } | |
25069 | inline QStringList &operator<<(const QStringList &l) | |
25070 | { *this += l; return *this; } | |
25071 | inline QStringList filter(const QRegExp &rx) const; | |
25072 | inline QStringList &replaceInStrings(const QRegExp &rx, const QString &after); | |
25073 | inline int indexOf(const QRegExp &rx, int from = 0) const; | |
25074 | inline int lastIndexOf(const QRegExp &rx, int from = -1) const; | |
25075 | inline int indexOf(QRegExp &rx, int from = 0) const; | |
25076 | inline int lastIndexOf(QRegExp &rx, int from = -1) const; | |
25077 | using QList<QString>::indexOf; | |
25078 | using QList<QString>::lastIndexOf; | |
25079 | }; | |
25080 | namespace QtPrivate { | |
25081 | void __attribute__((visibility("default"))) QStringList_sort(QStringList *that); | |
25082 | int __attribute__((visibility("default"))) QStringList_removeDuplicates(QStringList *that); | |
25083 | QString __attribute__((visibility("default"))) QStringList_join(const QStringList *that, const QString &sep); | |
25084 | QStringList __attribute__((visibility("default"))) QStringList_filter(const QStringList *that, const QString &str, | |
25085 | Qt::CaseSensitivity cs); | |
25086 | QBool __attribute__((visibility("default"))) QStringList_contains(const QStringList *that, const QString &str, Qt::CaseSensitivity cs); | |
25087 | void __attribute__((visibility("default"))) QStringList_replaceInStrings(QStringList *that, const QString &before, const QString &after, | |
25088 | Qt::CaseSensitivity cs); | |
25089 | void __attribute__((visibility("default"))) QStringList_replaceInStrings(QStringList *that, const QRegExp &rx, const QString &after); | |
25090 | QStringList __attribute__((visibility("default"))) QStringList_filter(const QStringList *that, const QRegExp &re); | |
25091 | int __attribute__((visibility("default"))) QStringList_indexOf(const QStringList *that, const QRegExp &rx, int from); | |
25092 | int __attribute__((visibility("default"))) QStringList_lastIndexOf(const QStringList *that, const QRegExp &rx, int from); | |
25093 | int __attribute__((visibility("default"))) QStringList_indexOf(const QStringList *that, QRegExp &rx, int from); | |
25094 | int __attribute__((visibility("default"))) QStringList_lastIndexOf(const QStringList *that, QRegExp &rx, int from); | |
25095 | } | |
25096 | inline void QStringList::sort() | |
25097 | { | |
25098 | QtPrivate::QStringList_sort(this); | |
25099 | } | |
25100 | inline int QStringList::removeDuplicates() | |
25101 | { | |
25102 | return QtPrivate::QStringList_removeDuplicates(this); | |
25103 | } | |
25104 | inline QString QStringList::join(const QString &sep) const | |
25105 | { | |
25106 | return QtPrivate::QStringList_join(this, sep); | |
25107 | } | |
25108 | inline QStringList QStringList::filter(const QString &str, Qt::CaseSensitivity cs) const | |
25109 | { | |
25110 | return QtPrivate::QStringList_filter(this, str, cs); | |
25111 | } | |
25112 | inline QBool QStringList::contains(const QString &str, Qt::CaseSensitivity cs) const | |
25113 | { | |
25114 | return QtPrivate::QStringList_contains(this, str, cs); | |
25115 | } | |
25116 | inline QStringList &QStringList::replaceInStrings(const QString &before, const QString &after, Qt::CaseSensitivity cs) | |
25117 | { | |
25118 | QtPrivate::QStringList_replaceInStrings(this, before, after, cs); | |
25119 | return *this; | |
25120 | } | |
25121 | inline QStringList &QStringList::replaceInStrings(const QRegExp &rx, const QString &after) | |
25122 | { | |
25123 | QtPrivate::QStringList_replaceInStrings(this, rx, after); | |
25124 | return *this; | |
25125 | } | |
25126 | inline QStringList QStringList::filter(const QRegExp &rx) const | |
25127 | { | |
25128 | return QtPrivate::QStringList_filter(this, rx); | |
25129 | } | |
25130 | inline int QStringList::indexOf(const QRegExp &rx, int from) const | |
25131 | { | |
25132 | return QtPrivate::QStringList_indexOf(this, rx, from); | |
25133 | } | |
25134 | inline int QStringList::lastIndexOf(const QRegExp &rx, int from) const | |
25135 | { | |
25136 | return QtPrivate::QStringList_lastIndexOf(this, rx, from); | |
25137 | } | |
25138 | inline int QStringList::indexOf(QRegExp &rx, int from) const | |
25139 | { | |
25140 | return QtPrivate::QStringList_indexOf(this, rx, from); | |
25141 | } | |
25142 | inline int QStringList::lastIndexOf(QRegExp &rx, int from) const | |
25143 | { | |
25144 | return QtPrivate::QStringList_lastIndexOf(this, rx, from); | |
25145 | } | |
25146 | inline QDataStream &operator>>(QDataStream &in, QStringList &list) | |
25147 | { | |
25148 | return operator>>(in, static_cast<QList<QString> &>(list)); | |
25149 | } | |
25150 | inline QDataStream &operator<<(QDataStream &out, const QStringList &list) | |
25151 | { | |
25152 | return operator<<(out, static_cast<const QList<QString> &>(list)); | |
25153 | } | |
25154 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
25155 | class QColor; | |
25156 | class QColormap; | |
25157 | class QVariant; | |
25158 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QColor &); | |
25159 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QColor &); | |
25160 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QColor &); | |
25161 | class __attribute__((visibility("default"))) QColor | |
25162 | { | |
25163 | public: | |
25164 | enum Spec { Invalid, Rgb, Hsv, Cmyk }; | |
25165 | QColor(); | |
25166 | QColor(Qt::GlobalColor color); | |
25167 | QColor(int r, int g, int b, int a = 255); | |
25168 | QColor(QRgb rgb); | |
25169 | QColor(const QString& name); | |
25170 | QColor(const char *name); | |
25171 | QColor(const QColor &color); | |
25172 | QColor(Spec spec); | |
25173 | bool isValid() const; | |
25174 | QString name() const; | |
25175 | void setNamedColor(const QString& name); | |
25176 | static QStringList colorNames(); | |
25177 | inline Spec spec() const | |
25178 | { return cspec; } | |
25179 | int alpha() const; | |
25180 | void setAlpha(int alpha); | |
25181 | qreal alphaF() const; | |
25182 | void setAlphaF(qreal alpha); | |
25183 | int red() const; | |
25184 | int green() const; | |
25185 | int blue() const; | |
25186 | void setRed(int red); | |
25187 | void setGreen(int green); | |
25188 | void setBlue(int blue); | |
25189 | qreal redF() const; | |
25190 | qreal greenF() const; | |
25191 | qreal blueF() const; | |
25192 | void setRedF(qreal red); | |
25193 | void setGreenF(qreal green); | |
25194 | void setBlueF(qreal blue); | |
25195 | void getRgb(int *r, int *g, int *b, int *a = 0) const; | |
25196 | void setRgb(int r, int g, int b, int a = 255); | |
25197 | void getRgbF(qreal *r, qreal *g, qreal *b, qreal *a = 0) const; | |
25198 | void setRgbF(qreal r, qreal g, qreal b, qreal a = 1.0); | |
25199 | QRgb rgba() const; | |
25200 | void setRgba(QRgb rgba); | |
25201 | QRgb rgb() const; | |
25202 | void setRgb(QRgb rgb); | |
25203 | int hue() const; | |
25204 | int saturation() const; | |
25205 | int value() const; | |
25206 | qreal hueF() const; | |
25207 | qreal saturationF() const; | |
25208 | qreal valueF() const; | |
25209 | void getHsv(int *h, int *s, int *v, int *a = 0) const; | |
25210 | void setHsv(int h, int s, int v, int a = 255); | |
25211 | void getHsvF(qreal *h, qreal *s, qreal *v, qreal *a = 0) const; | |
25212 | void setHsvF(qreal h, qreal s, qreal v, qreal a = 1.0); | |
25213 | int cyan() const; | |
25214 | int magenta() const; | |
25215 | int yellow() const; | |
25216 | int black() const; | |
25217 | qreal cyanF() const; | |
25218 | qreal magentaF() const; | |
25219 | qreal yellowF() const; | |
25220 | qreal blackF() const; | |
25221 | void getCmyk(int *c, int *m, int *y, int *k, int *a = 0); | |
25222 | void setCmyk(int c, int m, int y, int k, int a = 255); | |
25223 | void getCmykF(qreal *c, qreal *m, qreal *y, qreal *k, qreal *a = 0); | |
25224 | void setCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0); | |
25225 | QColor toRgb() const; | |
25226 | QColor toHsv() const; | |
25227 | QColor toCmyk() const; | |
25228 | QColor convertTo(Spec colorSpec) const; | |
25229 | static QColor fromRgb(QRgb rgb); | |
25230 | static QColor fromRgba(QRgb rgba); | |
25231 | static QColor fromRgb(int r, int g, int b, int a = 255); | |
25232 | static QColor fromRgbF(qreal r, qreal g, qreal b, qreal a = 1.0); | |
25233 | static QColor fromHsv(int h, int s, int v, int a = 255); | |
25234 | static QColor fromHsvF(qreal h, qreal s, qreal v, qreal a = 1.0); | |
25235 | static QColor fromCmyk(int c, int m, int y, int k, int a = 255); | |
25236 | static QColor fromCmykF(qreal c, qreal m, qreal y, qreal k, qreal a = 1.0); | |
25237 | QColor light(int f = 150) const; | |
25238 | QColor lighter(int f = 150) const; | |
25239 | QColor dark(int f = 200) const; | |
25240 | QColor darker(int f = 200) const; | |
25241 | QColor &operator=(const QColor &); | |
25242 | QColor &operator=(Qt::GlobalColor color); | |
25243 | bool operator==(const QColor &c) const; | |
25244 | bool operator!=(const QColor &c) const; | |
25245 | operator QVariant() const; | |
25246 | private: | |
25247 | QColor(int, int, int, Spec); | |
25248 | void invalidate(); | |
25249 | Spec cspec; | |
25250 | union { | |
25251 | struct { | |
25252 | ushort alpha; | |
25253 | ushort red; | |
25254 | ushort green; | |
25255 | ushort blue; | |
25256 | ushort pad; | |
25257 | } argb; | |
25258 | struct { | |
25259 | ushort alpha; | |
25260 | ushort hue; | |
25261 | ushort saturation; | |
25262 | ushort value; | |
25263 | ushort pad; | |
25264 | } ahsv; | |
25265 | struct { | |
25266 | ushort alpha; | |
25267 | ushort cyan; | |
25268 | ushort magenta; | |
25269 | ushort yellow; | |
25270 | ushort black; | |
25271 | } acmyk; | |
25272 | } ct; | |
25273 | friend class QColormap; | |
25274 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QColor &); | |
25275 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QColor &); | |
25276 | }; | |
25277 | inline QColor::QColor() | |
25278 | { invalidate(); } | |
25279 | inline QColor::QColor(int r, int g, int b, int a) | |
25280 | { setRgb(r, g, b, a); } | |
25281 | inline QColor::QColor(const char *aname) | |
25282 | { setNamedColor(QLatin1String(aname)); } | |
25283 | inline QColor::QColor(const QString& aname) | |
25284 | { setNamedColor(aname); } | |
25285 | inline QColor::QColor(const QColor &acolor) | |
25286 | : cspec(acolor.cspec) | |
25287 | { ct.argb = acolor.ct.argb; } | |
25288 | inline bool QColor::isValid() const | |
25289 | { return cspec != Invalid; } | |
25290 | inline QColor QColor::lighter(int f) const | |
25291 | { return light(f); } | |
25292 | inline QColor QColor::darker(int f) const | |
25293 | { return dark(f); } | |
25294 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
25295 | class QPaintDevice; | |
25296 | class QWidget; | |
25297 | class QDialog; | |
25298 | class QColor; | |
25299 | class QPalette; | |
25300 | class QCursor; | |
25301 | class QPoint; | |
25302 | class QSize; | |
25303 | class QRect; | |
25304 | class QPolygon; | |
25305 | class QPainter; | |
25306 | class QRegion; | |
25307 | class QFont; | |
25308 | class QFontMetrics; | |
25309 | class QFontInfo; | |
25310 | class QPen; | |
25311 | class QBrush; | |
25312 | class QMatrix; | |
25313 | class QPixmap; | |
25314 | class QBitmap; | |
25315 | class QMovie; | |
25316 | class QImage; | |
25317 | class QPicture; | |
25318 | class QPrinter; | |
25319 | class QTimer; | |
25320 | class QTime; | |
25321 | class QClipboard; | |
25322 | class QString; | |
25323 | class QByteArray; | |
25324 | class QApplication; | |
25325 | template<typename T> class QList; | |
25326 | typedef QList<QWidget *> QWidgetList; | |
25327 | typedef unsigned long WId; | |
25328 | struct QWSEvent; | |
25329 | template<class K, class V> class QHash; | |
25330 | typedef QHash<WId, QWidget *> QWidgetMapper; | |
25331 | template<class V> class QSet; | |
25332 | typedef QSet<QWidget *> QWidgetSet; | |
25333 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
25334 | template <class T> class QVector; | |
25335 | class QVariant; | |
25336 | struct QRegionPrivate; | |
25337 | class QBitmap; | |
25338 | class __attribute__((visibility("default"))) QRegion | |
25339 | { | |
25340 | public: | |
25341 | enum RegionType { Rectangle, Ellipse }; | |
25342 | QRegion(); | |
25343 | QRegion(int x, int y, int w, int h, RegionType t = Rectangle); | |
25344 | QRegion(const QRect &r, RegionType t = Rectangle); | |
25345 | QRegion(const QPolygon &pa, Qt::FillRule fillRule = Qt::OddEvenFill); | |
25346 | QRegion(const QRegion ®ion); | |
25347 | QRegion(const QBitmap &bitmap); | |
25348 | ~QRegion(); | |
25349 | QRegion &operator=(const QRegion &); | |
25350 | bool isEmpty() const; | |
25351 | bool contains(const QPoint &p) const; | |
25352 | bool contains(const QRect &r) const; | |
25353 | void translate(int dx, int dy); | |
25354 | inline void translate(const QPoint &p) { translate(p.x(), p.y()); } | |
25355 | QRegion translated(int dx, int dy) const; | |
25356 | inline QRegion translated(const QPoint &p) const { return translated(p.x(), p.y()); } | |
25357 | QRegion unite(const QRegion &r) const; | |
25358 | QRegion unite(const QRect &r) const; | |
25359 | QRegion intersect(const QRegion &r) const; | |
25360 | QRegion intersect(const QRect &r) const; | |
25361 | QRegion subtract(const QRegion &r) const; | |
25362 | QRegion eor(const QRegion &r) const; | |
25363 | inline QRegion united(const QRegion &r) const { return unite(r); } | |
25364 | inline QRegion united(const QRect &r) const { return unite(r); } | |
25365 | inline QRegion intersected(const QRegion &r) const { return intersect(r); } | |
25366 | inline QRegion intersected(const QRect &r) const { return intersect(r); } | |
25367 | inline QRegion subtracted(const QRegion &r) const { return subtract(r); } | |
25368 | inline QRegion xored(const QRegion &r) const { return eor(r); } | |
25369 | bool intersects(const QRegion &r) const; | |
25370 | bool intersects(const QRect &r) const; | |
25371 | QRect boundingRect() const; | |
25372 | QVector<QRect> rects() const; | |
25373 | void setRects(const QRect *rect, int num); | |
25374 | int numRects() const; | |
25375 | const QRegion operator|(const QRegion &r) const; | |
25376 | const QRegion operator+(const QRegion &r) const; | |
25377 | const QRegion operator+(const QRect &r) const; | |
25378 | const QRegion operator&(const QRegion &r) const; | |
25379 | const QRegion operator&(const QRect &r) const; | |
25380 | const QRegion operator-(const QRegion &r) const; | |
25381 | const QRegion operator^(const QRegion &r) const; | |
25382 | QRegion& operator|=(const QRegion &r); | |
25383 | QRegion& operator+=(const QRegion &r); | |
25384 | QRegion& operator+=(const QRect &r); | |
25385 | QRegion& operator&=(const QRegion &r); | |
25386 | QRegion& operator&=(const QRect &r); | |
25387 | QRegion& operator-=(const QRegion &r); | |
25388 | QRegion& operator^=(const QRegion &r); | |
25389 | bool operator==(const QRegion &r) const; | |
25390 | inline bool operator!=(const QRegion &r) const { return !(operator==(r)); } | |
25391 | operator QVariant() const; | |
25392 | inline void *handle() const { return d->qt_rgn; } | |
25393 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QRegion &); | |
25394 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QRegion &); | |
25395 | private: | |
25396 | QRegion copy() const; | |
25397 | void detach(); | |
25398 | friend bool qt_region_strictContains(const QRegion ®ion, | |
25399 | const QRect &rect); | |
25400 | friend struct QRegionPrivate; | |
25401 | void exec(const QByteArray &ba, int ver = 0, QDataStream::ByteOrder byteOrder = QDataStream::BigEndian); | |
25402 | struct QRegionData { | |
25403 | QBasicAtomicInt ref; | |
25404 | QRegionPrivate *qt_rgn; | |
25405 | }; | |
25406 | struct QRegionData *d; | |
25407 | static struct QRegionData shared_empty; | |
25408 | static void cleanUp(QRegionData *x); | |
25409 | }; | |
25410 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QRegion &); | |
25411 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QRegion &); | |
25412 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QRegion &); | |
25413 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
25414 | class QKeySequence; | |
25415 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &in, const QKeySequence &ks); | |
25416 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &out, QKeySequence &ks); | |
25417 | class QVariant; | |
25418 | class QKeySequencePrivate; | |
25419 | class __attribute__((visibility("default"))) QKeySequence | |
25420 | { | |
25421 | public: | |
25422 | enum StandardKey { | |
25423 | UnknownKey, | |
25424 | HelpContents, | |
25425 | WhatsThis, | |
25426 | Open, | |
25427 | Close, | |
25428 | Save, | |
25429 | New, | |
25430 | Delete, | |
25431 | Cut, | |
25432 | Copy, | |
25433 | Paste, | |
25434 | Undo, | |
25435 | Redo, | |
25436 | Back, | |
25437 | Forward, | |
25438 | Refresh, | |
25439 | ZoomIn, | |
25440 | ZoomOut, | |
25441 | Print, | |
25442 | AddTab, | |
25443 | NextChild, | |
25444 | PreviousChild, | |
25445 | Find, | |
25446 | FindNext, | |
25447 | FindPrevious, | |
25448 | Replace, | |
25449 | SelectAll, | |
25450 | Bold, | |
25451 | Italic, | |
25452 | Underline, | |
25453 | MoveToNextChar, | |
25454 | MoveToPreviousChar, | |
25455 | MoveToNextWord, | |
25456 | MoveToPreviousWord, | |
25457 | MoveToNextLine, | |
25458 | MoveToPreviousLine, | |
25459 | MoveToNextPage, | |
25460 | MoveToPreviousPage, | |
25461 | MoveToStartOfLine, | |
25462 | MoveToEndOfLine, | |
25463 | MoveToStartOfBlock, | |
25464 | MoveToEndOfBlock, | |
25465 | MoveToStartOfDocument, | |
25466 | MoveToEndOfDocument, | |
25467 | SelectNextChar, | |
25468 | SelectPreviousChar, | |
25469 | SelectNextWord, | |
25470 | SelectPreviousWord, | |
25471 | SelectNextLine, | |
25472 | SelectPreviousLine, | |
25473 | SelectNextPage, | |
25474 | SelectPreviousPage, | |
25475 | SelectStartOfLine, | |
25476 | SelectEndOfLine, | |
25477 | SelectStartOfBlock, | |
25478 | SelectEndOfBlock, | |
25479 | SelectStartOfDocument, | |
25480 | SelectEndOfDocument, | |
25481 | DeleteStartOfWord, | |
25482 | DeleteEndOfWord, | |
25483 | DeleteEndOfLine, | |
25484 | InsertParagraphSeparator, | |
25485 | InsertLineSeparator, | |
25486 | SaveAs | |
25487 | }; | |
25488 | QKeySequence(); | |
25489 | QKeySequence(const QString &key); | |
25490 | QKeySequence(int k1, int k2 = 0, int k3 = 0, int k4 = 0); | |
25491 | QKeySequence(const QKeySequence &ks); | |
25492 | QKeySequence(StandardKey key); | |
25493 | ~QKeySequence(); | |
25494 | uint count() const; | |
25495 | bool isEmpty() const; | |
25496 | enum SequenceMatch { | |
25497 | NoMatch, | |
25498 | PartialMatch, | |
25499 | ExactMatch | |
25500 | }; | |
25501 | enum SequenceFormat { | |
25502 | NativeText, | |
25503 | PortableText | |
25504 | }; | |
25505 | QString toString(SequenceFormat format = PortableText) const; | |
25506 | static QKeySequence fromString(const QString &str, SequenceFormat format = PortableText); | |
25507 | SequenceMatch matches(const QKeySequence &seq) const; | |
25508 | static QKeySequence mnemonic(const QString &text); | |
25509 | static QList<QKeySequence> keyBindings(StandardKey key); | |
25510 | operator QString() const; | |
25511 | operator QVariant() const; | |
25512 | operator int() const; | |
25513 | int operator[](uint i) const; | |
25514 | QKeySequence &operator=(const QKeySequence &other); | |
25515 | bool operator==(const QKeySequence &other) const; | |
25516 | inline bool operator!= (const QKeySequence &other) const | |
25517 | { return !(*this == other); } | |
25518 | bool operator< (const QKeySequence &ks) const; | |
25519 | inline bool operator> (const QKeySequence &other) const | |
25520 | { return other < *this; } | |
25521 | inline bool operator<= (const QKeySequence &other) const | |
25522 | { return !(other < *this); } | |
25523 | inline bool operator>= (const QKeySequence &other) const | |
25524 | { return !(*this < other); } | |
25525 | bool isDetached() const; | |
25526 | private: | |
25527 | static int decodeString(const QString &ks); | |
25528 | static QString encodeString(int key); | |
25529 | int assign(const QString &str); | |
25530 | void setKey(int key, int index); | |
25531 | QKeySequencePrivate *d; | |
25532 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &in, const QKeySequence &ks); | |
25533 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &in, QKeySequence &ks); | |
25534 | friend class Q3AccelManager; | |
25535 | friend class QShortcutMap; | |
25536 | friend class QShortcut; | |
25537 | public: | |
25538 | typedef QKeySequencePrivate * DataPtr; | |
25539 | inline DataPtr &data_ptr() { return d; } | |
25540 | }; | |
25541 | template <> class QTypeInfo<QKeySequence> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QKeySequence)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QKeySequence"; } }; | |
25542 | template <> inline bool qIsDetached<QKeySequence>(QKeySequence &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QKeySequence>(QKeySequence &value1, QKeySequence &value2) { const QKeySequence::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
25543 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QKeySequence &); | |
25544 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
25545 | class QEventPrivate; | |
25546 | class __attribute__((visibility("default"))) QEvent | |
25547 | { | |
25548 | public: | |
25549 | enum Type { | |
25550 | None = 0, | |
25551 | Timer = 1, | |
25552 | MouseButtonPress = 2, | |
25553 | MouseButtonRelease = 3, | |
25554 | MouseButtonDblClick = 4, | |
25555 | MouseMove = 5, | |
25556 | KeyPress = 6, | |
25557 | KeyRelease = 7, | |
25558 | FocusIn = 8, | |
25559 | FocusOut = 9, | |
25560 | Enter = 10, | |
25561 | Leave = 11, | |
25562 | Paint = 12, | |
25563 | Move = 13, | |
25564 | Resize = 14, | |
25565 | Create = 15, | |
25566 | Destroy = 16, | |
25567 | Show = 17, | |
25568 | Hide = 18, | |
25569 | Close = 19, | |
25570 | Quit = 20, | |
25571 | ParentChange = 21, | |
25572 | ParentAboutToChange = 131, | |
25573 | ThreadChange = 22, | |
25574 | WindowActivate = 24, | |
25575 | WindowDeactivate = 25, | |
25576 | ShowToParent = 26, | |
25577 | HideToParent = 27, | |
25578 | Wheel = 31, | |
25579 | WindowTitleChange = 33, | |
25580 | WindowIconChange = 34, | |
25581 | ApplicationWindowIconChange = 35, | |
25582 | ApplicationFontChange = 36, | |
25583 | ApplicationLayoutDirectionChange = 37, | |
25584 | ApplicationPaletteChange = 38, | |
25585 | PaletteChange = 39, | |
25586 | Clipboard = 40, | |
25587 | Speech = 42, | |
25588 | MetaCall = 43, | |
25589 | SockAct = 50, | |
25590 | WinEventAct = 132, | |
25591 | DeferredDelete = 52, | |
25592 | DragEnter = 60, | |
25593 | DragMove = 61, | |
25594 | DragLeave = 62, | |
25595 | Drop = 63, | |
25596 | DragResponse = 64, | |
25597 | ChildAdded = 68, | |
25598 | ChildPolished = 69, | |
25599 | ChildRemoved = 71, | |
25600 | ShowWindowRequest = 73, | |
25601 | PolishRequest = 74, | |
25602 | Polish = 75, | |
25603 | LayoutRequest = 76, | |
25604 | UpdateRequest = 77, | |
25605 | UpdateLater = 78, | |
25606 | EmbeddingControl = 79, | |
25607 | ActivateControl = 80, | |
25608 | DeactivateControl = 81, | |
25609 | ContextMenu = 82, | |
25610 | InputMethod = 83, | |
25611 | AccessibilityPrepare = 86, | |
25612 | TabletMove = 87, | |
25613 | LocaleChange = 88, | |
25614 | LanguageChange = 89, | |
25615 | LayoutDirectionChange = 90, | |
25616 | Style = 91, | |
25617 | TabletPress = 92, | |
25618 | TabletRelease = 93, | |
25619 | OkRequest = 94, | |
25620 | HelpRequest = 95, | |
25621 | IconDrag = 96, | |
25622 | FontChange = 97, | |
25623 | EnabledChange = 98, | |
25624 | ActivationChange = 99, | |
25625 | StyleChange = 100, | |
25626 | IconTextChange = 101, | |
25627 | ModifiedChange = 102, | |
25628 | MouseTrackingChange = 109, | |
25629 | WindowBlocked = 103, | |
25630 | WindowUnblocked = 104, | |
25631 | WindowStateChange = 105, | |
25632 | ToolTip = 110, | |
25633 | WhatsThis = 111, | |
25634 | StatusTip = 112, | |
25635 | ActionChanged = 113, | |
25636 | ActionAdded = 114, | |
25637 | ActionRemoved = 115, | |
25638 | FileOpen = 116, | |
25639 | Shortcut = 117, | |
25640 | ShortcutOverride = 51, | |
25641 | WhatsThisClicked = 118, | |
25642 | ToolBarChange = 120, | |
25643 | ApplicationActivate = 121, | |
25644 | ApplicationActivated = ApplicationActivate, | |
25645 | ApplicationDeactivate = 122, | |
25646 | ApplicationDeactivated = ApplicationDeactivate, | |
25647 | QueryWhatsThis = 123, | |
25648 | EnterWhatsThisMode = 124, | |
25649 | LeaveWhatsThisMode = 125, | |
25650 | ZOrderChange = 126, | |
25651 | HoverEnter = 127, | |
25652 | HoverLeave = 128, | |
25653 | HoverMove = 129, | |
25654 | AccessibilityHelp = 119, | |
25655 | AccessibilityDescription = 130, | |
25656 | AcceptDropsChange = 152, | |
25657 | MenubarUpdated = 153, | |
25658 | ZeroTimerEvent = 154, | |
25659 | GraphicsSceneMouseMove = 155, | |
25660 | GraphicsSceneMousePress = 156, | |
25661 | GraphicsSceneMouseRelease = 157, | |
25662 | GraphicsSceneMouseDoubleClick = 158, | |
25663 | GraphicsSceneContextMenu = 159, | |
25664 | GraphicsSceneHoverEnter = 160, | |
25665 | GraphicsSceneHoverMove = 161, | |
25666 | GraphicsSceneHoverLeave = 162, | |
25667 | GraphicsSceneHelp = 163, | |
25668 | GraphicsSceneDragEnter = 164, | |
25669 | GraphicsSceneDragMove = 165, | |
25670 | GraphicsSceneDragLeave = 166, | |
25671 | GraphicsSceneDrop = 167, | |
25672 | GraphicsSceneWheel = 168, | |
25673 | KeyboardLayoutChange = 169, | |
25674 | DynamicPropertyChange = 170, | |
25675 | TabletEnterProximity = 171, | |
25676 | TabletLeaveProximity = 172, | |
25677 | NonClientAreaMouseMove = 173, | |
25678 | NonClientAreaMouseButtonPress = 174, | |
25679 | NonClientAreaMouseButtonRelease = 175, | |
25680 | NonClientAreaMouseButtonDblClick = 176, | |
25681 | MacSizeChange = 177, | |
25682 | ContentsRectChange = 178, | |
25683 | MacGLWindowChange = 179, | |
25684 | FutureCallOut = 180, | |
25685 | GraphicsSceneResize = 181, | |
25686 | GraphicsSceneMove = 182, | |
25687 | CursorChange = 183, | |
25688 | ToolTipChange = 184, | |
25689 | NetworkReplyUpdated = 185, | |
25690 | GrabMouse = 186, | |
25691 | UngrabMouse = 187, | |
25692 | GrabKeyboard = 188, | |
25693 | UngrabKeyboard = 189, | |
25694 | CocoaRequestModal = 190, | |
25695 | MacGLClearDrawable = 191, | |
25696 | User = 1000, | |
25697 | MaxUser = 65535 | |
25698 | }; | |
25699 | QEvent(Type type); | |
25700 | virtual ~QEvent(); | |
25701 | inline Type type() const { return static_cast<Type>(t); } | |
25702 | inline bool spontaneous() const { return spont; } | |
25703 | inline void setAccepted(bool accepted) { m_accept = accepted; } | |
25704 | inline bool isAccepted() const { return m_accept; } | |
25705 | inline void accept() { m_accept = true; } | |
25706 | inline void ignore() { m_accept = false; } | |
25707 | static int registerEventType(int hint = -1); | |
25708 | protected: | |
25709 | QEventPrivate *d; | |
25710 | ushort t; | |
25711 | private: | |
25712 | ushort posted : 1; | |
25713 | ushort spont : 1; | |
25714 | ushort m_accept : 1; | |
25715 | ushort reserved : 13; | |
25716 | friend class QCoreApplication; | |
25717 | friend class QCoreApplicationPrivate; | |
25718 | friend class QThreadData; | |
25719 | friend class QApplication; | |
25720 | friend class QApplicationPrivate; | |
25721 | friend class Q3AccelManager; | |
25722 | friend class QShortcutMap; | |
25723 | friend class QETWidget; | |
25724 | }; | |
25725 | class __attribute__((visibility("default"))) QTimerEvent : public QEvent | |
25726 | { | |
25727 | public: | |
25728 | QTimerEvent( int timerId ); | |
25729 | ~QTimerEvent(); | |
25730 | int timerId() const { return id; } | |
25731 | protected: | |
25732 | int id; | |
25733 | }; | |
25734 | class QObject; | |
25735 | class __attribute__((visibility("default"))) QChildEvent : public QEvent | |
25736 | { | |
25737 | public: | |
25738 | QChildEvent( Type type, QObject *child ); | |
25739 | ~QChildEvent(); | |
25740 | QObject *child() const { return c; } | |
25741 | bool added() const { return type() == ChildAdded; } | |
25742 | bool polished() const { return type() == ChildPolished; } | |
25743 | bool removed() const { return type() == ChildRemoved; } | |
25744 | protected: | |
25745 | QObject *c; | |
25746 | }; | |
25747 | class __attribute__((visibility("default"))) QDynamicPropertyChangeEvent : public QEvent | |
25748 | { | |
25749 | public: | |
25750 | QDynamicPropertyChangeEvent(const QByteArray &name); | |
25751 | ~QDynamicPropertyChangeEvent(); | |
25752 | inline QByteArray propertyName() const { return n; } | |
25753 | private: | |
25754 | QByteArray n; | |
25755 | }; | |
25756 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
25757 | class __attribute__((visibility("default"))) QMetaType { | |
25758 | public: | |
25759 | enum Type { | |
25760 | Void = 0, Bool = 1, Int = 2, UInt = 3, LongLong = 4, ULongLong = 5, | |
25761 | Double = 6, QChar = 7, QVariantMap = 8, QVariantList = 9, | |
25762 | QString = 10, QStringList = 11, QByteArray = 12, | |
25763 | QBitArray = 13, QDate = 14, QTime = 15, QDateTime = 16, QUrl = 17, | |
25764 | QLocale = 18, QRect = 19, QRectF = 20, QSize = 21, QSizeF = 22, | |
25765 | QLine = 23, QLineF = 24, QPoint = 25, QPointF = 26, QRegExp = 27, | |
25766 | QVariantHash = 28, LastCoreType = 28 , | |
25767 | FirstGuiType = 63 , | |
25768 | QFont = 64, QPixmap = 65, QBrush = 66, QColor = 67, QPalette = 68, | |
25769 | QIcon = 69, QImage = 70, QPolygon = 71, QRegion = 72, QBitmap = 73, | |
25770 | QCursor = 74, QSizePolicy = 75, QKeySequence = 76, QPen = 77, | |
25771 | QTextLength = 78, QTextFormat = 79, QMatrix = 80, QTransform = 81, | |
25772 | LastGuiType = 81 , | |
25773 | FirstCoreExtType = 128 , | |
25774 | VoidStar = 128, Long = 129, Short = 130, Char = 131, ULong = 132, | |
25775 | UShort = 133, UChar = 134, Float = 135, QObjectStar = 136, QWidgetStar = 137, | |
25776 | LastCoreExtType = 137 , | |
25777 | User = 256 | |
25778 | }; | |
25779 | typedef void (*Destructor)(void *); | |
25780 | typedef void *(*Constructor)(const void *); | |
25781 | typedef void (*SaveOperator)(QDataStream &, const void *); | |
25782 | typedef void (*LoadOperator)(QDataStream &, void *); | |
25783 | static void registerStreamOperators(const char *typeName, SaveOperator saveOp, | |
25784 | LoadOperator loadOp); | |
25785 | static int registerType(const char *typeName, Destructor destructor, | |
25786 | Constructor constructor); | |
25787 | static int type(const char *typeName); | |
25788 | static const char *typeName(int type); | |
25789 | static bool isRegistered(int type); | |
25790 | static void *construct(int type, const void *copy = 0); | |
25791 | static void destroy(int type, void *data); | |
25792 | static void unregisterType(const char *typeName); | |
25793 | static bool save(QDataStream &stream, int type, const void *data); | |
25794 | static bool load(QDataStream &stream, int type, void *data); | |
25795 | }; | |
25796 | template <typename T> | |
25797 | void qMetaTypeDeleteHelper(T *t) | |
25798 | { | |
25799 | delete t; | |
25800 | } | |
25801 | template <typename T> | |
25802 | void *qMetaTypeConstructHelper(const T *t) | |
25803 | { | |
25804 | if (!t) | |
25805 | return new T; | |
25806 | return new T(*static_cast<const T*>(t)); | |
25807 | } | |
25808 | template <typename T> | |
25809 | void qMetaTypeSaveHelper(QDataStream &stream, const T *t) | |
25810 | { | |
25811 | stream << *t; | |
25812 | } | |
25813 | template <typename T> | |
25814 | void qMetaTypeLoadHelper(QDataStream &stream, T *t) | |
25815 | { | |
25816 | stream >> *t; | |
25817 | } | |
25818 | template <typename T> | |
25819 | int qRegisterMetaType(const char *typeName | |
25820 | , T * = 0 | |
25821 | ) | |
25822 | { | |
25823 | typedef void*(*ConstructPtr)(const T*); | |
25824 | ConstructPtr cptr = qMetaTypeConstructHelper<T>; | |
25825 | typedef void(*DeletePtr)(T*); | |
25826 | DeletePtr dptr = qMetaTypeDeleteHelper<T>; | |
25827 | return QMetaType::registerType(typeName, reinterpret_cast<QMetaType::Destructor>(dptr), | |
25828 | reinterpret_cast<QMetaType::Constructor>(cptr)); | |
25829 | } | |
25830 | template <typename T> | |
25831 | void qRegisterMetaTypeStreamOperators(const char *typeName | |
25832 | , T * = 0 | |
25833 | ) | |
25834 | { | |
25835 | typedef void(*SavePtr)(QDataStream &, const T *); | |
25836 | typedef void(*LoadPtr)(QDataStream &, T *); | |
25837 | SavePtr sptr = qMetaTypeSaveHelper<T>; | |
25838 | LoadPtr lptr = qMetaTypeLoadHelper<T>; | |
25839 | qRegisterMetaType<T>(typeName); | |
25840 | QMetaType::registerStreamOperators(typeName, reinterpret_cast<QMetaType::SaveOperator>(sptr), | |
25841 | reinterpret_cast<QMetaType::LoadOperator>(lptr)); | |
25842 | } | |
25843 | template <typename T> | |
25844 | struct QMetaTypeId | |
25845 | { | |
25846 | enum { Defined = 0 }; | |
25847 | }; | |
25848 | template <typename T> | |
25849 | struct QMetaTypeId2 | |
25850 | { | |
25851 | enum { Defined = QMetaTypeId<T>::Defined }; | |
25852 | static inline int qt_metatype_id() { return QMetaTypeId<T>::qt_metatype_id(); } | |
25853 | }; | |
25854 | template <typename T> | |
25855 | inline int qMetaTypeId( | |
25856 | T * = 0 | |
25857 | ) | |
25858 | { | |
25859 | return QMetaTypeId2<T>::qt_metatype_id(); | |
25860 | } | |
25861 | template <typename T> | |
25862 | inline int qRegisterMetaType( | |
25863 | T * dummy = 0 | |
25864 | ) | |
25865 | { | |
25866 | return qMetaTypeId(dummy); | |
25867 | } | |
25868 | class QString; | |
25869 | class QByteArray; | |
25870 | class QChar; | |
25871 | class QStringList; | |
25872 | class QBitArray; | |
25873 | class QDate; | |
25874 | class QTime; | |
25875 | class QDateTime; | |
25876 | class QUrl; | |
25877 | class QLocale; | |
25878 | class QRect; | |
25879 | class QRectF; | |
25880 | class QSize; | |
25881 | class QSizeF; | |
25882 | class QLine; | |
25883 | class QLineF; | |
25884 | class QPoint; | |
25885 | class QPointF; | |
25886 | class QRegExp; | |
25887 | class QWidget; | |
25888 | class QObject; | |
25889 | class QFont; | |
25890 | class QPixmap; | |
25891 | class QBrush; | |
25892 | class QColor; | |
25893 | class QPalette; | |
25894 | class QIcon; | |
25895 | class QImage; | |
25896 | class QPolygon; | |
25897 | class QRegion; | |
25898 | class QBitmap; | |
25899 | class QCursor; | |
25900 | class QSizePolicy; | |
25901 | class QKeySequence; | |
25902 | class QPen; | |
25903 | class QTextLength; | |
25904 | class QTextFormat; | |
25905 | class QMatrix; | |
25906 | class QTransform; | |
25907 | template<> struct QMetaTypeId2<QString> { enum { Defined = 1, MetaType = QMetaType::QString }; static inline int qt_metatype_id() { return QMetaType::QString; } }; | |
25908 | template<> struct QMetaTypeId2<int> { enum { Defined = 1, MetaType = QMetaType::Int }; static inline int qt_metatype_id() { return QMetaType::Int; } }; | |
25909 | template<> struct QMetaTypeId2<uint> { enum { Defined = 1, MetaType = QMetaType::UInt }; static inline int qt_metatype_id() { return QMetaType::UInt; } }; | |
25910 | template<> struct QMetaTypeId2<bool> { enum { Defined = 1, MetaType = QMetaType::Bool }; static inline int qt_metatype_id() { return QMetaType::Bool; } }; | |
25911 | template<> struct QMetaTypeId2<double> { enum { Defined = 1, MetaType = QMetaType::Double }; static inline int qt_metatype_id() { return QMetaType::Double; } }; | |
25912 | template<> struct QMetaTypeId2<QByteArray> { enum { Defined = 1, MetaType = QMetaType::QByteArray }; static inline int qt_metatype_id() { return QMetaType::QByteArray; } }; | |
25913 | template<> struct QMetaTypeId2<QChar> { enum { Defined = 1, MetaType = QMetaType::QChar }; static inline int qt_metatype_id() { return QMetaType::QChar; } }; | |
25914 | template<> struct QMetaTypeId2<long> { enum { Defined = 1, MetaType = QMetaType::Long }; static inline int qt_metatype_id() { return QMetaType::Long; } }; | |
25915 | template<> struct QMetaTypeId2<short> { enum { Defined = 1, MetaType = QMetaType::Short }; static inline int qt_metatype_id() { return QMetaType::Short; } }; | |
25916 | template<> struct QMetaTypeId2<char> { enum { Defined = 1, MetaType = QMetaType::Char }; static inline int qt_metatype_id() { return QMetaType::Char; } }; | |
25917 | template<> struct QMetaTypeId2<ulong> { enum { Defined = 1, MetaType = QMetaType::ULong }; static inline int qt_metatype_id() { return QMetaType::ULong; } }; | |
25918 | template<> struct QMetaTypeId2<ushort> { enum { Defined = 1, MetaType = QMetaType::UShort }; static inline int qt_metatype_id() { return QMetaType::UShort; } }; | |
25919 | template<> struct QMetaTypeId2<uchar> { enum { Defined = 1, MetaType = QMetaType::UChar }; static inline int qt_metatype_id() { return QMetaType::UChar; } }; | |
25920 | template<> struct QMetaTypeId2<float> { enum { Defined = 1, MetaType = QMetaType::Float }; static inline int qt_metatype_id() { return QMetaType::Float; } }; | |
25921 | template<> struct QMetaTypeId2<QObject *> { enum { Defined = 1, MetaType = QMetaType::QObjectStar }; static inline int qt_metatype_id() { return QMetaType::QObjectStar; } }; | |
25922 | template<> struct QMetaTypeId2<QWidget *> { enum { Defined = 1, MetaType = QMetaType::QWidgetStar }; static inline int qt_metatype_id() { return QMetaType::QWidgetStar; } }; | |
25923 | template<> struct QMetaTypeId2<void *> { enum { Defined = 1, MetaType = QMetaType::VoidStar }; static inline int qt_metatype_id() { return QMetaType::VoidStar; } }; | |
25924 | template<> struct QMetaTypeId2<qlonglong> { enum { Defined = 1, MetaType = QMetaType::LongLong }; static inline int qt_metatype_id() { return QMetaType::LongLong; } }; | |
25925 | template<> struct QMetaTypeId2<qulonglong> { enum { Defined = 1, MetaType = QMetaType::ULongLong }; static inline int qt_metatype_id() { return QMetaType::ULongLong; } }; | |
25926 | template<> struct QMetaTypeId2<QStringList> { enum { Defined = 1, MetaType = QMetaType::QStringList }; static inline int qt_metatype_id() { return QMetaType::QStringList; } }; | |
25927 | template<> struct QMetaTypeId2<QBitArray> { enum { Defined = 1, MetaType = QMetaType::QBitArray }; static inline int qt_metatype_id() { return QMetaType::QBitArray; } }; | |
25928 | template<> struct QMetaTypeId2<QDate> { enum { Defined = 1, MetaType = QMetaType::QDate }; static inline int qt_metatype_id() { return QMetaType::QDate; } }; | |
25929 | template<> struct QMetaTypeId2<QTime> { enum { Defined = 1, MetaType = QMetaType::QTime }; static inline int qt_metatype_id() { return QMetaType::QTime; } }; | |
25930 | template<> struct QMetaTypeId2<QDateTime> { enum { Defined = 1, MetaType = QMetaType::QDateTime }; static inline int qt_metatype_id() { return QMetaType::QDateTime; } }; | |
25931 | template<> struct QMetaTypeId2<QUrl> { enum { Defined = 1, MetaType = QMetaType::QUrl }; static inline int qt_metatype_id() { return QMetaType::QUrl; } }; | |
25932 | template<> struct QMetaTypeId2<QLocale> { enum { Defined = 1, MetaType = QMetaType::QLocale }; static inline int qt_metatype_id() { return QMetaType::QLocale; } }; | |
25933 | template<> struct QMetaTypeId2<QRect> { enum { Defined = 1, MetaType = QMetaType::QRect }; static inline int qt_metatype_id() { return QMetaType::QRect; } }; | |
25934 | template<> struct QMetaTypeId2<QRectF> { enum { Defined = 1, MetaType = QMetaType::QRectF }; static inline int qt_metatype_id() { return QMetaType::QRectF; } }; | |
25935 | template<> struct QMetaTypeId2<QSize> { enum { Defined = 1, MetaType = QMetaType::QSize }; static inline int qt_metatype_id() { return QMetaType::QSize; } }; | |
25936 | template<> struct QMetaTypeId2<QSizeF> { enum { Defined = 1, MetaType = QMetaType::QSizeF }; static inline int qt_metatype_id() { return QMetaType::QSizeF; } }; | |
25937 | template<> struct QMetaTypeId2<QLine> { enum { Defined = 1, MetaType = QMetaType::QLine }; static inline int qt_metatype_id() { return QMetaType::QLine; } }; | |
25938 | template<> struct QMetaTypeId2<QLineF> { enum { Defined = 1, MetaType = QMetaType::QLineF }; static inline int qt_metatype_id() { return QMetaType::QLineF; } }; | |
25939 | template<> struct QMetaTypeId2<QPoint> { enum { Defined = 1, MetaType = QMetaType::QPoint }; static inline int qt_metatype_id() { return QMetaType::QPoint; } }; | |
25940 | template<> struct QMetaTypeId2<QPointF> { enum { Defined = 1, MetaType = QMetaType::QPointF }; static inline int qt_metatype_id() { return QMetaType::QPointF; } }; | |
25941 | template<> struct QMetaTypeId2<QRegExp> { enum { Defined = 1, MetaType = QMetaType::QRegExp }; static inline int qt_metatype_id() { return QMetaType::QRegExp; } }; | |
25942 | template<> struct QMetaTypeId2<QFont> { enum { Defined = 1, MetaType = QMetaType::QFont }; static inline int qt_metatype_id() { return QMetaType::QFont; } }; | |
25943 | template<> struct QMetaTypeId2<QPixmap> { enum { Defined = 1, MetaType = QMetaType::QPixmap }; static inline int qt_metatype_id() { return QMetaType::QPixmap; } }; | |
25944 | template<> struct QMetaTypeId2<QBrush> { enum { Defined = 1, MetaType = QMetaType::QBrush }; static inline int qt_metatype_id() { return QMetaType::QBrush; } }; | |
25945 | template<> struct QMetaTypeId2<QColor> { enum { Defined = 1, MetaType = QMetaType::QColor }; static inline int qt_metatype_id() { return QMetaType::QColor; } }; | |
25946 | template<> struct QMetaTypeId2<QPalette> { enum { Defined = 1, MetaType = QMetaType::QPalette }; static inline int qt_metatype_id() { return QMetaType::QPalette; } }; | |
25947 | template<> struct QMetaTypeId2<QIcon> { enum { Defined = 1, MetaType = QMetaType::QIcon }; static inline int qt_metatype_id() { return QMetaType::QIcon; } }; | |
25948 | template<> struct QMetaTypeId2<QImage> { enum { Defined = 1, MetaType = QMetaType::QImage }; static inline int qt_metatype_id() { return QMetaType::QImage; } }; | |
25949 | template<> struct QMetaTypeId2<QPolygon> { enum { Defined = 1, MetaType = QMetaType::QPolygon }; static inline int qt_metatype_id() { return QMetaType::QPolygon; } }; | |
25950 | template<> struct QMetaTypeId2<QRegion> { enum { Defined = 1, MetaType = QMetaType::QRegion }; static inline int qt_metatype_id() { return QMetaType::QRegion; } }; | |
25951 | template<> struct QMetaTypeId2<QBitmap> { enum { Defined = 1, MetaType = QMetaType::QBitmap }; static inline int qt_metatype_id() { return QMetaType::QBitmap; } }; | |
25952 | template<> struct QMetaTypeId2<QCursor> { enum { Defined = 1, MetaType = QMetaType::QCursor }; static inline int qt_metatype_id() { return QMetaType::QCursor; } }; | |
25953 | template<> struct QMetaTypeId2<QSizePolicy> { enum { Defined = 1, MetaType = QMetaType::QSizePolicy }; static inline int qt_metatype_id() { return QMetaType::QSizePolicy; } }; | |
25954 | template<> struct QMetaTypeId2<QKeySequence> { enum { Defined = 1, MetaType = QMetaType::QKeySequence }; static inline int qt_metatype_id() { return QMetaType::QKeySequence; } }; | |
25955 | template<> struct QMetaTypeId2<QPen> { enum { Defined = 1, MetaType = QMetaType::QPen }; static inline int qt_metatype_id() { return QMetaType::QPen; } }; | |
25956 | template<> struct QMetaTypeId2<QTextLength> { enum { Defined = 1, MetaType = QMetaType::QTextLength }; static inline int qt_metatype_id() { return QMetaType::QTextLength; } }; | |
25957 | template<> struct QMetaTypeId2<QTextFormat> { enum { Defined = 1, MetaType = QMetaType::QTextFormat }; static inline int qt_metatype_id() { return QMetaType::QTextFormat; } }; | |
25958 | template<> struct QMetaTypeId2<QMatrix> { enum { Defined = 1, MetaType = QMetaType::QMatrix }; static inline int qt_metatype_id() { return QMetaType::QMatrix; } }; | |
25959 | template<> struct QMetaTypeId2<QTransform> { enum { Defined = 1, MetaType = QMetaType::QTransform }; static inline int qt_metatype_id() { return QMetaType::QTransform; } }; | |
25960 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
25961 | class QBitArray; | |
25962 | class QDataStream; | |
25963 | class QDate; | |
25964 | class QDateTime; | |
25965 | class QLine; | |
25966 | class QLineF; | |
25967 | class QLocale; | |
25968 | class QMatrix; | |
25969 | class QTransform; | |
25970 | class QStringList; | |
25971 | class QTime; | |
25972 | class QPoint; | |
25973 | class QPointF; | |
25974 | class QSize; | |
25975 | class QSizeF; | |
25976 | class QRect; | |
25977 | class QRectF; | |
25978 | class QRegExp; | |
25979 | class QTextFormat; | |
25980 | class QTextLength; | |
25981 | class QUrl; | |
25982 | class QVariant; | |
25983 | class QVariantComparisonHelper; | |
25984 | template <typename T> | |
25985 | inline QVariant qVariantFromValue(const T &); | |
25986 | template <typename T> | |
25987 | inline void qVariantSetValue(QVariant &, const T &); | |
25988 | template<typename T> | |
25989 | inline T qVariantValue(const QVariant &); | |
25990 | template<typename T> | |
25991 | inline bool qVariantCanConvert(const QVariant &); | |
25992 | class __attribute__((visibility("default"))) QVariant | |
25993 | { | |
25994 | public: | |
25995 | enum Type { | |
25996 | Invalid = 0, | |
25997 | Bool = 1, | |
25998 | Int = 2, | |
25999 | UInt = 3, | |
26000 | LongLong = 4, | |
26001 | ULongLong = 5, | |
26002 | Double = 6, | |
26003 | Char = 7, | |
26004 | Map = 8, | |
26005 | List = 9, | |
26006 | String = 10, | |
26007 | StringList = 11, | |
26008 | ByteArray = 12, | |
26009 | BitArray = 13, | |
26010 | Date = 14, | |
26011 | Time = 15, | |
26012 | DateTime = 16, | |
26013 | Url = 17, | |
26014 | Locale = 18, | |
26015 | Rect = 19, | |
26016 | RectF = 20, | |
26017 | Size = 21, | |
26018 | SizeF = 22, | |
26019 | Line = 23, | |
26020 | LineF = 24, | |
26021 | Point = 25, | |
26022 | PointF = 26, | |
26023 | RegExp = 27, | |
26024 | Hash = 28, | |
26025 | LastCoreType = Hash, | |
26026 | Font = 64, | |
26027 | Pixmap = 65, | |
26028 | Brush = 66, | |
26029 | Color = 67, | |
26030 | Palette = 68, | |
26031 | Icon = 69, | |
26032 | Image = 70, | |
26033 | Polygon = 71, | |
26034 | Region = 72, | |
26035 | Bitmap = 73, | |
26036 | Cursor = 74, | |
26037 | SizePolicy = 75, | |
26038 | KeySequence = 76, | |
26039 | Pen = 77, | |
26040 | TextLength = 78, | |
26041 | TextFormat = 79, | |
26042 | Matrix = 80, | |
26043 | Transform = 81, | |
26044 | LastGuiType = Transform, | |
26045 | UserType = 127, | |
26046 | LastType = 0xffffffff | |
26047 | }; | |
26048 | inline QVariant(); | |
26049 | ~QVariant(); | |
26050 | QVariant(Type type); | |
26051 | QVariant(int typeOrUserType, const void *copy); | |
26052 | QVariant(const QVariant &other); | |
26053 | QVariant(QDataStream &s); | |
26054 | QVariant(int i); | |
26055 | QVariant(uint ui); | |
26056 | QVariant(qlonglong ll); | |
26057 | QVariant(qulonglong ull); | |
26058 | QVariant(bool b); | |
26059 | QVariant(double d); | |
26060 | __attribute__ ((__deprecated__)) QVariant(const char *str); | |
26061 | QVariant(const QByteArray &bytearray); | |
26062 | QVariant(const QBitArray &bitarray); | |
26063 | QVariant(const QString &string); | |
26064 | QVariant(const QLatin1String &string); | |
26065 | QVariant(const QStringList &stringlist); | |
26066 | QVariant(const QChar &qchar); | |
26067 | QVariant(const QDate &date); | |
26068 | QVariant(const QTime &time); | |
26069 | QVariant(const QDateTime &datetime); | |
26070 | QVariant(const QList<QVariant> &list); | |
26071 | QVariant(const QMap<QString,QVariant> &map); | |
26072 | QVariant(const QHash<QString,QVariant> &hash); | |
26073 | QVariant(const QSize &size); | |
26074 | QVariant(const QSizeF &size); | |
26075 | QVariant(const QPoint &pt); | |
26076 | QVariant(const QPointF &pt); | |
26077 | QVariant(const QLine &line); | |
26078 | QVariant(const QLineF &line); | |
26079 | QVariant(const QRect &rect); | |
26080 | QVariant(const QRectF &rect); | |
26081 | QVariant(const QUrl &url); | |
26082 | QVariant(const QLocale &locale); | |
26083 | QVariant(const QRegExp ®Exp); | |
26084 | QVariant(Qt::GlobalColor color); | |
26085 | QVariant& operator=(const QVariant &other); | |
26086 | Type type() const; | |
26087 | int userType() const; | |
26088 | const char *typeName() const; | |
26089 | bool canConvert(Type t) const; | |
26090 | bool convert(Type t); | |
26091 | inline bool isValid() const; | |
26092 | bool isNull() const; | |
26093 | void clear(); | |
26094 | void detach(); | |
26095 | inline bool isDetached() const; | |
26096 | int toInt(bool *ok = 0) const; | |
26097 | uint toUInt(bool *ok = 0) const; | |
26098 | qlonglong toLongLong(bool *ok = 0) const; | |
26099 | qulonglong toULongLong(bool *ok = 0) const; | |
26100 | bool toBool() const; | |
26101 | double toDouble(bool *ok = 0) const; | |
26102 | QByteArray toByteArray() const; | |
26103 | QBitArray toBitArray() const; | |
26104 | QString toString() const; | |
26105 | QStringList toStringList() const; | |
26106 | QChar toChar() const; | |
26107 | QDate toDate() const; | |
26108 | QTime toTime() const; | |
26109 | QDateTime toDateTime() const; | |
26110 | QList<QVariant> toList() const; | |
26111 | QMap<QString, QVariant> toMap() const; | |
26112 | QHash<QString, QVariant> toHash() const; | |
26113 | QPoint toPoint() const; | |
26114 | QPointF toPointF() const; | |
26115 | QRect toRect() const; | |
26116 | QSize toSize() const; | |
26117 | QSizeF toSizeF() const; | |
26118 | QLine toLine() const; | |
26119 | QLineF toLineF() const; | |
26120 | QRectF toRectF() const; | |
26121 | QUrl toUrl() const; | |
26122 | QLocale toLocale() const; | |
26123 | QRegExp toRegExp() const; | |
26124 | void load(QDataStream &ds); | |
26125 | void save(QDataStream &ds) const; | |
26126 | static const char *typeToName(Type type); | |
26127 | static Type nameToType(const char *name); | |
26128 | void *data(); | |
26129 | const void *constData() const; | |
26130 | inline const void *data() const { return constData(); } | |
26131 | template<typename T> | |
26132 | inline void setValue(const T &value); | |
26133 | template<typename T> | |
26134 | inline T value() const | |
26135 | { return qVariantValue<T>(*this); } | |
26136 | template<typename T> | |
26137 | static inline QVariant fromValue(const T &value) | |
26138 | { return qVariantFromValue(value); } | |
26139 | template<typename T> | |
26140 | bool canConvert() const | |
26141 | { return qVariantCanConvert<T>(*this); } | |
26142 | public: | |
26143 | struct PrivateShared | |
26144 | { | |
26145 | inline PrivateShared(void *v) : ptr(v), ref(1) { } | |
26146 | void *ptr; | |
26147 | QAtomicInt ref; | |
26148 | }; | |
26149 | struct Private | |
26150 | { | |
26151 | inline Private(): type(Invalid), is_shared(false), is_null(true) { data.ptr = 0; } | |
26152 | inline Private(const Private &other) | |
26153 | : data(other.data), type(other.type), | |
26154 | is_shared(other.is_shared), is_null(other.is_null) | |
26155 | {} | |
26156 | union Data | |
26157 | { | |
26158 | char c; | |
26159 | int i; | |
26160 | uint u; | |
26161 | bool b; | |
26162 | double d; | |
26163 | qlonglong ll; | |
26164 | qulonglong ull; | |
26165 | void *ptr; | |
26166 | PrivateShared *shared; | |
26167 | } data; | |
26168 | uint type : 30; | |
26169 | uint is_shared : 1; | |
26170 | uint is_null : 1; | |
26171 | }; | |
26172 | public: | |
26173 | typedef void (*f_construct)(Private *, const void *); | |
26174 | typedef void (*f_clear)(Private *); | |
26175 | typedef bool (*f_null)(const Private *); | |
26176 | typedef void (*f_load)(Private *, QDataStream &); | |
26177 | typedef void (*f_save)(const Private *, QDataStream &); | |
26178 | typedef bool (*f_compare)(const Private *, const Private *); | |
26179 | typedef bool (*f_convert)(const QVariant::Private *d, Type t, void *, bool *); | |
26180 | typedef bool (*f_canConvert)(const QVariant::Private *d, Type t); | |
26181 | typedef void (*f_debugStream)(QDebug, const QVariant &); | |
26182 | struct Handler { | |
26183 | f_construct construct; | |
26184 | f_clear clear; | |
26185 | f_null isNull; | |
26186 | f_load load; | |
26187 | f_save save; | |
26188 | f_compare compare; | |
26189 | f_convert convert; | |
26190 | f_canConvert canConvert; | |
26191 | f_debugStream debugStream; | |
26192 | }; | |
26193 | inline bool operator==(const QVariant &v) const | |
26194 | { return cmp(v); } | |
26195 | inline bool operator!=(const QVariant &v) const | |
26196 | { return !cmp(v); } | |
26197 | protected: | |
26198 | friend inline bool qvariant_cast_helper(const QVariant &, QVariant::Type, void *); | |
26199 | friend int qRegisterGuiVariant(); | |
26200 | friend int qUnregisterGuiVariant(); | |
26201 | friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &); | |
26202 | friend __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QVariant &); | |
26203 | Private d; | |
26204 | static const Handler *handler; | |
26205 | void create(int type, const void *copy); | |
26206 | bool cmp(const QVariant &other) const; | |
26207 | private: | |
26208 | inline QVariant(void *) { qt_noop(); } | |
26209 | inline QVariant(bool, int) { qt_noop(); } | |
26210 | public: | |
26211 | typedef Private DataPtr; | |
26212 | inline DataPtr &data_ptr() { return d; } | |
26213 | }; | |
26214 | typedef QList<QVariant> QVariantList; | |
26215 | typedef QMap<QString, QVariant> QVariantMap; | |
26216 | typedef QHash<QString, QVariant> QVariantHash; | |
26217 | inline bool qvariant_cast_helper(const QVariant &v, QVariant::Type tp, void *ptr) | |
26218 | { return QVariant::handler->convert(&v.d, tp, ptr, 0); } | |
26219 | template <typename T> | |
26220 | inline QVariant qVariantFromValue(const T &t) | |
26221 | { | |
26222 | return QVariant(qMetaTypeId<T>(reinterpret_cast<T *>(0)), &t); | |
26223 | } | |
26224 | template <> | |
26225 | inline QVariant qVariantFromValue(const QVariant &t) { return t; } | |
26226 | template <typename T> | |
26227 | inline void qVariantSetValue(QVariant &v, const T &t) | |
26228 | { | |
26229 | v = QVariant(qMetaTypeId<T>(reinterpret_cast<T *>(0)), &t); | |
26230 | } | |
26231 | inline QVariant::QVariant() {} | |
26232 | inline bool QVariant::isValid() const { return d.type != Invalid; } | |
26233 | template<typename T> | |
26234 | inline void QVariant::setValue(const T &avalue) | |
26235 | { qVariantSetValue(*this, avalue); } | |
26236 | __attribute__((visibility("default"))) QDataStream& operator>> (QDataStream& s, QVariant& p); | |
26237 | __attribute__((visibility("default"))) QDataStream& operator<< (QDataStream& s, const QVariant& p); | |
26238 | __attribute__((visibility("default"))) QDataStream& operator>> (QDataStream& s, QVariant::Type& p); | |
26239 | __attribute__((visibility("default"))) QDataStream& operator<< (QDataStream& s, const QVariant::Type p); | |
26240 | inline bool QVariant::isDetached() const | |
26241 | { return !d.is_shared || d.data.shared->ref == 1; } | |
26242 | class QVariantComparisonHelper | |
26243 | { | |
26244 | public: | |
26245 | inline QVariantComparisonHelper(const QVariant &var) | |
26246 | : v(&var) {} | |
26247 | private: | |
26248 | friend inline bool operator==(const QVariant &, const QVariantComparisonHelper &); | |
26249 | const QVariant *v; | |
26250 | }; | |
26251 | inline bool operator==(const QVariant &v1, const QVariantComparisonHelper &v2) | |
26252 | { | |
26253 | return v1.cmp(*v2.v); | |
26254 | } | |
26255 | inline bool operator!=(const QVariant &v1, const QVariantComparisonHelper &v2) | |
26256 | { | |
26257 | return !operator==(v1, v2); | |
26258 | } | |
26259 | template<typename T> T qvariant_cast(const QVariant &v) | |
26260 | { | |
26261 | const int vid = qMetaTypeId<T>(static_cast<T *>(0)); | |
26262 | if (vid == v.userType()) | |
26263 | return *reinterpret_cast<const T *>(v.constData()); | |
26264 | if (vid < int(QMetaType::User)) { | |
26265 | T t; | |
26266 | if (qvariant_cast_helper(v, QVariant::Type(vid), &t)) | |
26267 | return t; | |
26268 | } | |
26269 | return T(); | |
26270 | } | |
26271 | template<typename T> | |
26272 | inline T qVariantValue(const QVariant &variant) | |
26273 | { return qvariant_cast<T>(variant); } | |
26274 | template<typename T> | |
26275 | inline bool qVariantCanConvert(const QVariant &variant) | |
26276 | { | |
26277 | return variant.canConvert(static_cast<QVariant::Type>( | |
26278 | qMetaTypeId<T>(static_cast<T *>(0)))); | |
26279 | } | |
26280 | template <> inline bool qIsDetached<QVariant>(QVariant &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QVariant>(QVariant &value1, QVariant &value2) { const QVariant::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
26281 | template <> class QTypeInfo<QVariant> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QVariant)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QVariant"; } }; | |
26282 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QVariant &); | |
26283 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QVariant::Type); | |
26284 | template<> struct QMetaTypeId2<QVariantList> { enum { Defined = 1, MetaType = QMetaType::QVariantList }; static inline int qt_metatype_id() { return QMetaType::QVariantList; } }; | |
26285 | template<> struct QMetaTypeId2<QVariantMap> { enum { Defined = 1, MetaType = QMetaType::QVariantMap }; static inline int qt_metatype_id() { return QMetaType::QVariantMap; } }; | |
26286 | template<> struct QMetaTypeId2<QVariantHash> { enum { Defined = 1, MetaType = QMetaType::QVariantHash }; static inline int qt_metatype_id() { return QMetaType::QVariantHash; } }; | |
26287 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
26288 | class QUrl; | |
26289 | class QMimeDataPrivate; | |
26290 | class __attribute__((visibility("default"))) QMimeData : public QObject | |
26291 | { | |
26292 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
26293 | public: | |
26294 | QMimeData(); | |
26295 | ~QMimeData(); | |
26296 | QList<QUrl> urls() const; | |
26297 | void setUrls(const QList<QUrl> &urls); | |
26298 | bool hasUrls() const; | |
26299 | QString text() const; | |
26300 | void setText(const QString &text); | |
26301 | bool hasText() const; | |
26302 | QString html() const; | |
26303 | void setHtml(const QString &html); | |
26304 | bool hasHtml() const; | |
26305 | QVariant imageData() const; | |
26306 | void setImageData(const QVariant &image); | |
26307 | bool hasImage() const; | |
26308 | QVariant colorData() const; | |
26309 | void setColorData(const QVariant &color); | |
26310 | bool hasColor() const; | |
26311 | QByteArray data(const QString &mimetype) const; | |
26312 | void setData(const QString &mimetype, const QByteArray &data); | |
26313 | void removeFormat(const QString &mimetype); | |
26314 | virtual bool hasFormat(const QString &mimetype) const; | |
26315 | virtual QStringList formats() const; | |
26316 | void clear(); | |
26317 | protected: | |
26318 | virtual QVariant retrieveData(const QString &mimetype, | |
26319 | QVariant::Type preferredType) const; | |
26320 | private: | |
26321 | QMimeData(const QMimeData &); QMimeData &operator=(const QMimeData &); | |
26322 | inline QMimeDataPrivate* d_func() { return reinterpret_cast<QMimeDataPrivate *>(d_ptr); } inline const QMimeDataPrivate* d_func() const { return reinterpret_cast<const QMimeDataPrivate *>(d_ptr); } friend class QMimeDataPrivate; | |
26323 | }; | |
26324 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
26325 | class __attribute__((visibility("default"))) QMimeSource | |
26326 | { | |
26327 | public: | |
26328 | virtual ~QMimeSource(); | |
26329 | virtual const char* format(int n = 0) const = 0; | |
26330 | virtual bool provides(const char*) const; | |
26331 | virtual QByteArray encodedData(const char*) const = 0; | |
26332 | }; | |
26333 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
26334 | class QMimeData; | |
26335 | class QDragPrivate; | |
26336 | class QWidget; | |
26337 | class QPixmap; | |
26338 | class QPoint; | |
26339 | class QDragManager; | |
26340 | class __attribute__((visibility("default"))) QDrag : public QObject | |
26341 | { | |
26342 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
26343 | inline QDragPrivate* d_func() { return reinterpret_cast<QDragPrivate *>(d_ptr); } inline const QDragPrivate* d_func() const { return reinterpret_cast<const QDragPrivate *>(d_ptr); } friend class QDragPrivate; | |
26344 | public: | |
26345 | explicit QDrag(QWidget *dragSource); | |
26346 | ~QDrag(); | |
26347 | void setMimeData(QMimeData *data); | |
26348 | QMimeData *mimeData() const; | |
26349 | void setPixmap(const QPixmap &); | |
26350 | QPixmap pixmap() const; | |
26351 | void setHotSpot(const QPoint &hotspot); | |
26352 | QPoint hotSpot() const; | |
26353 | QWidget *source() const; | |
26354 | QWidget *target() const; | |
26355 | Qt::DropAction start(Qt::DropActions supportedActions = Qt::CopyAction); | |
26356 | Qt::DropAction exec(Qt::DropActions supportedActions = Qt::MoveAction); | |
26357 | Qt::DropAction exec(Qt::DropActions supportedActions, Qt::DropAction defaultAction); | |
26358 | void setDragCursor(const QPixmap &cursor, Qt::DropAction action); | |
26359 | protected: | |
26360 | void actionChanged(Qt::DropAction action); | |
26361 | void targetChanged(QWidget *newTarget); | |
26362 | private: | |
26363 | friend class QDragManager; | |
26364 | QDrag(const QDrag &); QDrag &operator=(const QDrag &); | |
26365 | }; | |
26366 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
26367 | class QAction; | |
26368 | class __attribute__((visibility("default"))) QInputEvent : public QEvent | |
26369 | { | |
26370 | public: | |
26371 | QInputEvent(Type type, Qt::KeyboardModifiers modifiers = Qt::NoModifier); | |
26372 | ~QInputEvent(); | |
26373 | inline Qt::KeyboardModifiers modifiers() const { return modState; } | |
26374 | protected: | |
26375 | Qt::KeyboardModifiers modState; | |
26376 | }; | |
26377 | class __attribute__((visibility("default"))) QMouseEvent : public QInputEvent | |
26378 | { | |
26379 | public: | |
26380 | QMouseEvent(Type type, const QPoint &pos, Qt::MouseButton button, | |
26381 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); | |
26382 | QMouseEvent(Type type, const QPoint &pos, const QPoint &globalPos, | |
26383 | Qt::MouseButton button, Qt::MouseButtons buttons, | |
26384 | Qt::KeyboardModifiers modifiers); | |
26385 | ~QMouseEvent(); | |
26386 | inline const QPoint &pos() const { return p; } | |
26387 | inline const QPoint &globalPos() const { return g; } | |
26388 | inline int x() const { return p.x(); } | |
26389 | inline int y() const { return p.y(); } | |
26390 | inline int globalX() const { return g.x(); } | |
26391 | inline int globalY() const { return g.y(); } | |
26392 | inline Qt::MouseButton button() const { return b; } | |
26393 | inline Qt::MouseButtons buttons() const { return mouseState; } | |
26394 | static QMouseEvent *createExtendedMouseEvent(Type type, const QPointF &pos, | |
26395 | const QPoint &globalPos, Qt::MouseButton button, | |
26396 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); | |
26397 | inline bool hasExtendedInfo() const { return reinterpret_cast<const QMouseEvent *>(d) == this; } | |
26398 | QPointF posF() const; | |
26399 | protected: | |
26400 | QPoint p, g; | |
26401 | Qt::MouseButton b; | |
26402 | Qt::MouseButtons mouseState; | |
26403 | }; | |
26404 | class __attribute__((visibility("default"))) QHoverEvent : public QEvent | |
26405 | { | |
26406 | public: | |
26407 | QHoverEvent(Type type, const QPoint &pos, const QPoint &oldPos); | |
26408 | ~QHoverEvent(); | |
26409 | inline const QPoint &pos() const { return p; } | |
26410 | inline const QPoint &oldPos() const { return op; } | |
26411 | protected: | |
26412 | QPoint p, op; | |
26413 | }; | |
26414 | class __attribute__((visibility("default"))) QWheelEvent : public QInputEvent | |
26415 | { | |
26416 | public: | |
26417 | QWheelEvent(const QPoint &pos, int delta, | |
26418 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, | |
26419 | Qt::Orientation orient = Qt::Vertical); | |
26420 | QWheelEvent(const QPoint &pos, const QPoint& globalPos, int delta, | |
26421 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, | |
26422 | Qt::Orientation orient = Qt::Vertical); | |
26423 | ~QWheelEvent(); | |
26424 | inline int delta() const { return d; } | |
26425 | inline const QPoint &pos() const { return p; } | |
26426 | inline const QPoint &globalPos() const { return g; } | |
26427 | inline int x() const { return p.x(); } | |
26428 | inline int y() const { return p.y(); } | |
26429 | inline int globalX() const { return g.x(); } | |
26430 | inline int globalY() const { return g.y(); } | |
26431 | inline Qt::MouseButtons buttons() const { return mouseState; } | |
26432 | Qt::Orientation orientation() const { return o; } | |
26433 | protected: | |
26434 | QPoint p; | |
26435 | QPoint g; | |
26436 | int d; | |
26437 | Qt::MouseButtons mouseState; | |
26438 | Qt::Orientation o; | |
26439 | }; | |
26440 | class __attribute__((visibility("default"))) QTabletEvent : public QInputEvent | |
26441 | { | |
26442 | public: | |
26443 | enum TabletDevice { NoDevice, Puck, Stylus, Airbrush, FourDMouse, | |
26444 | XFreeEraser , RotationStylus }; | |
26445 | enum PointerType { UnknownPointer, Pen, Cursor, Eraser }; | |
26446 | QTabletEvent(Type t, const QPoint &pos, const QPoint &globalPos, const QPointF &hiResGlobalPos, | |
26447 | int device, int pointerType, qreal pressure, int xTilt, int yTilt, | |
26448 | qreal tangentialPressure, qreal rotation, int z, | |
26449 | Qt::KeyboardModifiers keyState, qint64 uniqueID); | |
26450 | ~QTabletEvent(); | |
26451 | inline const QPoint &pos() const { return mPos; } | |
26452 | inline const QPoint &globalPos() const { return mGPos; } | |
26453 | inline const QPointF &hiResGlobalPos() const { return mHiResGlobalPos; } | |
26454 | inline int x() const { return mPos.x(); } | |
26455 | inline int y() const { return mPos.y(); } | |
26456 | inline int globalX() const { return mGPos.x(); } | |
26457 | inline int globalY() const { return mGPos.y(); } | |
26458 | inline qreal hiResGlobalX() const { return mHiResGlobalPos.x(); } | |
26459 | inline qreal hiResGlobalY() const { return mHiResGlobalPos.y(); } | |
26460 | inline TabletDevice device() const { return TabletDevice(mDev); } | |
26461 | inline PointerType pointerType() const { return PointerType(mPointerType); } | |
26462 | inline qint64 uniqueId() const { return mUnique; } | |
26463 | inline qreal pressure() const { return mPress; } | |
26464 | inline int z() const { return mZ; } | |
26465 | inline qreal tangentialPressure() const { return mTangential; } | |
26466 | inline qreal rotation() const { return mRot; } | |
26467 | inline int xTilt() const { return mXT; } | |
26468 | inline int yTilt() const { return mYT; } | |
26469 | protected: | |
26470 | QPoint mPos, mGPos; | |
26471 | QPointF mHiResGlobalPos; | |
26472 | int mDev, mPointerType, mXT, mYT, mZ; | |
26473 | qreal mPress, mTangential, mRot; | |
26474 | qint64 mUnique; | |
26475 | void *mExtra; | |
26476 | }; | |
26477 | class __attribute__((visibility("default"))) QKeyEvent : public QInputEvent | |
26478 | { | |
26479 | public: | |
26480 | QKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, const QString& text = QString(), | |
26481 | bool autorep = false, ushort count = 1); | |
26482 | ~QKeyEvent(); | |
26483 | int key() const { return k; } | |
26484 | bool matches(QKeySequence::StandardKey key) const; | |
26485 | Qt::KeyboardModifiers modifiers() const; | |
26486 | inline QString text() const { return txt; } | |
26487 | inline bool isAutoRepeat() const { return autor; } | |
26488 | inline int count() const { return int(c); } | |
26489 | static QKeyEvent *createExtendedKeyEvent(Type type, int key, Qt::KeyboardModifiers modifiers, | |
26490 | quint32 nativeScanCode, quint32 nativeVirtualKey, | |
26491 | quint32 nativeModifiers, | |
26492 | const QString& text = QString(), bool autorep = false, | |
26493 | ushort count = 1); | |
26494 | inline bool hasExtendedInfo() const { return reinterpret_cast<const QKeyEvent*>(d) == this; } | |
26495 | quint32 nativeScanCode() const; | |
26496 | quint32 nativeVirtualKey() const; | |
26497 | quint32 nativeModifiers() const; | |
26498 | protected: | |
26499 | QString txt; | |
26500 | int k; | |
26501 | ushort c; | |
26502 | uint autor:1; | |
26503 | }; | |
26504 | class __attribute__((visibility("default"))) QFocusEvent : public QEvent | |
26505 | { | |
26506 | public: | |
26507 | QFocusEvent(Type type, Qt::FocusReason reason=Qt::OtherFocusReason); | |
26508 | ~QFocusEvent(); | |
26509 | inline bool gotFocus() const { return type() == FocusIn; } | |
26510 | inline bool lostFocus() const { return type() == FocusOut; } | |
26511 | Qt::FocusReason reason(); | |
26512 | Qt::FocusReason reason() const; | |
26513 | private: | |
26514 | Qt::FocusReason m_reason; | |
26515 | }; | |
26516 | class __attribute__((visibility("default"))) QPaintEvent : public QEvent | |
26517 | { | |
26518 | public: | |
26519 | QPaintEvent(const QRegion& paintRegion); | |
26520 | QPaintEvent(const QRect &paintRect); | |
26521 | ~QPaintEvent(); | |
26522 | inline const QRect &rect() const { return m_rect; } | |
26523 | inline const QRegion ®ion() const { return m_region; } | |
26524 | protected: | |
26525 | friend class QApplication; | |
26526 | friend class QCoreApplication; | |
26527 | QRect m_rect; | |
26528 | QRegion m_region; | |
26529 | bool m_erased; | |
26530 | }; | |
26531 | class QUpdateLaterEvent : public QEvent | |
26532 | { | |
26533 | public: | |
26534 | QUpdateLaterEvent(const QRegion& paintRegion); | |
26535 | ~QUpdateLaterEvent(); | |
26536 | inline const QRegion ®ion() const { return m_region; } | |
26537 | protected: | |
26538 | QRegion m_region; | |
26539 | }; | |
26540 | class __attribute__((visibility("default"))) QMoveEvent : public QEvent | |
26541 | { | |
26542 | public: | |
26543 | QMoveEvent(const QPoint &pos, const QPoint &oldPos); | |
26544 | ~QMoveEvent(); | |
26545 | inline const QPoint &pos() const { return p; } | |
26546 | inline const QPoint &oldPos() const { return oldp;} | |
26547 | protected: | |
26548 | QPoint p, oldp; | |
26549 | friend class QApplication; | |
26550 | friend class QCoreApplication; | |
26551 | }; | |
26552 | class __attribute__((visibility("default"))) QResizeEvent : public QEvent | |
26553 | { | |
26554 | public: | |
26555 | QResizeEvent(const QSize &size, const QSize &oldSize); | |
26556 | ~QResizeEvent(); | |
26557 | inline const QSize &size() const { return s; } | |
26558 | inline const QSize &oldSize()const { return olds;} | |
26559 | protected: | |
26560 | QSize s, olds; | |
26561 | friend class QApplication; | |
26562 | friend class QCoreApplication; | |
26563 | }; | |
26564 | class __attribute__((visibility("default"))) QCloseEvent : public QEvent | |
26565 | { | |
26566 | public: | |
26567 | QCloseEvent(); | |
26568 | ~QCloseEvent(); | |
26569 | }; | |
26570 | class __attribute__((visibility("default"))) QIconDragEvent : public QEvent | |
26571 | { | |
26572 | public: | |
26573 | QIconDragEvent(); | |
26574 | ~QIconDragEvent(); | |
26575 | }; | |
26576 | class __attribute__((visibility("default"))) QShowEvent : public QEvent | |
26577 | { | |
26578 | public: | |
26579 | QShowEvent(); | |
26580 | ~QShowEvent(); | |
26581 | }; | |
26582 | class __attribute__((visibility("default"))) QHideEvent : public QEvent | |
26583 | { | |
26584 | public: | |
26585 | QHideEvent(); | |
26586 | ~QHideEvent(); | |
26587 | }; | |
26588 | class __attribute__((visibility("default"))) QContextMenuEvent : public QInputEvent | |
26589 | { | |
26590 | public: | |
26591 | enum Reason { Mouse, Keyboard, Other }; | |
26592 | QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos, | |
26593 | Qt::KeyboardModifiers modifiers); | |
26594 | QContextMenuEvent(Reason reason, const QPoint &pos, const QPoint &globalPos); | |
26595 | QContextMenuEvent(Reason reason, const QPoint &pos); | |
26596 | ~QContextMenuEvent(); | |
26597 | inline int x() const { return p.x(); } | |
26598 | inline int y() const { return p.y(); } | |
26599 | inline int globalX() const { return gp.x(); } | |
26600 | inline int globalY() const { return gp.y(); } | |
26601 | inline const QPoint& pos() const { return p; } | |
26602 | inline const QPoint& globalPos() const { return gp; } | |
26603 | inline Reason reason() const { return Reason(reas); } | |
26604 | protected: | |
26605 | QPoint p; | |
26606 | QPoint gp; | |
26607 | uint reas : 8; | |
26608 | }; | |
26609 | class __attribute__((visibility("default"))) QInputMethodEvent : public QEvent | |
26610 | { | |
26611 | public: | |
26612 | enum AttributeType { | |
26613 | TextFormat, | |
26614 | Cursor, | |
26615 | Language, | |
26616 | Ruby | |
26617 | }; | |
26618 | class Attribute { | |
26619 | public: | |
26620 | Attribute(AttributeType t, int s, int l, QVariant val) : type(t), start(s), length(l), value(val) {} | |
26621 | AttributeType type; | |
26622 | int start; | |
26623 | int length; | |
26624 | QVariant value; | |
26625 | }; | |
26626 | QInputMethodEvent(); | |
26627 | QInputMethodEvent(const QString &preeditText, const QList<Attribute> &attributes); | |
26628 | void setCommitString(const QString &commitString, int replaceFrom = 0, int replaceLength = 0); | |
26629 | inline const QList<Attribute> &attributes() const { return attrs; } | |
26630 | inline const QString &preeditString() const { return preedit; } | |
26631 | inline const QString &commitString() const { return commit; } | |
26632 | inline int replacementStart() const { return replace_from; } | |
26633 | inline int replacementLength() const { return replace_length; } | |
26634 | QInputMethodEvent(const QInputMethodEvent &other); | |
26635 | private: | |
26636 | QString preedit; | |
26637 | QList<Attribute> attrs; | |
26638 | QString commit; | |
26639 | int replace_from; | |
26640 | int replace_length; | |
26641 | }; | |
26642 | class QMimeData; | |
26643 | class __attribute__((visibility("default"))) QDropEvent : public QEvent | |
26644 | , public QMimeSource | |
26645 | { | |
26646 | public: | |
26647 | QDropEvent(const QPoint& pos, Qt::DropActions actions, const QMimeData *data, | |
26648 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = Drop); | |
26649 | ~QDropEvent(); | |
26650 | inline const QPoint &pos() const { return p; } | |
26651 | inline Qt::MouseButtons mouseButtons() const { return mouseState; } | |
26652 | inline Qt::KeyboardModifiers keyboardModifiers() const { return modState; } | |
26653 | inline Qt::DropActions possibleActions() const { return act; } | |
26654 | inline Qt::DropAction proposedAction() const { return default_action; } | |
26655 | inline void acceptProposedAction() { drop_action = default_action; accept(); } | |
26656 | inline Qt::DropAction dropAction() const { return drop_action; } | |
26657 | void setDropAction(Qt::DropAction action); | |
26658 | QWidget* source() const; | |
26659 | inline const QMimeData *mimeData() const { return mdata; } | |
26660 | const char* format(int n = 0) const; | |
26661 | QByteArray encodedData(const char*) const; | |
26662 | bool provides(const char*) const; | |
26663 | protected: | |
26664 | friend class QApplication; | |
26665 | QPoint p; | |
26666 | Qt::MouseButtons mouseState; | |
26667 | Qt::KeyboardModifiers modState; | |
26668 | Qt::DropActions act; | |
26669 | Qt::DropAction drop_action; | |
26670 | Qt::DropAction default_action; | |
26671 | const QMimeData *mdata; | |
26672 | mutable QList<QByteArray> fmts; | |
26673 | }; | |
26674 | class __attribute__((visibility("default"))) QDragMoveEvent : public QDropEvent | |
26675 | { | |
26676 | public: | |
26677 | QDragMoveEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, | |
26678 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers, Type type = DragMove); | |
26679 | ~QDragMoveEvent(); | |
26680 | inline QRect answerRect() const { return rect; } | |
26681 | inline void accept() { QDropEvent::accept(); } | |
26682 | inline void ignore() { QDropEvent::ignore(); } | |
26683 | inline void accept(const QRect & r) { accept(); rect = r; } | |
26684 | inline void ignore(const QRect & r) { ignore(); rect = r; } | |
26685 | protected: | |
26686 | friend class QApplication; | |
26687 | QRect rect; | |
26688 | }; | |
26689 | class __attribute__((visibility("default"))) QDragEnterEvent : public QDragMoveEvent | |
26690 | { | |
26691 | public: | |
26692 | QDragEnterEvent(const QPoint &pos, Qt::DropActions actions, const QMimeData *data, | |
26693 | Qt::MouseButtons buttons, Qt::KeyboardModifiers modifiers); | |
26694 | ~QDragEnterEvent(); | |
26695 | }; | |
26696 | class __attribute__((visibility("default"))) QDragResponseEvent : public QEvent | |
26697 | { | |
26698 | public: | |
26699 | QDragResponseEvent(bool accepted); | |
26700 | ~QDragResponseEvent(); | |
26701 | inline bool dragAccepted() const { return a; } | |
26702 | protected: | |
26703 | bool a; | |
26704 | }; | |
26705 | class __attribute__((visibility("default"))) QDragLeaveEvent : public QEvent | |
26706 | { | |
26707 | public: | |
26708 | QDragLeaveEvent(); | |
26709 | ~QDragLeaveEvent(); | |
26710 | }; | |
26711 | class __attribute__((visibility("default"))) QHelpEvent : public QEvent | |
26712 | { | |
26713 | public: | |
26714 | QHelpEvent(Type type, const QPoint &pos, const QPoint &globalPos); | |
26715 | ~QHelpEvent(); | |
26716 | inline int x() const { return p.x(); } | |
26717 | inline int y() const { return p.y(); } | |
26718 | inline int globalX() const { return gp.x(); } | |
26719 | inline int globalY() const { return gp.y(); } | |
26720 | inline const QPoint& pos() const { return p; } | |
26721 | inline const QPoint& globalPos() const { return gp; } | |
26722 | private: | |
26723 | QPoint p; | |
26724 | QPoint gp; | |
26725 | }; | |
26726 | class __attribute__((visibility("default"))) QStatusTipEvent : public QEvent | |
26727 | { | |
26728 | public: | |
26729 | QStatusTipEvent(const QString &tip); | |
26730 | ~QStatusTipEvent(); | |
26731 | inline QString tip() const { return s; } | |
26732 | private: | |
26733 | QString s; | |
26734 | }; | |
26735 | class __attribute__((visibility("default"))) QWhatsThisClickedEvent : public QEvent | |
26736 | { | |
26737 | public: | |
26738 | QWhatsThisClickedEvent(const QString &href); | |
26739 | ~QWhatsThisClickedEvent(); | |
26740 | inline QString href() const { return s; } | |
26741 | private: | |
26742 | QString s; | |
26743 | }; | |
26744 | class __attribute__((visibility("default"))) QActionEvent : public QEvent | |
26745 | { | |
26746 | QAction *act, *bef; | |
26747 | public: | |
26748 | QActionEvent(int type, QAction *action, QAction *before = 0); | |
26749 | ~QActionEvent(); | |
26750 | inline QAction *action() const { return act; } | |
26751 | inline QAction *before() const { return bef; } | |
26752 | }; | |
26753 | class __attribute__((visibility("default"))) QFileOpenEvent : public QEvent | |
26754 | { | |
26755 | public: | |
26756 | QFileOpenEvent(const QString &file); | |
26757 | ~QFileOpenEvent(); | |
26758 | inline QString file() const { return f; } | |
26759 | private: | |
26760 | QString f; | |
26761 | }; | |
26762 | class __attribute__((visibility("default"))) QToolBarChangeEvent : public QEvent | |
26763 | { | |
26764 | public: | |
26765 | QToolBarChangeEvent(bool t); | |
26766 | ~QToolBarChangeEvent(); | |
26767 | inline bool toggle() const { return tog; } | |
26768 | private: | |
26769 | uint tog : 1; | |
26770 | }; | |
26771 | class __attribute__((visibility("default"))) QShortcutEvent : public QEvent | |
26772 | { | |
26773 | public: | |
26774 | QShortcutEvent(const QKeySequence &key, int id, bool ambiguous = false); | |
26775 | ~QShortcutEvent(); | |
26776 | inline const QKeySequence &key() { return sequence; } | |
26777 | inline const QKeySequence &key() const { return sequence; } | |
26778 | inline int shortcutId() { return sid; } | |
26779 | inline int shortcutId() const { return sid; } | |
26780 | inline bool isAmbiguous() { return ambig; } | |
26781 | inline bool isAmbiguous() const { return ambig; } | |
26782 | protected: | |
26783 | QKeySequence sequence; | |
26784 | bool ambig; | |
26785 | int sid; | |
26786 | }; | |
26787 | class __attribute__((visibility("default"))) QClipboardEvent : public QEvent | |
26788 | { | |
26789 | public: | |
26790 | QClipboardEvent(QEventPrivate *data); | |
26791 | ~QClipboardEvent(); | |
26792 | QEventPrivate *data() { return d; }; | |
26793 | }; | |
26794 | class __attribute__((visibility("default"))) QWindowStateChangeEvent: public QEvent | |
26795 | { | |
26796 | public: | |
26797 | QWindowStateChangeEvent(Qt::WindowStates aOldState); | |
26798 | QWindowStateChangeEvent(Qt::WindowStates aOldState, bool isOverride); | |
26799 | ~QWindowStateChangeEvent(); | |
26800 | inline Qt::WindowStates oldState() const { return ostate; } | |
26801 | bool isOverride() const; | |
26802 | private: | |
26803 | Qt::WindowStates ostate; | |
26804 | }; | |
26805 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QEvent *); | |
26806 | inline bool operator==(QKeyEvent *e, QKeySequence::StandardKey key){return (e ? e->matches(key) : false);} | |
26807 | inline bool operator==(QKeySequence::StandardKey key, QKeyEvent *e){return (e ? e->matches(key) : false);} | |
26808 | typedef struct FT_FaceRec_* FT_Face; | |
26809 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
26810 | class QFontPrivate; | |
26811 | class QStringList; | |
26812 | class QVariant; | |
26813 | class Q3TextFormatCollection; | |
26814 | class __attribute__((visibility("default"))) QFont | |
26815 | { | |
26816 | public: static const QMetaObject staticMetaObject; private: | |
26817 | public: | |
26818 | enum StyleHint { | |
26819 | Helvetica, SansSerif = Helvetica, | |
26820 | Times, Serif = Times, | |
26821 | Courier, TypeWriter = Courier, | |
26822 | OldEnglish, Decorative = OldEnglish, | |
26823 | System, | |
26824 | AnyStyle | |
26825 | }; | |
26826 | enum StyleStrategy { | |
26827 | PreferDefault = 0x0001, | |
26828 | PreferBitmap = 0x0002, | |
26829 | PreferDevice = 0x0004, | |
26830 | PreferOutline = 0x0008, | |
26831 | ForceOutline = 0x0010, | |
26832 | PreferMatch = 0x0020, | |
26833 | PreferQuality = 0x0040, | |
26834 | PreferAntialias = 0x0080, | |
26835 | NoAntialias = 0x0100, | |
26836 | OpenGLCompatible = 0x0200, | |
26837 | NoFontMerging = 0x8000 | |
26838 | }; | |
26839 | enum Weight { | |
26840 | Light = 25, | |
26841 | Normal = 50, | |
26842 | DemiBold = 63, | |
26843 | Bold = 75, | |
26844 | Black = 87 | |
26845 | }; | |
26846 | enum Style { | |
26847 | StyleNormal, | |
26848 | StyleItalic, | |
26849 | StyleOblique | |
26850 | }; | |
26851 | enum Stretch { | |
26852 | UltraCondensed = 50, | |
26853 | ExtraCondensed = 62, | |
26854 | Condensed = 75, | |
26855 | SemiCondensed = 87, | |
26856 | Unstretched = 100, | |
26857 | SemiExpanded = 112, | |
26858 | Expanded = 125, | |
26859 | ExtraExpanded = 150, | |
26860 | UltraExpanded = 200 | |
26861 | }; | |
26862 | enum Capitalization { | |
26863 | MixedCase, | |
26864 | AllUppercase, | |
26865 | AllLowercase, | |
26866 | SmallCaps, | |
26867 | Capitalize | |
26868 | }; | |
26869 | enum SpacingType { | |
26870 | PercentageSpacing, | |
26871 | AbsoluteSpacing | |
26872 | }; | |
26873 | enum ResolveProperties { | |
26874 | FamilyResolved = 0x0001, | |
26875 | SizeResolved = 0x0002, | |
26876 | StyleHintResolved = 0x0004, | |
26877 | StyleStrategyResolved = 0x0008, | |
26878 | WeightResolved = 0x0010, | |
26879 | StyleResolved = 0x0020, | |
26880 | UnderlineResolved = 0x0040, | |
26881 | OverlineResolved = 0x0080, | |
26882 | StrikeOutResolved = 0x0100, | |
26883 | FixedPitchResolved = 0x0200, | |
26884 | StretchResolved = 0x0400, | |
26885 | KerningResolved = 0x0800, | |
26886 | CapitalizationResolved = 0x1000, | |
26887 | LetterSpacingResolved = 0x2000, | |
26888 | WordSpacingResolved = 0x4000, | |
26889 | AllPropertiesResolved = 0x7fff | |
26890 | }; | |
26891 | QFont(); | |
26892 | QFont(const QString &family, int pointSize = -1, int weight = -1, bool italic = false); | |
26893 | QFont(const QFont &, QPaintDevice *pd); | |
26894 | QFont(const QFont &); | |
26895 | ~QFont(); | |
26896 | QString family() const; | |
26897 | void setFamily(const QString &); | |
26898 | int pointSize() const; | |
26899 | void setPointSize(int); | |
26900 | qreal pointSizeF() const; | |
26901 | void setPointSizeF(qreal); | |
26902 | int pixelSize() const; | |
26903 | void setPixelSize(int); | |
26904 | int weight() const; | |
26905 | void setWeight(int); | |
26906 | inline bool bold() const; | |
26907 | inline void setBold(bool); | |
26908 | void setStyle(Style style); | |
26909 | Style style() const; | |
26910 | inline bool italic() const; | |
26911 | inline void setItalic(bool b); | |
26912 | bool underline() const; | |
26913 | void setUnderline(bool); | |
26914 | bool overline() const; | |
26915 | void setOverline(bool); | |
26916 | bool strikeOut() const; | |
26917 | void setStrikeOut(bool); | |
26918 | bool fixedPitch() const; | |
26919 | void setFixedPitch(bool); | |
26920 | bool kerning() const; | |
26921 | void setKerning(bool); | |
26922 | StyleHint styleHint() const; | |
26923 | StyleStrategy styleStrategy() const; | |
26924 | void setStyleHint(StyleHint, StyleStrategy = PreferDefault); | |
26925 | void setStyleStrategy(StyleStrategy s); | |
26926 | int stretch() const; | |
26927 | void setStretch(int); | |
26928 | qreal letterSpacing() const; | |
26929 | SpacingType letterSpacingType() const; | |
26930 | void setLetterSpacing(SpacingType type, qreal spacing); | |
26931 | qreal wordSpacing() const; | |
26932 | void setWordSpacing(qreal spacing); | |
26933 | void setCapitalization(Capitalization); | |
26934 | Capitalization capitalization() const; | |
26935 | bool rawMode() const; | |
26936 | void setRawMode(bool); | |
26937 | bool exactMatch() const; | |
26938 | QFont &operator=(const QFont &); | |
26939 | bool operator==(const QFont &) const; | |
26940 | bool operator!=(const QFont &) const; | |
26941 | bool operator<(const QFont &) const; | |
26942 | operator QVariant() const; | |
26943 | bool isCopyOf(const QFont &) const; | |
26944 | Qt::HANDLE handle() const; | |
26945 | FT_Face freetypeFace() const; | |
26946 | void setRawName(const QString &); | |
26947 | QString rawName() const; | |
26948 | QString key() const; | |
26949 | QString toString() const; | |
26950 | bool fromString(const QString &); | |
26951 | static QString substitute(const QString &); | |
26952 | static QStringList substitutes(const QString &); | |
26953 | static QStringList substitutions(); | |
26954 | static void insertSubstitution(const QString&, const QString &); | |
26955 | static void insertSubstitutions(const QString&, const QStringList &); | |
26956 | static void removeSubstitution(const QString &); | |
26957 | static void initialize(); | |
26958 | static void cleanup(); | |
26959 | QString defaultFamily() const; | |
26960 | QString lastResortFamily() const; | |
26961 | QString lastResortFont() const; | |
26962 | QFont resolve(const QFont &) const; | |
26963 | inline uint resolve() const { return resolve_mask; } | |
26964 | inline void resolve(uint mask) { resolve_mask = mask; } | |
26965 | private: | |
26966 | QFont(QFontPrivate *); | |
26967 | void detach(); | |
26968 | friend class QFontPrivate; | |
26969 | friend class QFontDialogPrivate; | |
26970 | friend class QFontMetrics; | |
26971 | friend class QFontMetricsF; | |
26972 | friend class QFontInfo; | |
26973 | friend class QPainter; | |
26974 | friend class QPSPrintEngineFont; | |
26975 | friend class QApplication; | |
26976 | friend class QWidget; | |
26977 | friend class QWidgetPrivate; | |
26978 | friend class Q3TextFormatCollection; | |
26979 | friend class QTextLayout; | |
26980 | friend class QTextEngine; | |
26981 | friend class QStackTextEngine; | |
26982 | friend class QTextLine; | |
26983 | friend struct QScriptLine; | |
26984 | friend class QGLContext; | |
26985 | friend class QWin32PaintEngine; | |
26986 | friend class QAlphaPaintEngine; | |
26987 | friend class QPainterPath; | |
26988 | friend class QTextItemInt; | |
26989 | friend class QPicturePaintEngine; | |
26990 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QFont &); | |
26991 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QFont &); | |
26992 | QFontPrivate *d; | |
26993 | uint resolve_mask; | |
26994 | }; | |
26995 | inline bool QFont::bold() const | |
26996 | { return weight() > Normal; } | |
26997 | inline void QFont::setBold(bool enable) | |
26998 | { setWeight(enable ? Bold : Normal); } | |
26999 | inline bool QFont::italic() const | |
27000 | { | |
27001 | return (style() != StyleNormal); | |
27002 | } | |
27003 | inline void QFont::setItalic(bool b) { | |
27004 | setStyle(b ? StyleItalic : StyleNormal); | |
27005 | } | |
27006 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QFont &); | |
27007 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QFont &); | |
27008 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QFont &); | |
27009 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
27010 | template <class T> class QSharedDataPointer; | |
27011 | class __attribute__((visibility("default"))) QSharedData | |
27012 | { | |
27013 | public: | |
27014 | mutable QAtomicInt ref; | |
27015 | inline QSharedData() : ref(0) { } | |
27016 | inline QSharedData(const QSharedData &) : ref(0) { } | |
27017 | private: | |
27018 | QSharedData &operator=(const QSharedData &); | |
27019 | }; | |
27020 | template <class T> class QSharedDataPointer | |
27021 | { | |
27022 | public: | |
27023 | inline void detach() { if (d && d->ref != 1) detach_helper(); } | |
27024 | inline T &operator*() { detach(); return *d; } | |
27025 | inline const T &operator*() const { return *d; } | |
27026 | inline T *operator->() { detach(); return d; } | |
27027 | inline const T *operator->() const { return d; } | |
27028 | inline operator T *() { detach(); return d; } | |
27029 | inline operator const T *() const { return d; } | |
27030 | inline T *data() { detach(); return d; } | |
27031 | inline const T *data() const { return d; } | |
27032 | inline const T *constData() const { return d; } | |
27033 | inline bool operator==(const QSharedDataPointer<T> &other) const { return d == other.d; } | |
27034 | inline bool operator!=(const QSharedDataPointer<T> &other) const { return d != other.d; } | |
27035 | inline QSharedDataPointer() { d = 0; } | |
27036 | inline ~QSharedDataPointer() { if (d && !d->ref.deref()) delete d; } | |
27037 | explicit QSharedDataPointer(T *data); | |
27038 | inline QSharedDataPointer(const QSharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); } | |
27039 | inline QSharedDataPointer<T> & operator=(const QSharedDataPointer<T> &o) { | |
27040 | if (o.d != d) { | |
27041 | if (o.d) | |
27042 | o.d->ref.ref(); | |
27043 | if (d && !d->ref.deref()) | |
27044 | delete d; | |
27045 | d = o.d; | |
27046 | } | |
27047 | return *this; | |
27048 | } | |
27049 | inline QSharedDataPointer &operator=(T *o) { | |
27050 | if (o != d) { | |
27051 | if (o) | |
27052 | o->ref.ref(); | |
27053 | if (d && !d->ref.deref()) | |
27054 | delete d; | |
27055 | d = o; | |
27056 | } | |
27057 | return *this; | |
27058 | } | |
27059 | inline bool operator!() const { return !d; } | |
27060 | protected: | |
27061 | T *clone(); | |
27062 | private: | |
27063 | void detach_helper(); | |
27064 | T *d; | |
27065 | }; | |
27066 | template <class T> class QExplicitlySharedDataPointer | |
27067 | { | |
27068 | public: | |
27069 | typedef T Type; | |
27070 | inline T &operator*() const { return *d; } | |
27071 | inline T *operator->() { return d; } | |
27072 | inline T *operator->() const { return d; } | |
27073 | inline T *data() const { return d; } | |
27074 | inline const T *constData() const { return d; } | |
27075 | inline void detach() { if (d && d->ref != 1) detach_helper(); } | |
27076 | inline void reset() | |
27077 | { | |
27078 | if(d && !d->ref.deref()) | |
27079 | delete d; | |
27080 | d = 0; | |
27081 | } | |
27082 | inline operator bool () const { return d != 0; } | |
27083 | inline bool operator==(const QExplicitlySharedDataPointer<T> &other) const { return d == other.d; } | |
27084 | inline bool operator!=(const QExplicitlySharedDataPointer<T> &other) const { return d != other.d; } | |
27085 | inline bool operator==(const T *ptr) const { return d == ptr; } | |
27086 | inline bool operator!=(const T *ptr) const { return d != ptr; } | |
27087 | inline QExplicitlySharedDataPointer() { d = 0; } | |
27088 | inline ~QExplicitlySharedDataPointer() { if (d && !d->ref.deref()) delete d; } | |
27089 | explicit QExplicitlySharedDataPointer(T *data); | |
27090 | inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<T> &o) : d(o.d) { if (d) d->ref.ref(); } | |
27091 | template<class X> | |
27092 | inline QExplicitlySharedDataPointer(const QExplicitlySharedDataPointer<X> &o) : d(static_cast<T *>(o.data())) | |
27093 | { | |
27094 | if(d) | |
27095 | d->ref.ref(); | |
27096 | } | |
27097 | inline QExplicitlySharedDataPointer<T> & operator=(const QExplicitlySharedDataPointer<T> &o) { | |
27098 | if (o.d != d) { | |
27099 | if (o.d) | |
27100 | o.d->ref.ref(); | |
27101 | if (d && !d->ref.deref()) | |
27102 | delete d; | |
27103 | d = o.d; | |
27104 | } | |
27105 | return *this; | |
27106 | } | |
27107 | inline QExplicitlySharedDataPointer &operator=(T *o) { | |
27108 | if (o != d) { | |
27109 | if (o) | |
27110 | o->ref.ref(); | |
27111 | if (d && !d->ref.deref()) | |
27112 | delete d; | |
27113 | d = o; | |
27114 | } | |
27115 | return *this; | |
27116 | } | |
27117 | inline bool operator!() const { return !d; } | |
27118 | protected: | |
27119 | T *clone(); | |
27120 | private: | |
27121 | void detach_helper(); | |
27122 | T *d; | |
27123 | }; | |
27124 | template <class T> | |
27125 | inline QSharedDataPointer<T>::QSharedDataPointer(T *adata) : d(adata) | |
27126 | { if (d) d->ref.ref(); } | |
27127 | template <class T> | |
27128 | inline T *QSharedDataPointer<T>::clone() | |
27129 | { | |
27130 | return new T(*d); | |
27131 | } | |
27132 | template <class T> | |
27133 | void QSharedDataPointer<T>::detach_helper() | |
27134 | { | |
27135 | T *x = clone(); | |
27136 | x->ref.ref(); | |
27137 | if (!d->ref.deref()) | |
27138 | delete d; | |
27139 | d = x; | |
27140 | } | |
27141 | template <class T> | |
27142 | inline T *QExplicitlySharedDataPointer<T>::clone() | |
27143 | { | |
27144 | return new T(*d); | |
27145 | } | |
27146 | template <class T> | |
27147 | void QExplicitlySharedDataPointer<T>::detach_helper() | |
27148 | { | |
27149 | T *x = clone(); | |
27150 | x->ref.ref(); | |
27151 | if (!d->ref.deref()) | |
27152 | delete d; | |
27153 | d = x; | |
27154 | } | |
27155 | template <class T> | |
27156 | inline QExplicitlySharedDataPointer<T>::QExplicitlySharedDataPointer(T *adata) : d(adata) | |
27157 | { if (d) d->ref.ref(); } | |
27158 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
27159 | class QMatrix; | |
27160 | class QTransform; | |
27161 | class QRect; | |
27162 | class QVariant; | |
27163 | class __attribute__((visibility("default"))) QPolygon : public QVector<QPoint> | |
27164 | { | |
27165 | public: | |
27166 | inline QPolygon() {} | |
27167 | inline ~QPolygon() {} | |
27168 | inline QPolygon(int size); | |
27169 | inline QPolygon(const QPolygon &a) : QVector<QPoint>(a) {} | |
27170 | inline QPolygon(const QVector<QPoint> &v) : QVector<QPoint>(v) {} | |
27171 | QPolygon(const QRect &r, bool closed=false); | |
27172 | QPolygon(int nPoints, const int *points); | |
27173 | operator QVariant() const; | |
27174 | void translate(int dx, int dy); | |
27175 | void translate(const QPoint &offset); | |
27176 | QRect boundingRect() const; | |
27177 | void point(int i, int *x, int *y) const; | |
27178 | QPoint point(int i) const; | |
27179 | void setPoint(int index, int x, int y); | |
27180 | void setPoint(int index, const QPoint &p); | |
27181 | void setPoints(int nPoints, const int *points); | |
27182 | void setPoints(int nPoints, int firstx, int firsty, ...); | |
27183 | void putPoints(int index, int nPoints, const int *points); | |
27184 | void putPoints(int index, int nPoints, int firstx, int firsty, ...); | |
27185 | void putPoints(int index, int nPoints, const QPolygon & from, int fromIndex=0); | |
27186 | bool containsPoint(const QPoint &pt, Qt::FillRule fillRule) const; | |
27187 | QPolygon united(const QPolygon &r) const; | |
27188 | QPolygon intersected(const QPolygon &r) const; | |
27189 | QPolygon subtracted(const QPolygon &r) const; | |
27190 | }; | |
27191 | inline QPolygon::QPolygon(int asize) : QVector<QPoint>(asize) {} | |
27192 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QPolygon &); | |
27193 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &stream, const QPolygon &polygon); | |
27194 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &stream, QPolygon &polygon); | |
27195 | inline void QPolygon::setPoint(int index, const QPoint &pt) | |
27196 | { (*this)[index] = pt; } | |
27197 | inline void QPolygon::setPoint(int index, int x, int y) | |
27198 | { (*this)[index] = QPoint(x, y); } | |
27199 | inline QPoint QPolygon::point(int index) const | |
27200 | { return at(index); } | |
27201 | inline void QPolygon::translate(const QPoint &offset) | |
27202 | { translate(offset.x(), offset.y()); } | |
27203 | class QRectF; | |
27204 | class __attribute__((visibility("default"))) QPolygonF : public QVector<QPointF> | |
27205 | { | |
27206 | public: | |
27207 | inline QPolygonF() {} | |
27208 | inline ~QPolygonF() {} | |
27209 | inline QPolygonF(int size); | |
27210 | inline QPolygonF(const QPolygonF &a) : QVector<QPointF>(a) {} | |
27211 | inline QPolygonF(const QVector<QPointF> &v) : QVector<QPointF>(v) {} | |
27212 | QPolygonF(const QRectF &r); | |
27213 | QPolygonF(const QPolygon &a); | |
27214 | inline void translate(qreal dx, qreal dy); | |
27215 | void translate(const QPointF &offset); | |
27216 | QPolygon toPolygon() const; | |
27217 | bool isClosed() const { return !isEmpty() && first() == last(); } | |
27218 | QRectF boundingRect() const; | |
27219 | bool containsPoint(const QPointF &pt, Qt::FillRule fillRule) const; | |
27220 | QPolygonF united(const QPolygonF &r) const; | |
27221 | QPolygonF intersected(const QPolygonF &r) const; | |
27222 | QPolygonF subtracted(const QPolygonF &r) const; | |
27223 | }; | |
27224 | inline QPolygonF::QPolygonF(int asize) : QVector<QPointF>(asize) {} | |
27225 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QPolygonF &); | |
27226 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &stream, const QPolygonF &array); | |
27227 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &stream, QPolygonF &array); | |
27228 | inline void QPolygonF::translate(qreal dx, qreal dy) | |
27229 | { translate(QPointF(dx, dy)); } | |
27230 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
27231 | class __attribute__((visibility("default"))) QLine | |
27232 | { | |
27233 | public: | |
27234 | inline QLine(); | |
27235 | inline QLine(const QPoint &pt1, const QPoint &pt2); | |
27236 | inline QLine(int x1, int y1, int x2, int y2); | |
27237 | inline bool isNull() const; | |
27238 | inline QPoint p1() const; | |
27239 | inline QPoint p2() const; | |
27240 | inline int x1() const; | |
27241 | inline int y1() const; | |
27242 | inline int x2() const; | |
27243 | inline int y2() const; | |
27244 | inline int dx() const; | |
27245 | inline int dy() const; | |
27246 | inline void translate(const QPoint &p); | |
27247 | inline void translate(int dx, int dy); | |
27248 | inline QLine translated(const QPoint &p) const; | |
27249 | inline QLine translated(int dx, int dy) const; | |
27250 | inline void setP1(const QPoint &p1); | |
27251 | inline void setP2(const QPoint &p2); | |
27252 | inline void setPoints(const QPoint &p1, const QPoint &p2); | |
27253 | inline void setLine(int x1, int y1, int x2, int y2); | |
27254 | inline bool operator==(const QLine &d) const; | |
27255 | inline bool operator!=(const QLine &d) const { return !(*this == d); } | |
27256 | private: | |
27257 | QPoint pt1, pt2; | |
27258 | }; | |
27259 | template <> class QTypeInfo<QLine> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLine)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLine"; } }; | |
27260 | inline QLine::QLine() { } | |
27261 | inline QLine::QLine(const QPoint &pt1_, const QPoint &pt2_) : pt1(pt1_), pt2(pt2_) { } | |
27262 | inline QLine::QLine(int x1pos, int y1pos, int x2pos, int y2pos) : pt1(QPoint(x1pos, y1pos)), pt2(QPoint(x2pos, y2pos)) { } | |
27263 | inline bool QLine::isNull() const | |
27264 | { | |
27265 | return pt1 == pt2; | |
27266 | } | |
27267 | inline int QLine::x1() const | |
27268 | { | |
27269 | return pt1.x(); | |
27270 | } | |
27271 | inline int QLine::y1() const | |
27272 | { | |
27273 | return pt1.y(); | |
27274 | } | |
27275 | inline int QLine::x2() const | |
27276 | { | |
27277 | return pt2.x(); | |
27278 | } | |
27279 | inline int QLine::y2() const | |
27280 | { | |
27281 | return pt2.y(); | |
27282 | } | |
27283 | inline QPoint QLine::p1() const | |
27284 | { | |
27285 | return pt1; | |
27286 | } | |
27287 | inline QPoint QLine::p2() const | |
27288 | { | |
27289 | return pt2; | |
27290 | } | |
27291 | inline int QLine::dx() const | |
27292 | { | |
27293 | return pt2.x() - pt1.x(); | |
27294 | } | |
27295 | inline int QLine::dy() const | |
27296 | { | |
27297 | return pt2.y() - pt1.y(); | |
27298 | } | |
27299 | inline void QLine::translate(const QPoint &point) | |
27300 | { | |
27301 | pt1 += point; | |
27302 | pt2 += point; | |
27303 | } | |
27304 | inline void QLine::translate(int adx, int ady) | |
27305 | { | |
27306 | this->translate(QPoint(adx, ady)); | |
27307 | } | |
27308 | inline QLine QLine::translated(const QPoint &p) const | |
27309 | { | |
27310 | return QLine(pt1 + p, pt2 + p); | |
27311 | } | |
27312 | inline QLine QLine::translated(int adx, int ady) const | |
27313 | { | |
27314 | return translated(QPoint(adx, ady)); | |
27315 | } | |
27316 | inline void QLine::setP1(const QPoint &aP1) | |
27317 | { | |
27318 | pt1 = aP1; | |
27319 | } | |
27320 | inline void QLine::setP2(const QPoint &aP2) | |
27321 | { | |
27322 | pt2 = aP2; | |
27323 | } | |
27324 | inline void QLine::setPoints(const QPoint &aP1, const QPoint &aP2) | |
27325 | { | |
27326 | pt1 = aP1; | |
27327 | pt2 = aP2; | |
27328 | } | |
27329 | inline void QLine::setLine(int aX1, int aY1, int aX2, int aY2) | |
27330 | { | |
27331 | pt1 = QPoint(aX1, aY1); | |
27332 | pt2 = QPoint(aX2, aY2); | |
27333 | } | |
27334 | inline bool QLine::operator==(const QLine &d) const | |
27335 | { | |
27336 | return pt1 == d.pt1 && pt2 == d.pt2; | |
27337 | } | |
27338 | __attribute__((visibility("default"))) QDebug operator<<(QDebug d, const QLine &p); | |
27339 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QLine &); | |
27340 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QLine &); | |
27341 | class __attribute__((visibility("default"))) QLineF { | |
27342 | public: | |
27343 | enum IntersectType { NoIntersection, BoundedIntersection, UnboundedIntersection }; | |
27344 | inline QLineF(); | |
27345 | inline QLineF(const QPointF &pt1, const QPointF &pt2); | |
27346 | inline QLineF(qreal x1, qreal y1, qreal x2, qreal y2); | |
27347 | inline QLineF(const QLine &line) : pt1(line.p1()), pt2(line.p2()) { } | |
27348 | static QLineF fromPolar(qreal length, qreal angle); | |
27349 | bool isNull() const; | |
27350 | inline QPointF p1() const; | |
27351 | inline QPointF p2() const; | |
27352 | inline qreal x1() const; | |
27353 | inline qreal y1() const; | |
27354 | inline qreal x2() const; | |
27355 | inline qreal y2() const; | |
27356 | inline qreal dx() const; | |
27357 | inline qreal dy() const; | |
27358 | qreal length() const; | |
27359 | void setLength(qreal len); | |
27360 | qreal angle() const; | |
27361 | void setAngle(qreal angle); | |
27362 | qreal angleTo(const QLineF &l) const; | |
27363 | QLineF unitVector() const; | |
27364 | QLineF normalVector() const; | |
27365 | IntersectType intersect(const QLineF &l, QPointF *intersectionPoint) const; | |
27366 | qreal angle(const QLineF &l) const; | |
27367 | QPointF pointAt(qreal t) const; | |
27368 | inline void translate(const QPointF &p); | |
27369 | inline void translate(qreal dx, qreal dy); | |
27370 | inline QLineF translated(const QPointF &p) const; | |
27371 | inline QLineF translated(qreal dx, qreal dy) const; | |
27372 | inline void setP1(const QPointF &p1); | |
27373 | inline void setP2(const QPointF &p2); | |
27374 | inline void setPoints(const QPointF &p1, const QPointF &p2); | |
27375 | inline void setLine(qreal x1, qreal y1, qreal x2, qreal y2); | |
27376 | inline bool operator==(const QLineF &d) const; | |
27377 | inline bool operator!=(const QLineF &d) const { return !(*this == d); } | |
27378 | QLine toLine() const; | |
27379 | private: | |
27380 | QPointF pt1, pt2; | |
27381 | }; | |
27382 | template <> class QTypeInfo<QLineF> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QLineF)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QLineF"; } }; | |
27383 | inline QLineF::QLineF() | |
27384 | { | |
27385 | } | |
27386 | inline QLineF::QLineF(const QPointF &apt1, const QPointF &apt2) | |
27387 | : pt1(apt1), pt2(apt2) | |
27388 | { | |
27389 | } | |
27390 | inline QLineF::QLineF(qreal x1pos, qreal y1pos, qreal x2pos, qreal y2pos) | |
27391 | : pt1(x1pos, y1pos), pt2(x2pos, y2pos) | |
27392 | { | |
27393 | } | |
27394 | inline qreal QLineF::x1() const | |
27395 | { | |
27396 | return pt1.x(); | |
27397 | } | |
27398 | inline qreal QLineF::y1() const | |
27399 | { | |
27400 | return pt1.y(); | |
27401 | } | |
27402 | inline qreal QLineF::x2() const | |
27403 | { | |
27404 | return pt2.x(); | |
27405 | } | |
27406 | inline qreal QLineF::y2() const | |
27407 | { | |
27408 | return pt2.y(); | |
27409 | } | |
27410 | inline QPointF QLineF::p1() const | |
27411 | { | |
27412 | return pt1; | |
27413 | } | |
27414 | inline QPointF QLineF::p2() const | |
27415 | { | |
27416 | return pt2; | |
27417 | } | |
27418 | inline qreal QLineF::dx() const | |
27419 | { | |
27420 | return pt2.x() - pt1.x(); | |
27421 | } | |
27422 | inline qreal QLineF::dy() const | |
27423 | { | |
27424 | return pt2.y() - pt1.y(); | |
27425 | } | |
27426 | inline QLineF QLineF::normalVector() const | |
27427 | { | |
27428 | return QLineF(p1(), p1() + QPointF(dy(), -dx())); | |
27429 | } | |
27430 | inline void QLineF::translate(const QPointF &point) | |
27431 | { | |
27432 | pt1 += point; | |
27433 | pt2 += point; | |
27434 | } | |
27435 | inline void QLineF::translate(qreal adx, qreal ady) | |
27436 | { | |
27437 | this->translate(QPointF(adx, ady)); | |
27438 | } | |
27439 | inline QLineF QLineF::translated(const QPointF &p) const | |
27440 | { | |
27441 | return QLineF(pt1 + p, pt2 + p); | |
27442 | } | |
27443 | inline QLineF QLineF::translated(qreal adx, qreal ady) const | |
27444 | { | |
27445 | return translated(QPointF(adx, ady)); | |
27446 | } | |
27447 | inline void QLineF::setLength(qreal len) | |
27448 | { | |
27449 | if (isNull()) | |
27450 | return; | |
27451 | QLineF v = unitVector(); | |
27452 | pt2 = QPointF(pt1.x() + v.dx() * len, pt1.y() + v.dy() * len); | |
27453 | } | |
27454 | inline QPointF QLineF::pointAt(qreal t) const | |
27455 | { | |
27456 | qreal vx = pt2.x() - pt1.x(); | |
27457 | qreal vy = pt2.y() - pt1.y(); | |
27458 | return QPointF(pt1.x() + vx * t, pt1.y() + vy * t); | |
27459 | } | |
27460 | inline QLine QLineF::toLine() const | |
27461 | { | |
27462 | return QLine(pt1.toPoint(), pt2.toPoint()); | |
27463 | } | |
27464 | inline void QLineF::setP1(const QPointF &aP1) | |
27465 | { | |
27466 | pt1 = aP1; | |
27467 | } | |
27468 | inline void QLineF::setP2(const QPointF &aP2) | |
27469 | { | |
27470 | pt2 = aP2; | |
27471 | } | |
27472 | inline void QLineF::setPoints(const QPointF &aP1, const QPointF &aP2) | |
27473 | { | |
27474 | pt1 = aP1; | |
27475 | pt2 = aP2; | |
27476 | } | |
27477 | inline void QLineF::setLine(qreal aX1, qreal aY1, qreal aX2, qreal aY2) | |
27478 | { | |
27479 | pt1 = QPointF(aX1, aY1); | |
27480 | pt2 = QPointF(aX2, aY2); | |
27481 | } | |
27482 | inline bool QLineF::operator==(const QLineF &d) const | |
27483 | { | |
27484 | return pt1 == d.pt1 && pt2 == d.pt2; | |
27485 | } | |
27486 | __attribute__((visibility("default"))) QDebug operator<<(QDebug d, const QLineF &p); | |
27487 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QLineF &); | |
27488 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QLineF &); | |
27489 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
27490 | class QPainterPath; | |
27491 | class QVariant; | |
27492 | class __attribute__((visibility("default"))) QMatrix | |
27493 | { | |
27494 | public: | |
27495 | QMatrix(); | |
27496 | QMatrix(qreal m11, qreal m12, qreal m21, qreal m22, | |
27497 | qreal dx, qreal dy); | |
27498 | QMatrix(const QMatrix &matrix); | |
27499 | void setMatrix(qreal m11, qreal m12, qreal m21, qreal m22, | |
27500 | qreal dx, qreal dy); | |
27501 | qreal m11() const { return _m11; } | |
27502 | qreal m12() const { return _m12; } | |
27503 | qreal m21() const { return _m21; } | |
27504 | qreal m22() const { return _m22; } | |
27505 | qreal dx() const { return _dx; } | |
27506 | qreal dy() const { return _dy; } | |
27507 | void map(int x, int y, int *tx, int *ty) const; | |
27508 | void map(qreal x, qreal y, qreal *tx, qreal *ty) const; | |
27509 | QRect mapRect(const QRect &) const; | |
27510 | QRectF mapRect(const QRectF &) const; | |
27511 | QPoint map(const QPoint &p) const; | |
27512 | QPointF map(const QPointF&p) const; | |
27513 | QLine map(const QLine &l) const; | |
27514 | QLineF map(const QLineF &l) const; | |
27515 | QPolygonF map(const QPolygonF &a) const; | |
27516 | QPolygon map(const QPolygon &a) const; | |
27517 | QRegion map(const QRegion &r) const; | |
27518 | QPainterPath map(const QPainterPath &p) const; | |
27519 | QPolygon mapToPolygon(const QRect &r) const; | |
27520 | void reset(); | |
27521 | inline bool isIdentity() const; | |
27522 | QMatrix &translate(qreal dx, qreal dy); | |
27523 | QMatrix &scale(qreal sx, qreal sy); | |
27524 | QMatrix &shear(qreal sh, qreal sv); | |
27525 | QMatrix &rotate(qreal a); | |
27526 | bool isInvertible() const { return !qFuzzyCompare(_m11*_m22 - _m12*_m21 + 1, 1); } | |
27527 | qreal det() const { return _m11*_m22 - _m12*_m21; } | |
27528 | QMatrix inverted(bool *invertible = 0) const; | |
27529 | bool operator==(const QMatrix &) const; | |
27530 | bool operator!=(const QMatrix &) const; | |
27531 | QMatrix &operator*=(const QMatrix &); | |
27532 | QMatrix operator*(const QMatrix &o) const; | |
27533 | QMatrix &operator=(const QMatrix &); | |
27534 | operator QVariant() const; | |
27535 | private: | |
27536 | friend class QTransform; | |
27537 | qreal _m11, _m12; | |
27538 | qreal _m21, _m22; | |
27539 | qreal _dx, _dy; | |
27540 | }; | |
27541 | template <> class QTypeInfo<QMatrix> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QMatrix)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QMatrix"; } }; | |
27542 | __attribute__((visibility("default"))) inline QPoint operator*(const QPoint &p, const QMatrix &m) | |
27543 | { return m.map(p); } | |
27544 | __attribute__((visibility("default"))) inline QPointF operator*(const QPointF &p, const QMatrix &m) | |
27545 | { return m.map(p); } | |
27546 | __attribute__((visibility("default"))) inline QLineF operator*(const QLineF &l, const QMatrix &m) | |
27547 | { return m.map(l); } | |
27548 | __attribute__((visibility("default"))) inline QLine operator*(const QLine &l, const QMatrix &m) | |
27549 | { return m.map(l); } | |
27550 | __attribute__((visibility("default"))) inline QPolygon operator *(const QPolygon &a, const QMatrix &m) | |
27551 | { return m.map(a); } | |
27552 | __attribute__((visibility("default"))) inline QPolygonF operator *(const QPolygonF &a, const QMatrix &m) | |
27553 | { return m.map(a); } | |
27554 | __attribute__((visibility("default"))) inline QRegion operator *(const QRegion &r, const QMatrix &m) | |
27555 | { return m.map(r); } | |
27556 | __attribute__((visibility("default"))) QPainterPath operator *(const QPainterPath &p, const QMatrix &m); | |
27557 | inline bool QMatrix::isIdentity() const | |
27558 | { | |
27559 | return qFuzzyCompare(_m11, 1) && qFuzzyCompare(_m22, 1) && qFuzzyCompare(_m12 + 1, 1) | |
27560 | && qFuzzyCompare(_m21 + 1, 1) && qFuzzyCompare(_dx + 1, 1) && qFuzzyCompare(_dy + 1, 1); | |
27561 | } | |
27562 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QMatrix &); | |
27563 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QMatrix &); | |
27564 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QMatrix &); | |
27565 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
27566 | class QFont; | |
27567 | class QPainterPathPrivate; | |
27568 | class QPainterPathData; | |
27569 | class QPainterPathStrokerPrivate; | |
27570 | class QPolygonF; | |
27571 | class QRegion; | |
27572 | class QVectorPath; | |
27573 | class __attribute__((visibility("default"))) QPainterPath | |
27574 | { | |
27575 | public: | |
27576 | enum ElementType { | |
27577 | MoveToElement, | |
27578 | LineToElement, | |
27579 | CurveToElement, | |
27580 | CurveToDataElement | |
27581 | }; | |
27582 | class Element { | |
27583 | public: | |
27584 | qreal x; | |
27585 | qreal y; | |
27586 | ElementType type; | |
27587 | bool isMoveTo() const { return type == MoveToElement; } | |
27588 | bool isLineTo() const { return type == LineToElement; } | |
27589 | bool isCurveTo() const { return type == CurveToElement; } | |
27590 | operator QPointF () const { return QPointF(x, y); } | |
27591 | bool operator==(const Element &e) const { return qFuzzyCompare(x, e.x) | |
27592 | && qFuzzyCompare(y, e.y) && type == e.type; } | |
27593 | inline bool operator!=(const Element &e) const { return !operator==(e); } | |
27594 | }; | |
27595 | QPainterPath(); | |
27596 | explicit QPainterPath(const QPointF &startPoint); | |
27597 | QPainterPath(const QPainterPath &other); | |
27598 | QPainterPath &operator=(const QPainterPath &other); | |
27599 | ~QPainterPath(); | |
27600 | void closeSubpath(); | |
27601 | void moveTo(const QPointF &p); | |
27602 | inline void moveTo(qreal x, qreal y); | |
27603 | void lineTo(const QPointF &p); | |
27604 | inline void lineTo(qreal x, qreal y); | |
27605 | void arcMoveTo(const QRectF &rect, qreal angle); | |
27606 | inline void arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle); | |
27607 | void arcTo(const QRectF &rect, qreal startAngle, qreal arcLength); | |
27608 | inline void arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLength); | |
27609 | void cubicTo(const QPointF &ctrlPt1, const QPointF &ctrlPt2, const QPointF &endPt); | |
27610 | inline void cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y, | |
27611 | qreal endPtx, qreal endPty); | |
27612 | void quadTo(const QPointF &ctrlPt, const QPointF &endPt); | |
27613 | inline void quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty); | |
27614 | QPointF currentPosition() const; | |
27615 | void addRect(const QRectF &rect); | |
27616 | inline void addRect(qreal x, qreal y, qreal w, qreal h); | |
27617 | void addEllipse(const QRectF &rect); | |
27618 | inline void addEllipse(qreal x, qreal y, qreal w, qreal h); | |
27619 | inline void addEllipse(const QPointF ¢er, qreal rx, qreal ry); | |
27620 | void addPolygon(const QPolygonF &polygon); | |
27621 | void addText(const QPointF &point, const QFont &f, const QString &text); | |
27622 | inline void addText(qreal x, qreal y, const QFont &f, const QString &text); | |
27623 | void addPath(const QPainterPath &path); | |
27624 | void addRegion(const QRegion ®ion); | |
27625 | void addRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, | |
27626 | Qt::SizeMode mode = Qt::AbsoluteSize); | |
27627 | inline void addRoundedRect(qreal x, qreal y, qreal w, qreal h, | |
27628 | qreal xRadius, qreal yRadius, | |
27629 | Qt::SizeMode mode = Qt::AbsoluteSize); | |
27630 | void addRoundRect(const QRectF &rect, int xRnd, int yRnd); | |
27631 | inline void addRoundRect(qreal x, qreal y, qreal w, qreal h, | |
27632 | int xRnd, int yRnd); | |
27633 | inline void addRoundRect(const QRectF &rect, int roundness); | |
27634 | inline void addRoundRect(qreal x, qreal y, qreal w, qreal h, | |
27635 | int roundness); | |
27636 | void connectPath(const QPainterPath &path); | |
27637 | bool contains(const QPointF &pt) const; | |
27638 | bool contains(const QRectF &rect) const; | |
27639 | bool intersects(const QRectF &rect) const; | |
27640 | QRectF boundingRect() const; | |
27641 | QRectF controlPointRect() const; | |
27642 | Qt::FillRule fillRule() const; | |
27643 | void setFillRule(Qt::FillRule fillRule); | |
27644 | inline bool isEmpty() const; | |
27645 | QPainterPath toReversed() const; | |
27646 | QList<QPolygonF> toSubpathPolygons(const QMatrix &matrix = QMatrix()) const; | |
27647 | QList<QPolygonF> toFillPolygons(const QMatrix &matrix = QMatrix()) const; | |
27648 | QPolygonF toFillPolygon(const QMatrix &matrix = QMatrix()) const; | |
27649 | QList<QPolygonF> toSubpathPolygons(const QTransform &matrix) const; | |
27650 | QList<QPolygonF> toFillPolygons(const QTransform &matrix) const; | |
27651 | QPolygonF toFillPolygon(const QTransform &matrix) const; | |
27652 | inline int elementCount() const; | |
27653 | inline const QPainterPath::Element &elementAt(int i) const; | |
27654 | inline void setElementPositionAt(int i, qreal x, qreal y); | |
27655 | qreal length() const; | |
27656 | qreal percentAtLength(qreal t) const; | |
27657 | QPointF pointAtPercent(qreal t) const; | |
27658 | qreal angleAtPercent(qreal t) const; | |
27659 | qreal slopeAtPercent(qreal t) const; | |
27660 | bool intersects(const QPainterPath &p) const; | |
27661 | bool contains(const QPainterPath &p) const; | |
27662 | QPainterPath united(const QPainterPath &r) const; | |
27663 | QPainterPath intersected(const QPainterPath &r) const; | |
27664 | QPainterPath subtracted(const QPainterPath &r) const; | |
27665 | QPainterPath subtractedInverted(const QPainterPath &r) const; | |
27666 | QPainterPath simplified() const; | |
27667 | bool operator==(const QPainterPath &other) const; | |
27668 | bool operator!=(const QPainterPath &other) const; | |
27669 | QPainterPath operator&(const QPainterPath &other) const; | |
27670 | QPainterPath operator|(const QPainterPath &other) const; | |
27671 | QPainterPath operator+(const QPainterPath &other) const; | |
27672 | QPainterPath operator-(const QPainterPath &other) const; | |
27673 | QPainterPath &operator&=(const QPainterPath &other); | |
27674 | QPainterPath &operator|=(const QPainterPath &other); | |
27675 | QPainterPath &operator+=(const QPainterPath &other); | |
27676 | QPainterPath &operator-=(const QPainterPath &other); | |
27677 | private: | |
27678 | QPainterPathPrivate *d_ptr; | |
27679 | inline void ensureData() { if (!d_ptr) ensureData_helper(); } | |
27680 | void ensureData_helper(); | |
27681 | inline void detach(); | |
27682 | void detach_helper(); | |
27683 | void setDirty(bool); | |
27684 | void computeBoundingRect() const; | |
27685 | void computeControlPointRect() const; | |
27686 | QPainterPathData *d_func() const { return reinterpret_cast<QPainterPathData *>(d_ptr); } | |
27687 | friend class QPainterPathData; | |
27688 | friend class QPainterPathStroker; | |
27689 | friend class QPainterPathStrokerPrivate; | |
27690 | friend class QMatrix; | |
27691 | friend class QTransform; | |
27692 | friend __attribute__((visibility("default"))) const QVectorPath &qtVectorPathForPath(const QPainterPath &); | |
27693 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPainterPath &); | |
27694 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPainterPath &); | |
27695 | }; | |
27696 | class QPainterPathPrivate | |
27697 | { | |
27698 | public: | |
27699 | friend class QPainterPath; | |
27700 | friend class QPainterPathData; | |
27701 | friend class QPainterPathStroker; | |
27702 | friend class QPainterPathStrokerPrivate; | |
27703 | friend class QMatrix; | |
27704 | friend class QTransform; | |
27705 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPainterPath &); | |
27706 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPainterPath &); | |
27707 | private: | |
27708 | QAtomicInt ref; | |
27709 | QVector<QPainterPath::Element> elements; | |
27710 | }; | |
27711 | template <> class QTypeInfo<QPainterPath::Element> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPainterPath::Element)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPainterPath::Element"; } }; | |
27712 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPainterPath &); | |
27713 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPainterPath &); | |
27714 | class __attribute__((visibility("default"))) QPainterPathStroker | |
27715 | { | |
27716 | inline QPainterPathStrokerPrivate* d_func() { return reinterpret_cast<QPainterPathStrokerPrivate *>(d_ptr); } inline const QPainterPathStrokerPrivate* d_func() const { return reinterpret_cast<const QPainterPathStrokerPrivate *>(d_ptr); } friend class QPainterPathStrokerPrivate; | |
27717 | public: | |
27718 | QPainterPathStroker(); | |
27719 | ~QPainterPathStroker(); | |
27720 | void setWidth(qreal width); | |
27721 | qreal width() const; | |
27722 | void setCapStyle(Qt::PenCapStyle style); | |
27723 | Qt::PenCapStyle capStyle() const; | |
27724 | void setJoinStyle(Qt::PenJoinStyle style); | |
27725 | Qt::PenJoinStyle joinStyle() const; | |
27726 | void setMiterLimit(qreal length); | |
27727 | qreal miterLimit() const; | |
27728 | void setCurveThreshold(qreal threshold); | |
27729 | qreal curveThreshold() const; | |
27730 | void setDashPattern(Qt::PenStyle); | |
27731 | void setDashPattern(const QVector<qreal> &dashPattern); | |
27732 | QVector<qreal> dashPattern() const; | |
27733 | void setDashOffset(qreal offset); | |
27734 | qreal dashOffset() const; | |
27735 | QPainterPath createStroke(const QPainterPath &path) const; | |
27736 | private: | |
27737 | friend class QX11PaintEngine; | |
27738 | QPainterPathStrokerPrivate *d_ptr; | |
27739 | }; | |
27740 | inline void QPainterPath::moveTo(qreal x, qreal y) | |
27741 | { | |
27742 | moveTo(QPointF(x, y)); | |
27743 | } | |
27744 | inline void QPainterPath::lineTo(qreal x, qreal y) | |
27745 | { | |
27746 | lineTo(QPointF(x, y)); | |
27747 | } | |
27748 | inline void QPainterPath::arcTo(qreal x, qreal y, qreal w, qreal h, qreal startAngle, qreal arcLenght) | |
27749 | { | |
27750 | arcTo(QRectF(x, y, w, h), startAngle, arcLenght); | |
27751 | } | |
27752 | inline void QPainterPath::arcMoveTo(qreal x, qreal y, qreal w, qreal h, qreal angle) | |
27753 | { | |
27754 | arcMoveTo(QRectF(x, y, w, h), angle); | |
27755 | } | |
27756 | inline void QPainterPath::cubicTo(qreal ctrlPt1x, qreal ctrlPt1y, qreal ctrlPt2x, qreal ctrlPt2y, | |
27757 | qreal endPtx, qreal endPty) | |
27758 | { | |
27759 | cubicTo(QPointF(ctrlPt1x, ctrlPt1y), QPointF(ctrlPt2x, ctrlPt2y), | |
27760 | QPointF(endPtx, endPty)); | |
27761 | } | |
27762 | inline void QPainterPath::quadTo(qreal ctrlPtx, qreal ctrlPty, qreal endPtx, qreal endPty) | |
27763 | { | |
27764 | quadTo(QPointF(ctrlPtx, ctrlPty), QPointF(endPtx, endPty)); | |
27765 | } | |
27766 | inline void QPainterPath::addEllipse(qreal x, qreal y, qreal w, qreal h) | |
27767 | { | |
27768 | addEllipse(QRectF(x, y, w, h)); | |
27769 | } | |
27770 | inline void QPainterPath::addEllipse(const QPointF ¢er, qreal rx, qreal ry) | |
27771 | { | |
27772 | addEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry)); | |
27773 | } | |
27774 | inline void QPainterPath::addRect(qreal x, qreal y, qreal w, qreal h) | |
27775 | { | |
27776 | addRect(QRectF(x, y, w, h)); | |
27777 | } | |
27778 | inline void QPainterPath::addRoundedRect(qreal x, qreal y, qreal w, qreal h, | |
27779 | qreal xRadius, qreal yRadius, | |
27780 | Qt::SizeMode mode) | |
27781 | { | |
27782 | addRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode); | |
27783 | } | |
27784 | inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h, | |
27785 | int xRnd, int yRnd) | |
27786 | { | |
27787 | addRoundRect(QRectF(x, y, w, h), xRnd, yRnd); | |
27788 | } | |
27789 | inline void QPainterPath::addRoundRect(const QRectF &rect, | |
27790 | int roundness) | |
27791 | { | |
27792 | int xRnd = roundness; | |
27793 | int yRnd = roundness; | |
27794 | if (rect.width() > rect.height()) | |
27795 | xRnd = int(roundness * rect.height()/rect.width()); | |
27796 | else | |
27797 | yRnd = int(roundness * rect.width()/rect.height()); | |
27798 | addRoundRect(rect, xRnd, yRnd); | |
27799 | } | |
27800 | inline void QPainterPath::addRoundRect(qreal x, qreal y, qreal w, qreal h, | |
27801 | int roundness) | |
27802 | { | |
27803 | addRoundRect(QRectF(x, y, w, h), roundness); | |
27804 | } | |
27805 | inline void QPainterPath::addText(qreal x, qreal y, const QFont &f, const QString &text) | |
27806 | { | |
27807 | addText(QPointF(x, y), f, text); | |
27808 | } | |
27809 | inline bool QPainterPath::isEmpty() const | |
27810 | { | |
27811 | return !d_ptr || (d_ptr->elements.size() == 1 && d_ptr->elements.first().type == MoveToElement); | |
27812 | } | |
27813 | inline int QPainterPath::elementCount() const | |
27814 | { | |
27815 | return d_ptr ? d_ptr->elements.size() : 0; | |
27816 | } | |
27817 | inline const QPainterPath::Element &QPainterPath::elementAt(int i) const | |
27818 | { | |
27819 | qt_noop(); | |
27820 | qt_noop(); | |
27821 | return d_ptr->elements.at(i); | |
27822 | } | |
27823 | inline void QPainterPath::setElementPositionAt(int i, qreal x, qreal y) | |
27824 | { | |
27825 | qt_noop(); | |
27826 | qt_noop(); | |
27827 | detach(); | |
27828 | QPainterPath::Element &e = d_ptr->elements[i]; | |
27829 | e.x = x; | |
27830 | e.y = y; | |
27831 | } | |
27832 | inline void QPainterPath::detach() | |
27833 | { | |
27834 | if (d_ptr->ref != 1) | |
27835 | detach_helper(); | |
27836 | setDirty(true); | |
27837 | } | |
27838 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QPainterPath &); | |
27839 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
27840 | class QVariant; | |
27841 | class __attribute__((visibility("default"))) QTransform | |
27842 | { | |
27843 | public: | |
27844 | enum TransformationType { | |
27845 | TxNone = 0x00, | |
27846 | TxTranslate = 0x01, | |
27847 | TxScale = 0x02, | |
27848 | TxRotate = 0x04, | |
27849 | TxShear = 0x08, | |
27850 | TxProject = 0x10 | |
27851 | }; | |
27852 | QTransform(); | |
27853 | QTransform(qreal h11, qreal h12, qreal h13, | |
27854 | qreal h21, qreal h22, qreal h23, | |
27855 | qreal h31, qreal h32, qreal h33 = 1.0); | |
27856 | QTransform(qreal h11, qreal h12, qreal h21, | |
27857 | qreal h22, qreal dx, qreal dy); | |
27858 | explicit QTransform(const QMatrix &mtx); | |
27859 | bool isAffine() const; | |
27860 | bool isIdentity() const; | |
27861 | bool isInvertible() const; | |
27862 | bool isScaling() const; | |
27863 | bool isRotating() const; | |
27864 | bool isTranslating() const; | |
27865 | TransformationType type() const; | |
27866 | inline qreal determinant() const; | |
27867 | qreal det() const; | |
27868 | qreal m11() const; | |
27869 | qreal m12() const; | |
27870 | qreal m13() const; | |
27871 | qreal m21() const; | |
27872 | qreal m22() const; | |
27873 | qreal m23() const; | |
27874 | qreal m31() const; | |
27875 | qreal m32() const; | |
27876 | qreal m33() const; | |
27877 | qreal dx() const; | |
27878 | qreal dy() const; | |
27879 | void setMatrix(qreal m11, qreal m12, qreal m13, | |
27880 | qreal m21, qreal m22, qreal m23, | |
27881 | qreal m31, qreal m32, qreal m33); | |
27882 | QTransform inverted(bool *invertible = 0) const; | |
27883 | QTransform adjoint() const; | |
27884 | QTransform transposed() const; | |
27885 | QTransform &translate(qreal dx, qreal dy); | |
27886 | QTransform &scale(qreal sx, qreal sy); | |
27887 | QTransform &shear(qreal sh, qreal sv); | |
27888 | QTransform &rotate(qreal a, Qt::Axis axis = Qt::ZAxis); | |
27889 | QTransform &rotateRadians(qreal a, Qt::Axis axis = Qt::ZAxis); | |
27890 | static bool squareToQuad(const QPolygonF &square, QTransform &result); | |
27891 | static bool quadToSquare(const QPolygonF &quad, QTransform &result); | |
27892 | static bool quadToQuad(const QPolygonF &one, | |
27893 | const QPolygonF &two, | |
27894 | QTransform &result); | |
27895 | bool operator==(const QTransform &) const; | |
27896 | bool operator!=(const QTransform &) const; | |
27897 | QTransform &operator*=(const QTransform &); | |
27898 | QTransform operator*(const QTransform &o) const; | |
27899 | QTransform &operator=(const QTransform &); | |
27900 | operator QVariant() const; | |
27901 | void reset(); | |
27902 | QPoint map(const QPoint &p) const; | |
27903 | QPointF map(const QPointF &p) const; | |
27904 | QLine map(const QLine &l) const; | |
27905 | QLineF map(const QLineF &l) const; | |
27906 | QPolygonF map(const QPolygonF &a) const; | |
27907 | QPolygon map(const QPolygon &a) const; | |
27908 | QRegion map(const QRegion &r) const; | |
27909 | QPainterPath map(const QPainterPath &p) const; | |
27910 | QPolygon mapToPolygon(const QRect &r) const; | |
27911 | QRect mapRect(const QRect &) const; | |
27912 | QRectF mapRect(const QRectF &) const; | |
27913 | void map(int x, int y, int *tx, int *ty) const; | |
27914 | void map(qreal x, qreal y, qreal *tx, qreal *ty) const; | |
27915 | const QMatrix &toAffine() const; | |
27916 | QTransform &operator*=(qreal div); | |
27917 | QTransform &operator/=(qreal div); | |
27918 | QTransform &operator+=(qreal div); | |
27919 | QTransform &operator-=(qreal div); | |
27920 | static QTransform fromTranslate(qreal dx, qreal dy); | |
27921 | static QTransform fromScale(qreal dx, qreal dy); | |
27922 | private: | |
27923 | QMatrix affine; | |
27924 | qreal m_13; | |
27925 | qreal m_23; | |
27926 | qreal m_33; | |
27927 | mutable uint m_type : 5; | |
27928 | mutable uint m_dirty : 5; | |
27929 | class Private; | |
27930 | Private *d; | |
27931 | }; | |
27932 | template <> class QTypeInfo<QTransform> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTransform)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTransform"; } }; | |
27933 | inline bool QTransform::isAffine() const | |
27934 | { | |
27935 | return type() < TxProject; | |
27936 | } | |
27937 | inline bool QTransform::isIdentity() const | |
27938 | { | |
27939 | return type() == TxNone; | |
27940 | } | |
27941 | inline bool QTransform::isInvertible() const | |
27942 | { | |
27943 | return !qFuzzyCompare(determinant() + 1, 1); | |
27944 | } | |
27945 | inline bool QTransform::isScaling() const | |
27946 | { | |
27947 | return type() >= TxScale; | |
27948 | } | |
27949 | inline bool QTransform::isRotating() const | |
27950 | { | |
27951 | return type() >= TxRotate; | |
27952 | } | |
27953 | inline bool QTransform::isTranslating() const | |
27954 | { | |
27955 | return type() >= TxTranslate; | |
27956 | } | |
27957 | inline qreal QTransform::determinant() const | |
27958 | { | |
27959 | return affine._m11*(m_33*affine._m22-affine._dy*m_23) - | |
27960 | affine._m21*(m_33*affine._m12-affine._dy*m_13)+affine._dx*(m_23*affine._m12-affine._m22*m_13); | |
27961 | } | |
27962 | inline qreal QTransform::det() const | |
27963 | { | |
27964 | return determinant(); | |
27965 | } | |
27966 | inline qreal QTransform::m11() const | |
27967 | { | |
27968 | return affine._m11; | |
27969 | } | |
27970 | inline qreal QTransform::m12() const | |
27971 | { | |
27972 | return affine._m12; | |
27973 | } | |
27974 | inline qreal QTransform::m13() const | |
27975 | { | |
27976 | return m_13; | |
27977 | } | |
27978 | inline qreal QTransform::m21() const | |
27979 | { | |
27980 | return affine._m21; | |
27981 | } | |
27982 | inline qreal QTransform::m22() const | |
27983 | { | |
27984 | return affine._m22; | |
27985 | } | |
27986 | inline qreal QTransform::m23() const | |
27987 | { | |
27988 | return m_23; | |
27989 | } | |
27990 | inline qreal QTransform::m31() const | |
27991 | { | |
27992 | return affine._dx; | |
27993 | } | |
27994 | inline qreal QTransform::m32() const | |
27995 | { | |
27996 | return affine._dy; | |
27997 | } | |
27998 | inline qreal QTransform::m33() const | |
27999 | { | |
28000 | return m_33; | |
28001 | } | |
28002 | inline qreal QTransform::dx() const | |
28003 | { | |
28004 | return affine._dx; | |
28005 | } | |
28006 | inline qreal QTransform::dy() const | |
28007 | { | |
28008 | return affine._dy; | |
28009 | } | |
28010 | inline QTransform &QTransform::operator*=(qreal num) | |
28011 | { | |
28012 | if (num == 1.) | |
28013 | return *this; | |
28014 | affine._m11 *= num; | |
28015 | affine._m12 *= num; | |
28016 | m_13 *= num; | |
28017 | affine._m21 *= num; | |
28018 | affine._m22 *= num; | |
28019 | m_23 *= num; | |
28020 | affine._dx *= num; | |
28021 | affine._dy *= num; | |
28022 | m_33 *= num; | |
28023 | m_dirty |= TxScale; | |
28024 | return *this; | |
28025 | } | |
28026 | inline QTransform &QTransform::operator/=(qreal div) | |
28027 | { | |
28028 | if (div == 0) | |
28029 | return *this; | |
28030 | div = 1/div; | |
28031 | return operator*=(div); | |
28032 | } | |
28033 | inline QTransform &QTransform::operator+=(qreal num) | |
28034 | { | |
28035 | if (num == 0) | |
28036 | return *this; | |
28037 | affine._m11 += num; | |
28038 | affine._m12 += num; | |
28039 | m_13 += num; | |
28040 | affine._m21 += num; | |
28041 | affine._m22 += num; | |
28042 | m_23 += num; | |
28043 | affine._dx += num; | |
28044 | affine._dy += num; | |
28045 | m_33 += num; | |
28046 | m_dirty |= TxProject; | |
28047 | return *this; | |
28048 | } | |
28049 | inline QTransform &QTransform::operator-=(qreal num) | |
28050 | { | |
28051 | if (num == 0) | |
28052 | return *this; | |
28053 | affine._m11 -= num; | |
28054 | affine._m12 -= num; | |
28055 | m_13 -= num; | |
28056 | affine._m21 -= num; | |
28057 | affine._m22 -= num; | |
28058 | m_23 -= num; | |
28059 | affine._dx -= num; | |
28060 | affine._dy -= num; | |
28061 | m_33 -= num; | |
28062 | m_dirty |= TxProject; | |
28063 | return *this; | |
28064 | } | |
28065 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QTransform &); | |
28066 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QTransform &); | |
28067 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QTransform &); | |
28068 | __attribute__((visibility("default"))) inline QPoint operator*(const QPoint &p, const QTransform &m) | |
28069 | { return m.map(p); } | |
28070 | __attribute__((visibility("default"))) inline QPointF operator*(const QPointF &p, const QTransform &m) | |
28071 | { return m.map(p); } | |
28072 | __attribute__((visibility("default"))) inline QLineF operator*(const QLineF &l, const QTransform &m) | |
28073 | { return m.map(l); } | |
28074 | __attribute__((visibility("default"))) inline QLine operator*(const QLine &l, const QTransform &m) | |
28075 | { return m.map(l); } | |
28076 | __attribute__((visibility("default"))) inline QPolygon operator *(const QPolygon &a, const QTransform &m) | |
28077 | { return m.map(a); } | |
28078 | __attribute__((visibility("default"))) inline QPolygonF operator *(const QPolygonF &a, const QTransform &m) | |
28079 | { return m.map(a); } | |
28080 | __attribute__((visibility("default"))) inline QRegion operator *(const QRegion &r, const QTransform &m) | |
28081 | { return m.map(r); } | |
28082 | __attribute__((visibility("default"))) inline QPainterPath operator *(const QPainterPath &p, const QTransform &m) | |
28083 | { return m.map(p); } | |
28084 | __attribute__((visibility("default"))) inline QTransform operator *(const QTransform &a, qreal n) | |
28085 | { QTransform t(a); t *= n; return t; } | |
28086 | __attribute__((visibility("default"))) inline QTransform operator /(const QTransform &a, qreal n) | |
28087 | { QTransform t(a); t /= n; return t; } | |
28088 | __attribute__((visibility("default"))) inline QTransform operator +(const QTransform &a, qreal n) | |
28089 | { QTransform t(a); t += n; return t; } | |
28090 | __attribute__((visibility("default"))) inline QTransform operator -(const QTransform &a, qreal n) | |
28091 | { QTransform t(a); t -= n; return t; } | |
28092 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28093 | class QWSDisplay; | |
28094 | class QPaintEngine; | |
28095 | class __attribute__((visibility("default"))) QPaintDevice | |
28096 | { | |
28097 | public: | |
28098 | enum PaintDeviceMetric { | |
28099 | PdmWidth = 1, | |
28100 | PdmHeight, | |
28101 | PdmWidthMM, | |
28102 | PdmHeightMM, | |
28103 | PdmNumColors, | |
28104 | PdmDepth, | |
28105 | PdmDpiX, | |
28106 | PdmDpiY, | |
28107 | PdmPhysicalDpiX, | |
28108 | PdmPhysicalDpiY | |
28109 | }; | |
28110 | virtual ~QPaintDevice(); | |
28111 | virtual int devType() const; | |
28112 | bool paintingActive() const; | |
28113 | virtual QPaintEngine *paintEngine() const = 0; | |
28114 | static QWSDisplay *qwsDisplay(); | |
28115 | int width() const { return metric(PdmWidth); } | |
28116 | int height() const { return metric(PdmHeight); } | |
28117 | int widthMM() const { return metric(PdmWidthMM); } | |
28118 | int heightMM() const { return metric(PdmHeightMM); } | |
28119 | int logicalDpiX() const { return metric(PdmDpiX); } | |
28120 | int logicalDpiY() const { return metric(PdmDpiY); } | |
28121 | int physicalDpiX() const { return metric(PdmPhysicalDpiX); } | |
28122 | int physicalDpiY() const { return metric(PdmPhysicalDpiY); } | |
28123 | int numColors() const { return metric(PdmNumColors); } | |
28124 | int depth() const { return metric(PdmDepth); } | |
28125 | protected: | |
28126 | QPaintDevice(); | |
28127 | virtual int metric(PaintDeviceMetric metric) const; | |
28128 | ushort painters; | |
28129 | private: | |
28130 | QPaintDevice(const QPaintDevice &); QPaintDevice &operator=(const QPaintDevice &); | |
28131 | friend class QPainter; | |
28132 | friend class QFontEngineMac; | |
28133 | friend class QX11PaintEngine; | |
28134 | }; | |
28135 | inline int QPaintDevice::devType() const | |
28136 | { return QInternal::UnknownDevice; } | |
28137 | inline bool QPaintDevice::paintingActive() const | |
28138 | { return painters != 0; } | |
28139 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28140 | class QIODevice; | |
28141 | class QStringList; | |
28142 | class QMatrix; | |
28143 | class QTransform; | |
28144 | class QVariant; | |
28145 | template <class T> class QList; | |
28146 | template <class T> class QVector; | |
28147 | struct QImageData; | |
28148 | class QImageDataMisc; | |
28149 | class __attribute__((visibility("default"))) QImageTextKeyLang { | |
28150 | public: | |
28151 | QImageTextKeyLang(const char* k, const char* l) : key(k), lang(l) { } | |
28152 | QImageTextKeyLang() { } | |
28153 | QByteArray key; | |
28154 | QByteArray lang; | |
28155 | bool operator< (const QImageTextKeyLang& other) const | |
28156 | { return key < other.key || (key==other.key && lang < other.lang); } | |
28157 | bool operator== (const QImageTextKeyLang& other) const | |
28158 | { return key==other.key && lang==other.lang; } | |
28159 | inline bool operator!= (const QImageTextKeyLang &other) const | |
28160 | { return !operator==(other); } | |
28161 | }; | |
28162 | class __attribute__((visibility("default"))) QImage : public QPaintDevice | |
28163 | { | |
28164 | public: | |
28165 | enum InvertMode { InvertRgb, InvertRgba }; | |
28166 | enum Format { | |
28167 | Format_Invalid, | |
28168 | Format_Mono, | |
28169 | Format_MonoLSB, | |
28170 | Format_Indexed8, | |
28171 | Format_RGB32, | |
28172 | Format_ARGB32, | |
28173 | Format_ARGB32_Premultiplied, | |
28174 | Format_RGB16, | |
28175 | Format_ARGB8565_Premultiplied, | |
28176 | Format_RGB666, | |
28177 | Format_ARGB6666_Premultiplied, | |
28178 | Format_RGB555, | |
28179 | Format_ARGB8555_Premultiplied, | |
28180 | Format_RGB888, | |
28181 | Format_RGB444, | |
28182 | Format_ARGB4444_Premultiplied, | |
28183 | NImageFormats | |
28184 | }; | |
28185 | QImage(); | |
28186 | QImage(const QSize &size, Format format); | |
28187 | QImage(int width, int height, Format format); | |
28188 | QImage(uchar *data, int width, int height, Format format); | |
28189 | QImage(const uchar *data, int width, int height, Format format); | |
28190 | QImage(uchar *data, int width, int height, int bytesPerLine, Format format); | |
28191 | QImage(const uchar *data, int width, int height, int bytesPerLine, Format format); | |
28192 | explicit QImage(const char * const xpm[]); | |
28193 | explicit QImage(const QString &fileName, const char *format = 0); | |
28194 | explicit QImage(const char *fileName, const char *format = 0); | |
28195 | QImage(const QImage &); | |
28196 | ~QImage(); | |
28197 | QImage &operator=(const QImage &); | |
28198 | bool isNull() const; | |
28199 | int devType() const; | |
28200 | bool operator==(const QImage &) const; | |
28201 | bool operator!=(const QImage &) const; | |
28202 | operator QVariant() const; | |
28203 | void detach(); | |
28204 | bool isDetached() const; | |
28205 | QImage copy(const QRect &rect = QRect()) const; | |
28206 | inline QImage copy(int x, int y, int w, int h) const | |
28207 | { return copy(QRect(x, y, w, h)); } | |
28208 | Format format() const; | |
28209 | QImage convertToFormat(Format f, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result)); | |
28210 | QImage convertToFormat(Format f, const QVector<QRgb> &colorTable, Qt::ImageConversionFlags flags = Qt::AutoColor) const __attribute__ ((warn_unused_result)); | |
28211 | int width() const; | |
28212 | int height() const; | |
28213 | QSize size() const; | |
28214 | QRect rect() const; | |
28215 | int depth() const; | |
28216 | int numColors() const; | |
28217 | QRgb color(int i) const; | |
28218 | void setColor(int i, QRgb c); | |
28219 | void setNumColors(int); | |
28220 | bool allGray() const; | |
28221 | bool isGrayscale() const; | |
28222 | uchar *bits(); | |
28223 | const uchar *bits() const; | |
28224 | int numBytes() const; | |
28225 | uchar *scanLine(int); | |
28226 | const uchar *scanLine(int) const; | |
28227 | int bytesPerLine() const; | |
28228 | bool valid(int x, int y) const; | |
28229 | bool valid(const QPoint &pt) const; | |
28230 | int pixelIndex(int x, int y) const; | |
28231 | int pixelIndex(const QPoint &pt) const; | |
28232 | QRgb pixel(int x, int y) const; | |
28233 | QRgb pixel(const QPoint &pt) const; | |
28234 | void setPixel(int x, int y, uint index_or_rgb); | |
28235 | void setPixel(const QPoint &pt, uint index_or_rgb); | |
28236 | QVector<QRgb> colorTable() const; | |
28237 | void setColorTable(const QVector<QRgb> colors); | |
28238 | void fill(uint pixel); | |
28239 | bool hasAlphaChannel() const; | |
28240 | void setAlphaChannel(const QImage &alphaChannel); | |
28241 | QImage alphaChannel() const; | |
28242 | QImage createAlphaMask(Qt::ImageConversionFlags flags = Qt::AutoColor) const; | |
28243 | QImage createHeuristicMask(bool clipTight = true) const; | |
28244 | QImage createMaskFromColor(QRgb color, Qt::MaskMode mode = Qt::MaskInColor) const; | |
28245 | inline QImage scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio, | |
28246 | Qt::TransformationMode mode = Qt::FastTransformation) const | |
28247 | { return scaled(QSize(w, h), aspectMode, mode); } | |
28248 | QImage scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio, | |
28249 | Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28250 | QImage scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28251 | QImage scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28252 | QImage transformed(const QMatrix &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28253 | static QMatrix trueMatrix(const QMatrix &, int w, int h); | |
28254 | QImage transformed(const QTransform &matrix, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28255 | static QTransform trueMatrix(const QTransform &, int w, int h); | |
28256 | QImage mirrored(bool horizontally = false, bool vertically = true) const; | |
28257 | QImage rgbSwapped() const; | |
28258 | void invertPixels(InvertMode = InvertRgb); | |
28259 | bool load(QIODevice *device, const char* format); | |
28260 | bool load(const QString &fileName, const char* format=0); | |
28261 | bool loadFromData(const uchar *buf, int len, const char *format = 0); | |
28262 | inline bool loadFromData(const QByteArray &data, const char* aformat=0) | |
28263 | { return loadFromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), aformat); } | |
28264 | bool save(const QString &fileName, const char* format=0, int quality=-1) const; | |
28265 | bool save(QIODevice *device, const char* format=0, int quality=-1) const; | |
28266 | static QImage fromData(const uchar *data, int size, const char *format = 0); | |
28267 | inline static QImage fromData(const QByteArray &data, const char *format = 0) | |
28268 | { return fromData(reinterpret_cast<const uchar *>(data.constData()), data.size(), format); } | |
28269 | int serialNumber() const; | |
28270 | qint64 cacheKey() const; | |
28271 | QPaintEngine *paintEngine() const; | |
28272 | int dotsPerMeterX() const; | |
28273 | int dotsPerMeterY() const; | |
28274 | void setDotsPerMeterX(int); | |
28275 | void setDotsPerMeterY(int); | |
28276 | QPoint offset() const; | |
28277 | void setOffset(const QPoint&); | |
28278 | QStringList textKeys() const; | |
28279 | QString text(const QString &key = QString()) const; | |
28280 | void setText(const QString &key, const QString &value); | |
28281 | QString text(const char* key, const char* lang=0) const; | |
28282 | QList<QImageTextKeyLang> textList() const; | |
28283 | QStringList textLanguages() const; | |
28284 | QString text(const QImageTextKeyLang&) const; | |
28285 | void setText(const char* key, const char* lang, const QString&); | |
28286 | protected: | |
28287 | virtual int metric(PaintDeviceMetric metric) const; | |
28288 | private: | |
28289 | friend class QWSOnScreenSurface; | |
28290 | QImageData *d; | |
28291 | friend class QRasterPixmapData; | |
28292 | friend class QDetachedPixmap; | |
28293 | friend __attribute__((visibility("default"))) qint64 qt_image_id(const QImage &image); | |
28294 | friend const QVector<QRgb> *qt_image_colortable(const QImage &image); | |
28295 | public: | |
28296 | typedef QImageData * DataPtr; | |
28297 | inline DataPtr &data_ptr() { return d; } | |
28298 | }; | |
28299 | template <> inline bool qIsDetached<QImage>(QImage &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QImage>(QImage &value1, QImage &value2) { const QImage::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
28300 | template <> class QTypeInfo<QImage> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QImage)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QImage"; } }; | |
28301 | __attribute__((visibility("default"))) inline bool QImage::valid(const QPoint &pt) const { return valid(pt.x(), pt.y()); } | |
28302 | __attribute__((visibility("default"))) inline int QImage::pixelIndex(const QPoint &pt) const { return pixelIndex(pt.x(), pt.y());} | |
28303 | __attribute__((visibility("default"))) inline QRgb QImage::pixel(const QPoint &pt) const { return pixel(pt.x(), pt.y()); } | |
28304 | __attribute__((visibility("default"))) inline void QImage::setPixel(const QPoint &pt, uint index_or_rgb) { setPixel(pt.x(), pt.y(), index_or_rgb); } | |
28305 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QImage &); | |
28306 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QImage &); | |
28307 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28308 | class QImageWriter; | |
28309 | class QColor; | |
28310 | class QVariant; | |
28311 | class QX11Info; | |
28312 | class QPixmapData; | |
28313 | class __attribute__((visibility("default"))) QPixmap : public QPaintDevice | |
28314 | { | |
28315 | public: | |
28316 | QPixmap(); | |
28317 | explicit QPixmap(QPixmapData *data); | |
28318 | QPixmap(int w, int h); | |
28319 | QPixmap(const QSize &); | |
28320 | QPixmap(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
28321 | QPixmap(const char * const xpm[]); | |
28322 | QPixmap(const QPixmap &); | |
28323 | ~QPixmap(); | |
28324 | QPixmap &operator=(const QPixmap &); | |
28325 | operator QVariant() const; | |
28326 | bool isNull() const; | |
28327 | int devType() const; | |
28328 | int width() const; | |
28329 | int height() const; | |
28330 | QSize size() const; | |
28331 | QRect rect() const; | |
28332 | int depth() const; | |
28333 | static int defaultDepth(); | |
28334 | void fill(const QColor &fillColor = Qt::white); | |
28335 | void fill(const QWidget *widget, const QPoint &ofs); | |
28336 | inline void fill(const QWidget *widget, int xofs, int yofs) { fill(widget, QPoint(xofs, yofs)); } | |
28337 | QBitmap mask() const; | |
28338 | void setMask(const QBitmap &); | |
28339 | QPixmap alphaChannel() const; | |
28340 | void setAlphaChannel(const QPixmap &); | |
28341 | bool hasAlpha() const; | |
28342 | bool hasAlphaChannel() const; | |
28343 | QBitmap createHeuristicMask(bool clipTight = true) const; | |
28344 | QBitmap createMaskFromColor(const QColor &maskColor) const; | |
28345 | QBitmap createMaskFromColor(const QColor &maskColor, Qt::MaskMode mode) const; | |
28346 | static QPixmap grabWindow(WId, int x=0, int y=0, int w=-1, int h=-1); | |
28347 | static QPixmap grabWidget(QWidget *widget, const QRect &rect); | |
28348 | static inline QPixmap grabWidget(QWidget *widget, int x=0, int y=0, int w=-1, int h=-1) | |
28349 | { return grabWidget(widget, QRect(x, y, w, h)); } | |
28350 | inline QPixmap scaled(int w, int h, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio, | |
28351 | Qt::TransformationMode mode = Qt::FastTransformation) const | |
28352 | { return scaled(QSize(w, h), aspectMode, mode); } | |
28353 | QPixmap scaled(const QSize &s, Qt::AspectRatioMode aspectMode = Qt::IgnoreAspectRatio, | |
28354 | Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28355 | QPixmap scaledToWidth(int w, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28356 | QPixmap scaledToHeight(int h, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28357 | QPixmap transformed(const QMatrix &, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28358 | static QMatrix trueMatrix(const QMatrix &m, int w, int h); | |
28359 | QPixmap transformed(const QTransform &, Qt::TransformationMode mode = Qt::FastTransformation) const; | |
28360 | static QTransform trueMatrix(const QTransform &m, int w, int h); | |
28361 | QImage toImage() const; | |
28362 | static QPixmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
28363 | bool load(const QString& fileName, const char *format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
28364 | bool loadFromData(const uchar *buf, uint len, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
28365 | inline bool loadFromData(const QByteArray &data, const char* format = 0, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
28366 | bool save(const QString& fileName, const char* format = 0, int quality = -1) const; | |
28367 | bool save(QIODevice* device, const char* format = 0, int quality = -1) const; | |
28368 | inline QPixmap copy(int x, int y, int width, int height) const; | |
28369 | QPixmap copy(const QRect &rect = QRect()) const; | |
28370 | int serialNumber() const; | |
28371 | qint64 cacheKey() const; | |
28372 | bool isDetached() const; | |
28373 | void detach(); | |
28374 | bool isQBitmap() const; | |
28375 | const uchar *qwsBits() const; | |
28376 | int qwsBytesPerLine() const; | |
28377 | QRgb *clut() const; | |
28378 | int numCols() const; | |
28379 | Qt::HANDLE handle() const; | |
28380 | QPaintEngine *paintEngine() const; | |
28381 | inline bool operator!() const { return isNull(); } | |
28382 | protected: | |
28383 | int metric(PaintDeviceMetric) const; | |
28384 | private: | |
28385 | QPixmapData *data; | |
28386 | bool doImageIO(QImageWriter *io, int quality) const; | |
28387 | enum Type { PixmapType, BitmapType }; | |
28388 | QPixmap(const QSize &s, Type); | |
28389 | void init(int, int, Type = PixmapType); | |
28390 | QPixmap(const QSize &s, int type); | |
28391 | void init(int, int, int); | |
28392 | void deref(); | |
28393 | friend class QPixmapData; | |
28394 | friend class QX11PixmapData; | |
28395 | friend class QMacPixmapData; | |
28396 | friend class QBitmap; | |
28397 | friend class QPaintDevice; | |
28398 | friend class QPainter; | |
28399 | friend class QGLWidget; | |
28400 | friend class QX11PaintEngine; | |
28401 | friend class QCoreGraphicsPaintEngine; | |
28402 | friend class QWidgetPrivate; | |
28403 | friend class QRasterPaintEngine; | |
28404 | friend class QRasterBuffer; | |
28405 | friend class QDirect3DPaintEngine; | |
28406 | friend class QDirect3DPaintEnginePrivate; | |
28407 | friend class QDetachedPixmap; | |
28408 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPixmap &); | |
28409 | friend __attribute__((visibility("default"))) qint64 qt_pixmap_id(const QPixmap &pixmap); | |
28410 | public: | |
28411 | QPixmapData* pixmapData() const; | |
28412 | public: | |
28413 | typedef QPixmapData * DataPtr; | |
28414 | inline DataPtr &data_ptr() { return data; } | |
28415 | }; | |
28416 | template <> inline bool qIsDetached<QPixmap>(QPixmap &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QPixmap>(QPixmap &value1, QPixmap &value2) { const QPixmap::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
28417 | inline QPixmap QPixmap::copy(int ax, int ay, int awidth, int aheight) const | |
28418 | { | |
28419 | return copy(QRect(ax, ay, awidth, aheight)); | |
28420 | } | |
28421 | inline bool QPixmap::loadFromData(const QByteArray &buf, const char *format, | |
28422 | Qt::ImageConversionFlags flags) | |
28423 | { | |
28424 | return loadFromData(reinterpret_cast<const uchar *>(buf.constData()), buf.size(), format, flags); | |
28425 | } | |
28426 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPixmap &); | |
28427 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPixmap &); | |
28428 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28429 | struct QBrushData; | |
28430 | class QPixmap; | |
28431 | class QGradient; | |
28432 | class QVariant; | |
28433 | class __attribute__((visibility("default"))) QBrush | |
28434 | { | |
28435 | public: | |
28436 | QBrush(); | |
28437 | QBrush(Qt::BrushStyle bs); | |
28438 | QBrush(const QColor &color, Qt::BrushStyle bs=Qt::SolidPattern); | |
28439 | QBrush(Qt::GlobalColor color, Qt::BrushStyle bs=Qt::SolidPattern); | |
28440 | QBrush(const QColor &color, const QPixmap &pixmap); | |
28441 | QBrush(Qt::GlobalColor color, const QPixmap &pixmap); | |
28442 | QBrush(const QPixmap &pixmap); | |
28443 | QBrush(const QImage &image); | |
28444 | QBrush(const QBrush &brush); | |
28445 | QBrush(const QGradient &gradient); | |
28446 | ~QBrush(); | |
28447 | QBrush &operator=(const QBrush &brush); | |
28448 | operator QVariant() const; | |
28449 | inline Qt::BrushStyle style() const; | |
28450 | void setStyle(Qt::BrushStyle); | |
28451 | inline const QMatrix &matrix() const; | |
28452 | void setMatrix(const QMatrix &mat); | |
28453 | inline QTransform transform() const; | |
28454 | void setTransform(const QTransform &); | |
28455 | QPixmap texture() const; | |
28456 | void setTexture(const QPixmap &pixmap); | |
28457 | QImage textureImage() const; | |
28458 | void setTextureImage(const QImage &image); | |
28459 | inline const QColor &color() const; | |
28460 | void setColor(const QColor &color); | |
28461 | inline void setColor(Qt::GlobalColor color); | |
28462 | const QGradient *gradient() const; | |
28463 | bool isOpaque() const; | |
28464 | bool operator==(const QBrush &b) const; | |
28465 | inline bool operator!=(const QBrush &b) const { return !(operator==(b)); } | |
28466 | private: | |
28467 | friend class QRasterPaintEngine; | |
28468 | friend class QRasterPaintEnginePrivate; | |
28469 | friend struct QSpanData; | |
28470 | friend class QPainter; | |
28471 | friend bool qHasPixmapTexture(const QBrush& brush); | |
28472 | void detach(Qt::BrushStyle newStyle); | |
28473 | void init(const QColor &color, Qt::BrushStyle bs); | |
28474 | QBrushData *d; | |
28475 | void cleanUp(QBrushData *x); | |
28476 | public: | |
28477 | inline bool isDetached() const; | |
28478 | typedef QBrushData * DataPtr; | |
28479 | inline DataPtr &data_ptr() { return d; } | |
28480 | }; | |
28481 | inline void QBrush::setColor(Qt::GlobalColor acolor) | |
28482 | { setColor(QColor(acolor)); } | |
28483 | template <> class QTypeInfo<QBrush> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QBrush)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QBrush"; } }; | |
28484 | template <> inline bool qIsDetached<QBrush>(QBrush &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QBrush>(QBrush &value1, QBrush &value2) { const QBrush::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
28485 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QBrush &); | |
28486 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QBrush &); | |
28487 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QBrush &); | |
28488 | struct QBrushData | |
28489 | { | |
28490 | QAtomicInt ref; | |
28491 | Qt::BrushStyle style; | |
28492 | QColor color; | |
28493 | QTransform transform; | |
28494 | }; | |
28495 | inline Qt::BrushStyle QBrush::style() const { return d->style; } | |
28496 | inline const QColor &QBrush::color() const { return d->color; } | |
28497 | inline const QMatrix &QBrush::matrix() const { return d->transform.toAffine(); } | |
28498 | inline QTransform QBrush::transform() const { return d->transform; } | |
28499 | inline bool QBrush::isDetached() const { return d->ref == 1; } | |
28500 | class QGradientPrivate; | |
28501 | typedef QPair<qreal, QColor> QGradientStop; | |
28502 | typedef QVector<QGradientStop> QGradientStops; | |
28503 | class __attribute__((visibility("default"))) QGradient | |
28504 | { | |
28505 | public: static const QMetaObject staticMetaObject; private: | |
28506 | public: | |
28507 | enum Type { | |
28508 | LinearGradient, | |
28509 | RadialGradient, | |
28510 | ConicalGradient, | |
28511 | NoGradient | |
28512 | }; | |
28513 | enum Spread { | |
28514 | PadSpread, | |
28515 | ReflectSpread, | |
28516 | RepeatSpread | |
28517 | }; | |
28518 | enum CoordinateMode { | |
28519 | LogicalMode, | |
28520 | StretchToDeviceMode, | |
28521 | ObjectBoundingMode | |
28522 | }; | |
28523 | enum InterpolationMode { | |
28524 | ColorInterpolation, | |
28525 | ComponentInterpolation | |
28526 | }; | |
28527 | QGradient(); | |
28528 | Type type() const { return m_type; } | |
28529 | inline void setSpread(Spread spread); | |
28530 | Spread spread() const { return m_spread; } | |
28531 | void setColorAt(qreal pos, const QColor &color); | |
28532 | void setStops(const QGradientStops &stops); | |
28533 | QGradientStops stops() const; | |
28534 | CoordinateMode coordinateMode() const; | |
28535 | void setCoordinateMode(CoordinateMode mode); | |
28536 | InterpolationMode interpolationMode() const; | |
28537 | void setInterpolationMode(InterpolationMode mode); | |
28538 | bool operator==(const QGradient &gradient) const; | |
28539 | inline bool operator!=(const QGradient &other) const | |
28540 | { return !operator==(other); } | |
28541 | bool operator==(const QGradient &gradient); | |
28542 | private: | |
28543 | friend class QLinearGradient; | |
28544 | friend class QRadialGradient; | |
28545 | friend class QConicalGradient; | |
28546 | Type m_type; | |
28547 | Spread m_spread; | |
28548 | QGradientStops m_stops; | |
28549 | union { | |
28550 | struct { | |
28551 | qreal x1, y1, x2, y2; | |
28552 | } linear; | |
28553 | struct { | |
28554 | qreal cx, cy, fx, fy, radius; | |
28555 | } radial; | |
28556 | struct { | |
28557 | qreal cx, cy, angle; | |
28558 | } conical; | |
28559 | } m_data; | |
28560 | void *dummy; | |
28561 | }; | |
28562 | inline void QGradient::setSpread(Spread aspread) | |
28563 | { m_spread = aspread; } | |
28564 | class __attribute__((visibility("default"))) QLinearGradient : public QGradient | |
28565 | { | |
28566 | public: | |
28567 | QLinearGradient(); | |
28568 | QLinearGradient(const QPointF &start, const QPointF &finalStop); | |
28569 | QLinearGradient(qreal xStart, qreal yStart, qreal xFinalStop, qreal yFinalStop); | |
28570 | QPointF start() const; | |
28571 | void setStart(const QPointF &start); | |
28572 | inline void setStart(qreal x, qreal y) { setStart(QPointF(x, y)); } | |
28573 | QPointF finalStop() const; | |
28574 | void setFinalStop(const QPointF &stop); | |
28575 | inline void setFinalStop(qreal x, qreal y) { setFinalStop(QPointF(x, y)); } | |
28576 | }; | |
28577 | class __attribute__((visibility("default"))) QRadialGradient : public QGradient | |
28578 | { | |
28579 | public: | |
28580 | QRadialGradient(); | |
28581 | QRadialGradient(const QPointF ¢er, qreal radius, const QPointF &focalPoint); | |
28582 | QRadialGradient(qreal cx, qreal cy, qreal radius, qreal fx, qreal fy); | |
28583 | QRadialGradient(const QPointF ¢er, qreal radius); | |
28584 | QRadialGradient(qreal cx, qreal cy, qreal radius); | |
28585 | QPointF center() const; | |
28586 | void setCenter(const QPointF ¢er); | |
28587 | inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); } | |
28588 | QPointF focalPoint() const; | |
28589 | void setFocalPoint(const QPointF &focalPoint); | |
28590 | inline void setFocalPoint(qreal x, qreal y) { setFocalPoint(QPointF(x, y)); } | |
28591 | qreal radius() const; | |
28592 | void setRadius(qreal radius); | |
28593 | }; | |
28594 | class __attribute__((visibility("default"))) QConicalGradient : public QGradient | |
28595 | { | |
28596 | public: | |
28597 | QConicalGradient(); | |
28598 | QConicalGradient(const QPointF ¢er, qreal startAngle); | |
28599 | QConicalGradient(qreal cx, qreal cy, qreal startAngle); | |
28600 | QPointF center() const; | |
28601 | void setCenter(const QPointF ¢er); | |
28602 | inline void setCenter(qreal x, qreal y) { setCenter(QPointF(x, y)); } | |
28603 | qreal angle() const; | |
28604 | void setAngle(qreal angle); | |
28605 | }; | |
28606 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28607 | class QVariant; | |
28608 | class QPenPrivate; | |
28609 | class QBrush; | |
28610 | class QPen; | |
28611 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPen &); | |
28612 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPen &); | |
28613 | class __attribute__((visibility("default"))) QPen | |
28614 | { | |
28615 | public: | |
28616 | QPen(); | |
28617 | QPen(Qt::PenStyle); | |
28618 | QPen(const QColor &color); | |
28619 | QPen(const QBrush &brush, qreal width, Qt::PenStyle s = Qt::SolidLine, | |
28620 | Qt::PenCapStyle c = Qt::SquareCap, Qt::PenJoinStyle j = Qt::BevelJoin); | |
28621 | QPen(const QPen &pen); | |
28622 | ~QPen(); | |
28623 | QPen &operator=(const QPen &pen); | |
28624 | Qt::PenStyle style() const; | |
28625 | void setStyle(Qt::PenStyle); | |
28626 | QVector<qreal> dashPattern() const; | |
28627 | void setDashPattern(const QVector<qreal> &pattern); | |
28628 | qreal dashOffset() const; | |
28629 | void setDashOffset(qreal doffset); | |
28630 | qreal miterLimit() const; | |
28631 | void setMiterLimit(qreal limit); | |
28632 | qreal widthF() const; | |
28633 | void setWidthF(qreal width); | |
28634 | int width() const; | |
28635 | void setWidth(int width); | |
28636 | QColor color() const; | |
28637 | void setColor(const QColor &color); | |
28638 | QBrush brush() const; | |
28639 | void setBrush(const QBrush &brush); | |
28640 | bool isSolid() const; | |
28641 | Qt::PenCapStyle capStyle() const; | |
28642 | void setCapStyle(Qt::PenCapStyle pcs); | |
28643 | Qt::PenJoinStyle joinStyle() const; | |
28644 | void setJoinStyle(Qt::PenJoinStyle pcs); | |
28645 | bool isCosmetic() const; | |
28646 | void setCosmetic(bool cosmetic); | |
28647 | bool operator==(const QPen &p) const; | |
28648 | inline bool operator!=(const QPen &p) const { return !(operator==(p)); } | |
28649 | operator QVariant() const; | |
28650 | bool isDetached(); | |
28651 | private: | |
28652 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QPen &); | |
28653 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QPen &); | |
28654 | void detach(); | |
28655 | class QPenPrivate *d; | |
28656 | public: | |
28657 | typedef QPenPrivate * DataPtr; | |
28658 | inline DataPtr &data_ptr() { return d; } | |
28659 | }; | |
28660 | template <> class QTypeInfo<QPen> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QPen)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QPen"; } }; | |
28661 | template <> inline bool qIsDetached<QPen>(QPen &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QPen>(QPen &value1, QPen &value2) { const QPen::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
28662 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QPen &); | |
28663 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28664 | template <typename T> class QList; | |
28665 | struct QTextOptionPrivate; | |
28666 | class __attribute__((visibility("default"))) QTextOption | |
28667 | { | |
28668 | public: | |
28669 | enum TabType { | |
28670 | LeftTab, | |
28671 | RightTab, | |
28672 | CenterTab, | |
28673 | DelimiterTab | |
28674 | }; | |
28675 | struct __attribute__((visibility("default"))) Tab { | |
28676 | inline Tab() : position(80), type(QTextOption::LeftTab) { } | |
28677 | inline bool operator==(const Tab &other) const { | |
28678 | return type == other.type | |
28679 | && qFuzzyCompare(position, other.position) | |
28680 | && delimiter == other.delimiter; | |
28681 | } | |
28682 | inline bool operator!=(const Tab &other) const { | |
28683 | return !operator==(other); | |
28684 | } | |
28685 | qreal position; | |
28686 | TabType type; | |
28687 | QChar delimiter; | |
28688 | }; | |
28689 | QTextOption(); | |
28690 | QTextOption(Qt::Alignment alignment); | |
28691 | ~QTextOption(); | |
28692 | QTextOption(const QTextOption &o); | |
28693 | QTextOption &operator=(const QTextOption &o); | |
28694 | inline void setAlignment(Qt::Alignment alignment); | |
28695 | inline Qt::Alignment alignment() const { return Qt::Alignment(align); } | |
28696 | inline void setTextDirection(Qt::LayoutDirection aDirection) { this->direction = aDirection; } | |
28697 | inline Qt::LayoutDirection textDirection() const { return Qt::LayoutDirection(direction); } | |
28698 | enum WrapMode { | |
28699 | NoWrap, | |
28700 | WordWrap, | |
28701 | ManualWrap, | |
28702 | WrapAnywhere, | |
28703 | WrapAtWordBoundaryOrAnywhere | |
28704 | }; | |
28705 | inline void setWrapMode(WrapMode wrap) { wordWrap = wrap; } | |
28706 | inline WrapMode wrapMode() const { return static_cast<WrapMode>(wordWrap); } | |
28707 | enum Flag { | |
28708 | ShowTabsAndSpaces = 0x1, | |
28709 | ShowLineAndParagraphSeparators = 0x2, | |
28710 | AddSpaceForLineAndParagraphSeparators = 0x4, | |
28711 | SuppressColors = 0x8, | |
28712 | IncludeTrailingSpaces = 0x80000000 | |
28713 | }; | |
28714 | typedef QFlags<Flag> Flags; | |
28715 | inline void setFlags(Flags flags); | |
28716 | inline Flags flags() const { return Flags(f); } | |
28717 | inline void setTabStop(qreal tabStop); | |
28718 | inline qreal tabStop() const { return tab; } | |
28719 | void setTabArray(QList<qreal> tabStops); | |
28720 | QList<qreal> tabArray() const; | |
28721 | void setTabs(QList<Tab> tabStops); | |
28722 | QList<Tab> tabs() const; | |
28723 | void setUseDesignMetrics(bool b) { design = b; } | |
28724 | bool useDesignMetrics() const { return design; } | |
28725 | private: | |
28726 | uint align : 8; | |
28727 | uint wordWrap : 4; | |
28728 | uint design : 1; | |
28729 | uint direction : 1; | |
28730 | uint unused : 19; | |
28731 | uint f; | |
28732 | qreal tab; | |
28733 | QTextOptionPrivate *d; | |
28734 | }; | |
28735 | inline QFlags<QTextOption::Flags::enum_type> operator|(QTextOption::Flags::enum_type f1, QTextOption::Flags::enum_type f2) { return QFlags<QTextOption::Flags::enum_type>(f1) | f2; } inline QFlags<QTextOption::Flags::enum_type> operator|(QTextOption::Flags::enum_type f1, QFlags<QTextOption::Flags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextOption::Flags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
28736 | inline void QTextOption::setAlignment(Qt::Alignment aalignment) | |
28737 | { align = aalignment; } | |
28738 | inline void QTextOption::setFlags(Flags aflags) | |
28739 | { f = aflags; } | |
28740 | inline void QTextOption::setTabStop(qreal atabStop) | |
28741 | { tab = atabStop; } | |
28742 | template <> struct QMetaTypeId< QTextOption::Tab > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id) metatype_id = qRegisterMetaType< QTextOption::Tab >("QTextOption::Tab"); return metatype_id; } }; | |
28743 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
28744 | class QString; | |
28745 | class QVariant; | |
28746 | class QFont; | |
28747 | class QTextFormatCollection; | |
28748 | class QTextFormatPrivate; | |
28749 | class QTextBlockFormat; | |
28750 | class QTextCharFormat; | |
28751 | class QTextListFormat; | |
28752 | class QTextTableFormat; | |
28753 | class QTextFrameFormat; | |
28754 | class QTextImageFormat; | |
28755 | class QTextTableCellFormat; | |
28756 | class QTextFormat; | |
28757 | class QTextObject; | |
28758 | class QTextCursor; | |
28759 | class QTextDocument; | |
28760 | class QTextLength; | |
28761 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QTextLength &); | |
28762 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QTextLength &); | |
28763 | class __attribute__((visibility("default"))) QTextLength | |
28764 | { | |
28765 | public: | |
28766 | enum Type { VariableLength = 0, FixedLength, PercentageLength }; | |
28767 | inline QTextLength() : lengthType(VariableLength), fixedValueOrPercentage(0) {} | |
28768 | inline explicit QTextLength(Type type, qreal value); | |
28769 | inline Type type() const { return lengthType; } | |
28770 | inline qreal value(qreal maximumLength) const | |
28771 | { | |
28772 | switch (lengthType) { | |
28773 | case FixedLength: return fixedValueOrPercentage; | |
28774 | case VariableLength: return maximumLength; | |
28775 | case PercentageLength: return fixedValueOrPercentage * maximumLength / qreal(100); | |
28776 | } | |
28777 | return -1; | |
28778 | } | |
28779 | inline qreal rawValue() const { return fixedValueOrPercentage; } | |
28780 | inline bool operator==(const QTextLength &other) const | |
28781 | { return lengthType == other.lengthType | |
28782 | && qFuzzyCompare(fixedValueOrPercentage, other.fixedValueOrPercentage); } | |
28783 | inline bool operator!=(const QTextLength &other) const | |
28784 | { return lengthType != other.lengthType | |
28785 | || !qFuzzyCompare(fixedValueOrPercentage, other.fixedValueOrPercentage); } | |
28786 | operator QVariant() const; | |
28787 | private: | |
28788 | Type lengthType; | |
28789 | qreal fixedValueOrPercentage; | |
28790 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QTextLength &); | |
28791 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QTextLength &); | |
28792 | }; | |
28793 | inline QTextLength::QTextLength(Type atype, qreal avalue) | |
28794 | : lengthType(atype), fixedValueOrPercentage(avalue) {} | |
28795 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QTextFormat &); | |
28796 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QTextFormat &); | |
28797 | class __attribute__((visibility("default"))) QTextFormat | |
28798 | { | |
28799 | public: static const QMetaObject staticMetaObject; private: | |
28800 | public: | |
28801 | enum FormatType { | |
28802 | InvalidFormat = -1, | |
28803 | BlockFormat = 1, | |
28804 | CharFormat = 2, | |
28805 | ListFormat = 3, | |
28806 | TableFormat = 4, | |
28807 | FrameFormat = 5, | |
28808 | UserFormat = 100 | |
28809 | }; | |
28810 | enum Property { | |
28811 | ObjectIndex = 0x0, | |
28812 | CssFloat = 0x0800, | |
28813 | LayoutDirection = 0x0801, | |
28814 | OutlinePen = 0x810, | |
28815 | BackgroundBrush = 0x820, | |
28816 | ForegroundBrush = 0x821, | |
28817 | BackgroundImageUrl = 0x823, | |
28818 | BlockAlignment = 0x1010, | |
28819 | BlockTopMargin = 0x1030, | |
28820 | BlockBottomMargin = 0x1031, | |
28821 | BlockLeftMargin = 0x1032, | |
28822 | BlockRightMargin = 0x1033, | |
28823 | TextIndent = 0x1034, | |
28824 | TabPositions = 0x1035, | |
28825 | BlockIndent = 0x1040, | |
28826 | BlockNonBreakableLines = 0x1050, | |
28827 | BlockTrailingHorizontalRulerWidth = 0x1060, | |
28828 | FirstFontProperty = 0x1FE0, | |
28829 | FontCapitalization = FirstFontProperty, | |
28830 | FontLetterSpacing = 0x1FE1, | |
28831 | FontWordSpacing = 0x1FE2, | |
28832 | FontStyleHint = 0x1FE3, | |
28833 | FontStyleStrategy = 0x1FE4, | |
28834 | FontKerning = 0x1FE5, | |
28835 | FontFamily = 0x2000, | |
28836 | FontPointSize = 0x2001, | |
28837 | FontSizeAdjustment = 0x2002, | |
28838 | FontSizeIncrement = FontSizeAdjustment, | |
28839 | FontWeight = 0x2003, | |
28840 | FontItalic = 0x2004, | |
28841 | FontUnderline = 0x2005, | |
28842 | FontOverline = 0x2006, | |
28843 | FontStrikeOut = 0x2007, | |
28844 | FontFixedPitch = 0x2008, | |
28845 | FontPixelSize = 0x2009, | |
28846 | LastFontProperty = FontPixelSize, | |
28847 | TextUnderlineColor = 0x2010, | |
28848 | TextVerticalAlignment = 0x2021, | |
28849 | TextOutline = 0x2022, | |
28850 | TextUnderlineStyle = 0x2023, | |
28851 | TextToolTip = 0x2024, | |
28852 | IsAnchor = 0x2030, | |
28853 | AnchorHref = 0x2031, | |
28854 | AnchorName = 0x2032, | |
28855 | ObjectType = 0x2f00, | |
28856 | ListStyle = 0x3000, | |
28857 | ListIndent = 0x3001, | |
28858 | FrameBorder = 0x4000, | |
28859 | FrameMargin = 0x4001, | |
28860 | FramePadding = 0x4002, | |
28861 | FrameWidth = 0x4003, | |
28862 | FrameHeight = 0x4004, | |
28863 | FrameTopMargin = 0x4005, | |
28864 | FrameBottomMargin = 0x4006, | |
28865 | FrameLeftMargin = 0x4007, | |
28866 | FrameRightMargin = 0x4008, | |
28867 | FrameBorderBrush = 0x4009, | |
28868 | FrameBorderStyle = 0x4010, | |
28869 | TableColumns = 0x4100, | |
28870 | TableColumnWidthConstraints = 0x4101, | |
28871 | TableCellSpacing = 0x4102, | |
28872 | TableCellPadding = 0x4103, | |
28873 | TableHeaderRowCount = 0x4104, | |
28874 | TableCellRowSpan = 0x4810, | |
28875 | TableCellColumnSpan = 0x4811, | |
28876 | TableCellTopPadding = 0x4812, | |
28877 | TableCellBottomPadding = 0x4813, | |
28878 | TableCellLeftPadding = 0x4814, | |
28879 | TableCellRightPadding = 0x4815, | |
28880 | ImageName = 0x5000, | |
28881 | ImageWidth = 0x5010, | |
28882 | ImageHeight = 0x5011, | |
28883 | FullWidthSelection = 0x06000, | |
28884 | PageBreakPolicy = 0x7000, | |
28885 | UserProperty = 0x100000 | |
28886 | }; | |
28887 | enum ObjectTypes { | |
28888 | NoObject, | |
28889 | ImageObject, | |
28890 | TableObject, | |
28891 | TableCellObject, | |
28892 | UserObject = 0x1000 | |
28893 | }; | |
28894 | enum PageBreakFlag { | |
28895 | PageBreak_Auto = 0, | |
28896 | PageBreak_AlwaysBefore = 0x001, | |
28897 | PageBreak_AlwaysAfter = 0x010 | |
28898 | }; | |
28899 | typedef QFlags<PageBreakFlag> PageBreakFlags; | |
28900 | QTextFormat(); | |
28901 | explicit QTextFormat(int type); | |
28902 | QTextFormat(const QTextFormat &rhs); | |
28903 | QTextFormat &operator=(const QTextFormat &rhs); | |
28904 | ~QTextFormat(); | |
28905 | void merge(const QTextFormat &other); | |
28906 | inline bool isValid() const { return type() != InvalidFormat; } | |
28907 | int type() const; | |
28908 | int objectIndex() const; | |
28909 | void setObjectIndex(int object); | |
28910 | QVariant property(int propertyId) const; | |
28911 | void setProperty(int propertyId, const QVariant &value); | |
28912 | void clearProperty(int propertyId); | |
28913 | bool hasProperty(int propertyId) const; | |
28914 | bool boolProperty(int propertyId) const; | |
28915 | int intProperty(int propertyId) const; | |
28916 | qreal doubleProperty(int propertyId) const; | |
28917 | QString stringProperty(int propertyId) const; | |
28918 | QColor colorProperty(int propertyId) const; | |
28919 | QPen penProperty(int propertyId) const; | |
28920 | QBrush brushProperty(int propertyId) const; | |
28921 | QTextLength lengthProperty(int propertyId) const; | |
28922 | QVector<QTextLength> lengthVectorProperty(int propertyId) const; | |
28923 | void setProperty(int propertyId, const QVector<QTextLength> &lengths); | |
28924 | QMap<int, QVariant> properties() const; | |
28925 | int propertyCount() const; | |
28926 | inline void setObjectType(int type); | |
28927 | inline int objectType() const | |
28928 | { return intProperty(ObjectType); } | |
28929 | inline bool isCharFormat() const { return type() == CharFormat; } | |
28930 | inline bool isBlockFormat() const { return type() == BlockFormat; } | |
28931 | inline bool isListFormat() const { return type() == ListFormat; } | |
28932 | inline bool isFrameFormat() const { return type() == FrameFormat; } | |
28933 | inline bool isImageFormat() const { return type() == CharFormat && objectType() == ImageObject; } | |
28934 | inline bool isTableFormat() const { return type() == FrameFormat && objectType() == TableObject; } | |
28935 | inline bool isTableCellFormat() const { return type() == CharFormat && objectType() == TableCellObject; } | |
28936 | QTextBlockFormat toBlockFormat() const; | |
28937 | QTextCharFormat toCharFormat() const; | |
28938 | QTextListFormat toListFormat() const; | |
28939 | QTextTableFormat toTableFormat() const; | |
28940 | QTextFrameFormat toFrameFormat() const; | |
28941 | QTextImageFormat toImageFormat() const; | |
28942 | QTextTableCellFormat toTableCellFormat() const; | |
28943 | bool operator==(const QTextFormat &rhs) const; | |
28944 | inline bool operator!=(const QTextFormat &rhs) const { return !operator==(rhs); } | |
28945 | operator QVariant() const; | |
28946 | inline void setLayoutDirection(Qt::LayoutDirection direction) | |
28947 | { setProperty(QTextFormat::LayoutDirection, direction); } | |
28948 | inline Qt::LayoutDirection layoutDirection() const | |
28949 | { return Qt::LayoutDirection(intProperty(QTextFormat::LayoutDirection)); } | |
28950 | inline void setBackground(const QBrush &brush) | |
28951 | { setProperty(BackgroundBrush, brush); } | |
28952 | inline QBrush background() const | |
28953 | { return brushProperty(BackgroundBrush); } | |
28954 | inline void clearBackground() | |
28955 | { clearProperty(BackgroundBrush); } | |
28956 | inline void setForeground(const QBrush &brush) | |
28957 | { setProperty(ForegroundBrush, brush); } | |
28958 | inline QBrush foreground() const | |
28959 | { return brushProperty(ForegroundBrush); } | |
28960 | inline void clearForeground() | |
28961 | { clearProperty(ForegroundBrush); } | |
28962 | private: | |
28963 | QSharedDataPointer<QTextFormatPrivate> d; | |
28964 | qint32 format_type; | |
28965 | friend class QTextFormatCollection; | |
28966 | friend class QTextCharFormat; | |
28967 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QTextFormat &); | |
28968 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QTextFormat &); | |
28969 | }; | |
28970 | inline void QTextFormat::setObjectType(int atype) | |
28971 | { setProperty(ObjectType, atype); } | |
28972 | inline QFlags<QTextFormat::PageBreakFlags::enum_type> operator|(QTextFormat::PageBreakFlags::enum_type f1, QTextFormat::PageBreakFlags::enum_type f2) { return QFlags<QTextFormat::PageBreakFlags::enum_type>(f1) | f2; } inline QFlags<QTextFormat::PageBreakFlags::enum_type> operator|(QTextFormat::PageBreakFlags::enum_type f1, QFlags<QTextFormat::PageBreakFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextFormat::PageBreakFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
28973 | class __attribute__((visibility("default"))) QTextCharFormat : public QTextFormat | |
28974 | { | |
28975 | public: | |
28976 | enum VerticalAlignment { | |
28977 | AlignNormal = 0, | |
28978 | AlignSuperScript, | |
28979 | AlignSubScript, | |
28980 | AlignMiddle, | |
28981 | AlignTop, | |
28982 | AlignBottom | |
28983 | }; | |
28984 | enum UnderlineStyle { | |
28985 | NoUnderline, | |
28986 | SingleUnderline, | |
28987 | DashUnderline, | |
28988 | DotLine, | |
28989 | DashDotLine, | |
28990 | DashDotDotLine, | |
28991 | WaveUnderline, | |
28992 | SpellCheckUnderline | |
28993 | }; | |
28994 | QTextCharFormat(); | |
28995 | bool isValid() const { return isCharFormat(); } | |
28996 | void setFont(const QFont &font); | |
28997 | QFont font() const; | |
28998 | inline void setFontFamily(const QString &family) | |
28999 | { setProperty(FontFamily, family); } | |
29000 | inline QString fontFamily() const | |
29001 | { return stringProperty(FontFamily); } | |
29002 | inline void setFontPointSize(qreal size) | |
29003 | { setProperty(FontPointSize, size); } | |
29004 | inline qreal fontPointSize() const | |
29005 | { return doubleProperty(FontPointSize); } | |
29006 | inline void setFontWeight(int weight) | |
29007 | { if (weight == QFont::Normal) weight = 0; setProperty(FontWeight, weight); } | |
29008 | inline int fontWeight() const | |
29009 | { int weight = intProperty(FontWeight); if (weight == 0) weight = QFont::Normal; return weight; } | |
29010 | inline void setFontItalic(bool italic) | |
29011 | { setProperty(FontItalic, italic); } | |
29012 | inline bool fontItalic() const | |
29013 | { return boolProperty(FontItalic); } | |
29014 | inline void setFontCapitalization(QFont::Capitalization capitalization) | |
29015 | { setProperty(FontCapitalization, capitalization); } | |
29016 | inline QFont::Capitalization fontCapitalization() const | |
29017 | { return static_cast<QFont::Capitalization>(intProperty(FontCapitalization)); } | |
29018 | inline void setFontLetterSpacing(qreal spacing) | |
29019 | { setProperty(FontLetterSpacing, spacing); } | |
29020 | inline qreal fontLetterSpacing() const | |
29021 | { return doubleProperty(FontLetterSpacing); } | |
29022 | inline void setFontWordSpacing(qreal spacing) | |
29023 | { setProperty(FontWordSpacing, spacing); } | |
29024 | inline qreal fontWordSpacing() const | |
29025 | { return doubleProperty(FontWordSpacing); } | |
29026 | inline void setFontUnderline(bool underline) | |
29027 | { setProperty(TextUnderlineStyle, underline ? SingleUnderline : NoUnderline); } | |
29028 | bool fontUnderline() const; | |
29029 | inline void setFontOverline(bool overline) | |
29030 | { setProperty(FontOverline, overline); } | |
29031 | inline bool fontOverline() const | |
29032 | { return boolProperty(FontOverline); } | |
29033 | inline void setFontStrikeOut(bool strikeOut) | |
29034 | { setProperty(FontStrikeOut, strikeOut); } | |
29035 | inline bool fontStrikeOut() const | |
29036 | { return boolProperty(FontStrikeOut); } | |
29037 | inline void setUnderlineColor(const QColor &color) | |
29038 | { setProperty(TextUnderlineColor, color); } | |
29039 | inline QColor underlineColor() const | |
29040 | { return colorProperty(TextUnderlineColor); } | |
29041 | inline void setFontFixedPitch(bool fixedPitch) | |
29042 | { setProperty(FontFixedPitch, fixedPitch); } | |
29043 | inline bool fontFixedPitch() const | |
29044 | { return boolProperty(FontFixedPitch); } | |
29045 | inline void setFontStyleHint(QFont::StyleHint hint, QFont::StyleStrategy strategy = QFont::PreferDefault) | |
29046 | { setProperty(FontStyleHint, hint); setProperty(FontStyleStrategy, strategy); } | |
29047 | inline void setFontStyleStrategy(QFont::StyleStrategy strategy) | |
29048 | { setProperty(FontStyleStrategy, strategy); } | |
29049 | QFont::StyleHint fontStyleHint() const | |
29050 | { return static_cast<QFont::StyleHint>(intProperty(FontStyleHint)); } | |
29051 | QFont::StyleStrategy fontStyleStrategy() const | |
29052 | { return static_cast<QFont::StyleStrategy>(intProperty(FontStyleStrategy)); } | |
29053 | inline void setFontKerning(bool enable) | |
29054 | { setProperty(FontKerning, enable); } | |
29055 | inline bool fontKerning() const | |
29056 | { return boolProperty(FontKerning); } | |
29057 | void setUnderlineStyle(UnderlineStyle style); | |
29058 | inline UnderlineStyle underlineStyle() const | |
29059 | { return static_cast<UnderlineStyle>(intProperty(TextUnderlineStyle)); } | |
29060 | inline void setVerticalAlignment(VerticalAlignment alignment) | |
29061 | { setProperty(TextVerticalAlignment, alignment); } | |
29062 | inline VerticalAlignment verticalAlignment() const | |
29063 | { return static_cast<VerticalAlignment>(intProperty(TextVerticalAlignment)); } | |
29064 | inline void setTextOutline(const QPen &pen) | |
29065 | { setProperty(TextOutline, pen); } | |
29066 | inline QPen textOutline() const | |
29067 | { return penProperty(TextOutline); } | |
29068 | inline void setToolTip(const QString &tip) | |
29069 | { setProperty(TextToolTip, tip); } | |
29070 | inline QString toolTip() const | |
29071 | { return stringProperty(TextToolTip); } | |
29072 | inline void setAnchor(bool anchor) | |
29073 | { setProperty(IsAnchor, anchor); } | |
29074 | inline bool isAnchor() const | |
29075 | { return boolProperty(IsAnchor); } | |
29076 | inline void setAnchorHref(const QString &value) | |
29077 | { setProperty(AnchorHref, value); } | |
29078 | inline QString anchorHref() const | |
29079 | { return stringProperty(AnchorHref); } | |
29080 | inline void setAnchorName(const QString &name) | |
29081 | { setAnchorNames(QStringList(name)); } | |
29082 | QString anchorName() const; | |
29083 | inline void setAnchorNames(const QStringList &names) | |
29084 | { setProperty(AnchorName, names); } | |
29085 | QStringList anchorNames() const; | |
29086 | inline void setTableCellRowSpan(int tableCellRowSpan); | |
29087 | inline int tableCellRowSpan() const | |
29088 | { int s = intProperty(TableCellRowSpan); if (s == 0) s = 1; return s; } | |
29089 | inline void setTableCellColumnSpan(int tableCellColumnSpan); | |
29090 | inline int tableCellColumnSpan() const | |
29091 | { int s = intProperty(TableCellColumnSpan); if (s == 0) s = 1; return s; } | |
29092 | protected: | |
29093 | explicit QTextCharFormat(const QTextFormat &fmt); | |
29094 | friend class QTextFormat; | |
29095 | }; | |
29096 | inline void QTextCharFormat::setTableCellRowSpan(int _tableCellRowSpan) | |
29097 | { | |
29098 | if (_tableCellRowSpan <= 1) | |
29099 | clearProperty(TableCellRowSpan); | |
29100 | else | |
29101 | setProperty(TableCellRowSpan, _tableCellRowSpan); | |
29102 | } | |
29103 | inline void QTextCharFormat::setTableCellColumnSpan(int _tableCellColumnSpan) | |
29104 | { | |
29105 | if (_tableCellColumnSpan <= 1) | |
29106 | clearProperty(TableCellColumnSpan); | |
29107 | else | |
29108 | setProperty(TableCellColumnSpan, _tableCellColumnSpan); | |
29109 | } | |
29110 | class __attribute__((visibility("default"))) QTextBlockFormat : public QTextFormat | |
29111 | { | |
29112 | public: | |
29113 | QTextBlockFormat(); | |
29114 | bool isValid() const { return isBlockFormat(); } | |
29115 | inline void setAlignment(Qt::Alignment alignment); | |
29116 | inline Qt::Alignment alignment() const | |
29117 | { int a = intProperty(BlockAlignment); if (a == 0) a = Qt::AlignLeft; return QFlag(a); } | |
29118 | inline void setTopMargin(qreal margin) | |
29119 | { setProperty(BlockTopMargin, margin); } | |
29120 | inline qreal topMargin() const | |
29121 | { return doubleProperty(BlockTopMargin); } | |
29122 | inline void setBottomMargin(qreal margin) | |
29123 | { setProperty(BlockBottomMargin, margin); } | |
29124 | inline qreal bottomMargin() const | |
29125 | { return doubleProperty(BlockBottomMargin); } | |
29126 | inline void setLeftMargin(qreal margin) | |
29127 | { setProperty(BlockLeftMargin, margin); } | |
29128 | inline qreal leftMargin() const | |
29129 | { return doubleProperty(BlockLeftMargin); } | |
29130 | inline void setRightMargin(qreal margin) | |
29131 | { setProperty(BlockRightMargin, margin); } | |
29132 | inline qreal rightMargin() const | |
29133 | { return doubleProperty(BlockRightMargin); } | |
29134 | inline void setTextIndent(qreal aindent) | |
29135 | { setProperty(TextIndent, aindent); } | |
29136 | inline qreal textIndent() const | |
29137 | { return doubleProperty(TextIndent); } | |
29138 | inline void setIndent(int indent); | |
29139 | inline int indent() const | |
29140 | { return intProperty(BlockIndent); } | |
29141 | inline void setNonBreakableLines(bool b) | |
29142 | { setProperty(BlockNonBreakableLines, b); } | |
29143 | inline bool nonBreakableLines() const | |
29144 | { return boolProperty(BlockNonBreakableLines); } | |
29145 | inline void setPageBreakPolicy(PageBreakFlags flags) | |
29146 | { setProperty(PageBreakPolicy, int(flags)); } | |
29147 | inline PageBreakFlags pageBreakPolicy() const | |
29148 | { return PageBreakFlags(intProperty(PageBreakPolicy)); } | |
29149 | void setTabPositions(const QList<QTextOption::Tab> &tabs); | |
29150 | QList<QTextOption::Tab> tabPositions() const; | |
29151 | protected: | |
29152 | explicit QTextBlockFormat(const QTextFormat &fmt); | |
29153 | friend class QTextFormat; | |
29154 | }; | |
29155 | inline void QTextBlockFormat::setAlignment(Qt::Alignment aalignment) | |
29156 | { setProperty(BlockAlignment, int(aalignment)); } | |
29157 | inline void QTextBlockFormat::setIndent(int aindent) | |
29158 | { setProperty(BlockIndent, aindent); } | |
29159 | class __attribute__((visibility("default"))) QTextListFormat : public QTextFormat | |
29160 | { | |
29161 | public: | |
29162 | QTextListFormat(); | |
29163 | bool isValid() const { return isListFormat(); } | |
29164 | enum Style { | |
29165 | ListDisc = -1, | |
29166 | ListCircle = -2, | |
29167 | ListSquare = -3, | |
29168 | ListDecimal = -4, | |
29169 | ListLowerAlpha = -5, | |
29170 | ListUpperAlpha = -6, | |
29171 | ListStyleUndefined = 0 | |
29172 | }; | |
29173 | inline void setStyle(Style style); | |
29174 | inline Style style() const | |
29175 | { return static_cast<Style>(intProperty(ListStyle)); } | |
29176 | inline void setIndent(int indent); | |
29177 | inline int indent() const | |
29178 | { return intProperty(ListIndent); } | |
29179 | protected: | |
29180 | explicit QTextListFormat(const QTextFormat &fmt); | |
29181 | friend class QTextFormat; | |
29182 | }; | |
29183 | inline void QTextListFormat::setStyle(Style astyle) | |
29184 | { setProperty(ListStyle, astyle); } | |
29185 | inline void QTextListFormat::setIndent(int aindent) | |
29186 | { setProperty(ListIndent, aindent); } | |
29187 | class __attribute__((visibility("default"))) QTextImageFormat : public QTextCharFormat | |
29188 | { | |
29189 | public: | |
29190 | QTextImageFormat(); | |
29191 | bool isValid() const { return isImageFormat(); } | |
29192 | inline void setName(const QString &name); | |
29193 | inline QString name() const | |
29194 | { return stringProperty(ImageName); } | |
29195 | inline void setWidth(qreal width); | |
29196 | inline qreal width() const | |
29197 | { return doubleProperty(ImageWidth); } | |
29198 | inline void setHeight(qreal height); | |
29199 | inline qreal height() const | |
29200 | { return doubleProperty(ImageHeight); } | |
29201 | protected: | |
29202 | explicit QTextImageFormat(const QTextFormat &format); | |
29203 | friend class QTextFormat; | |
29204 | }; | |
29205 | inline void QTextImageFormat::setName(const QString &aname) | |
29206 | { setProperty(ImageName, aname); } | |
29207 | inline void QTextImageFormat::setWidth(qreal awidth) | |
29208 | { setProperty(ImageWidth, awidth); } | |
29209 | inline void QTextImageFormat::setHeight(qreal aheight) | |
29210 | { setProperty(ImageHeight, aheight); } | |
29211 | class __attribute__((visibility("default"))) QTextFrameFormat : public QTextFormat | |
29212 | { | |
29213 | public: | |
29214 | QTextFrameFormat(); | |
29215 | bool isValid() const { return isFrameFormat(); } | |
29216 | enum Position { | |
29217 | InFlow, | |
29218 | FloatLeft, | |
29219 | FloatRight | |
29220 | }; | |
29221 | enum BorderStyle { | |
29222 | BorderStyle_None, | |
29223 | BorderStyle_Dotted, | |
29224 | BorderStyle_Dashed, | |
29225 | BorderStyle_Solid, | |
29226 | BorderStyle_Double, | |
29227 | BorderStyle_DotDash, | |
29228 | BorderStyle_DotDotDash, | |
29229 | BorderStyle_Groove, | |
29230 | BorderStyle_Ridge, | |
29231 | BorderStyle_Inset, | |
29232 | BorderStyle_Outset | |
29233 | }; | |
29234 | inline void setPosition(Position f) | |
29235 | { setProperty(CssFloat, f); } | |
29236 | inline Position position() const | |
29237 | { return static_cast<Position>(intProperty(CssFloat)); } | |
29238 | inline void setBorder(qreal border); | |
29239 | inline qreal border() const | |
29240 | { return doubleProperty(FrameBorder); } | |
29241 | inline void setBorderBrush(const QBrush &brush) | |
29242 | { setProperty(FrameBorderBrush, brush); } | |
29243 | inline QBrush borderBrush() const | |
29244 | { return brushProperty(FrameBorderBrush); } | |
29245 | inline void setBorderStyle(BorderStyle style) | |
29246 | { setProperty(FrameBorderStyle, style); } | |
29247 | inline BorderStyle borderStyle() const | |
29248 | { return static_cast<BorderStyle>(intProperty(FrameBorderStyle)); } | |
29249 | void setMargin(qreal margin); | |
29250 | inline qreal margin() const | |
29251 | { return doubleProperty(FrameMargin); } | |
29252 | inline void setTopMargin(qreal margin); | |
29253 | qreal topMargin() const; | |
29254 | inline void setBottomMargin(qreal margin); | |
29255 | qreal bottomMargin() const; | |
29256 | inline void setLeftMargin(qreal margin); | |
29257 | qreal leftMargin() const; | |
29258 | inline void setRightMargin(qreal margin); | |
29259 | qreal rightMargin() const; | |
29260 | inline void setPadding(qreal padding); | |
29261 | inline qreal padding() const | |
29262 | { return doubleProperty(FramePadding); } | |
29263 | inline void setWidth(qreal width); | |
29264 | inline void setWidth(const QTextLength &length) | |
29265 | { setProperty(FrameWidth, length); } | |
29266 | inline QTextLength width() const | |
29267 | { return lengthProperty(FrameWidth); } | |
29268 | inline void setHeight(qreal height); | |
29269 | inline void setHeight(const QTextLength &height); | |
29270 | inline QTextLength height() const | |
29271 | { return lengthProperty(FrameHeight); } | |
29272 | inline void setPageBreakPolicy(PageBreakFlags flags) | |
29273 | { setProperty(PageBreakPolicy, int(flags)); } | |
29274 | inline PageBreakFlags pageBreakPolicy() const | |
29275 | { return PageBreakFlags(intProperty(PageBreakPolicy)); } | |
29276 | protected: | |
29277 | explicit QTextFrameFormat(const QTextFormat &fmt); | |
29278 | friend class QTextFormat; | |
29279 | }; | |
29280 | inline void QTextFrameFormat::setBorder(qreal aborder) | |
29281 | { setProperty(FrameBorder, aborder); } | |
29282 | inline void QTextFrameFormat::setPadding(qreal apadding) | |
29283 | { setProperty(FramePadding, apadding); } | |
29284 | inline void QTextFrameFormat::setWidth(qreal awidth) | |
29285 | { setProperty(FrameWidth, QTextLength(QTextLength::FixedLength, awidth)); } | |
29286 | inline void QTextFrameFormat::setHeight(qreal aheight) | |
29287 | { setProperty(FrameHeight, QTextLength(QTextLength::FixedLength, aheight)); } | |
29288 | inline void QTextFrameFormat::setHeight(const QTextLength &aheight) | |
29289 | { setProperty(FrameHeight, aheight); } | |
29290 | inline void QTextFrameFormat::setTopMargin(qreal amargin) | |
29291 | { setProperty(FrameTopMargin, amargin); } | |
29292 | inline void QTextFrameFormat::setBottomMargin(qreal amargin) | |
29293 | { setProperty(FrameBottomMargin, amargin); } | |
29294 | inline void QTextFrameFormat::setLeftMargin(qreal amargin) | |
29295 | { setProperty(FrameLeftMargin, amargin); } | |
29296 | inline void QTextFrameFormat::setRightMargin(qreal amargin) | |
29297 | { setProperty(FrameRightMargin, amargin); } | |
29298 | class __attribute__((visibility("default"))) QTextTableFormat : public QTextFrameFormat | |
29299 | { | |
29300 | public: | |
29301 | QTextTableFormat(); | |
29302 | inline bool isValid() const { return isTableFormat(); } | |
29303 | inline int columns() const | |
29304 | { int cols = intProperty(TableColumns); if (cols == 0) cols = 1; return cols; } | |
29305 | inline void setColumns(int columns); | |
29306 | inline void setColumnWidthConstraints(const QVector<QTextLength> &constraints) | |
29307 | { setProperty(TableColumnWidthConstraints, constraints); } | |
29308 | inline QVector<QTextLength> columnWidthConstraints() const | |
29309 | { return lengthVectorProperty(TableColumnWidthConstraints); } | |
29310 | inline void clearColumnWidthConstraints() | |
29311 | { clearProperty(TableColumnWidthConstraints); } | |
29312 | inline qreal cellSpacing() const | |
29313 | { return doubleProperty(TableCellSpacing); } | |
29314 | inline void setCellSpacing(qreal spacing) | |
29315 | { setProperty(TableCellSpacing, spacing); } | |
29316 | inline qreal cellPadding() const | |
29317 | { return doubleProperty(TableCellPadding); } | |
29318 | inline void setCellPadding(qreal padding); | |
29319 | inline void setAlignment(Qt::Alignment alignment); | |
29320 | inline Qt::Alignment alignment() const | |
29321 | { return QFlag(intProperty(BlockAlignment)); } | |
29322 | inline void setHeaderRowCount(int count) | |
29323 | { setProperty(TableHeaderRowCount, count); } | |
29324 | inline int headerRowCount() const | |
29325 | { return intProperty(TableHeaderRowCount); } | |
29326 | protected: | |
29327 | explicit QTextTableFormat(const QTextFormat &fmt); | |
29328 | friend class QTextFormat; | |
29329 | }; | |
29330 | inline void QTextTableFormat::setColumns(int acolumns) | |
29331 | { | |
29332 | if (acolumns == 1) | |
29333 | acolumns = 0; | |
29334 | setProperty(TableColumns, acolumns); | |
29335 | } | |
29336 | inline void QTextTableFormat::setCellPadding(qreal apadding) | |
29337 | { setProperty(TableCellPadding, apadding); } | |
29338 | inline void QTextTableFormat::setAlignment(Qt::Alignment aalignment) | |
29339 | { setProperty(BlockAlignment, int(aalignment)); } | |
29340 | class __attribute__((visibility("default"))) QTextTableCellFormat : public QTextCharFormat | |
29341 | { | |
29342 | public: | |
29343 | QTextTableCellFormat(); | |
29344 | inline bool isValid() const { return isTableCellFormat(); } | |
29345 | inline void setTopPadding(qreal padding); | |
29346 | inline qreal topPadding() const; | |
29347 | inline void setBottomPadding(qreal padding); | |
29348 | inline qreal bottomPadding() const; | |
29349 | inline void setLeftPadding(qreal padding); | |
29350 | inline qreal leftPadding() const; | |
29351 | inline void setRightPadding(qreal padding); | |
29352 | inline qreal rightPadding() const; | |
29353 | inline void setPadding(qreal padding); | |
29354 | protected: | |
29355 | explicit QTextTableCellFormat(const QTextFormat &fmt); | |
29356 | friend class QTextFormat; | |
29357 | }; | |
29358 | inline void QTextTableCellFormat::setTopPadding(qreal padding) | |
29359 | { | |
29360 | setProperty(TableCellTopPadding, padding); | |
29361 | } | |
29362 | inline qreal QTextTableCellFormat::topPadding() const | |
29363 | { | |
29364 | return doubleProperty(TableCellTopPadding); | |
29365 | } | |
29366 | inline void QTextTableCellFormat::setBottomPadding(qreal padding) | |
29367 | { | |
29368 | setProperty(TableCellBottomPadding, padding); | |
29369 | } | |
29370 | inline qreal QTextTableCellFormat::bottomPadding() const | |
29371 | { | |
29372 | return doubleProperty(TableCellBottomPadding); | |
29373 | } | |
29374 | inline void QTextTableCellFormat::setLeftPadding(qreal padding) | |
29375 | { | |
29376 | setProperty(TableCellLeftPadding, padding); | |
29377 | } | |
29378 | inline qreal QTextTableCellFormat::leftPadding() const | |
29379 | { | |
29380 | return doubleProperty(TableCellLeftPadding); | |
29381 | } | |
29382 | inline void QTextTableCellFormat::setRightPadding(qreal padding) | |
29383 | { | |
29384 | setProperty(TableCellRightPadding, padding); | |
29385 | } | |
29386 | inline qreal QTextTableCellFormat::rightPadding() const | |
29387 | { | |
29388 | return doubleProperty(TableCellRightPadding); | |
29389 | } | |
29390 | inline void QTextTableCellFormat::setPadding(qreal padding) | |
29391 | { | |
29392 | setTopPadding(padding); | |
29393 | setBottomPadding(padding); | |
29394 | setLeftPadding(padding); | |
29395 | setRightPadding(padding); | |
29396 | } | |
29397 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
29398 | class QTextEngine; | |
29399 | class QFont; | |
29400 | class QRect; | |
29401 | class QRegion; | |
29402 | class QTextFormat; | |
29403 | class QPalette; | |
29404 | class QPainter; | |
29405 | class __attribute__((visibility("default"))) QTextInlineObject | |
29406 | { | |
29407 | public: | |
29408 | QTextInlineObject(int i, QTextEngine *e) : itm(i), eng(e) {} | |
29409 | inline QTextInlineObject() : itm(0), eng(0) {} | |
29410 | inline bool isValid() const { return eng; } | |
29411 | QRectF rect() const; | |
29412 | qreal width() const; | |
29413 | qreal ascent() const; | |
29414 | qreal descent() const; | |
29415 | qreal height() const; | |
29416 | Qt::LayoutDirection textDirection() const; | |
29417 | void setWidth(qreal w); | |
29418 | void setAscent(qreal a); | |
29419 | void setDescent(qreal d); | |
29420 | int textPosition() const; | |
29421 | int formatIndex() const; | |
29422 | QTextFormat format() const; | |
29423 | private: | |
29424 | friend class QTextLayout; | |
29425 | int itm; | |
29426 | QTextEngine *eng; | |
29427 | }; | |
29428 | class QPaintDevice; | |
29429 | class QTextFormat; | |
29430 | class QTextLine; | |
29431 | class QTextBlock; | |
29432 | class QTextOption; | |
29433 | class __attribute__((visibility("default"))) QTextLayout | |
29434 | { | |
29435 | public: | |
29436 | QTextLayout(); | |
29437 | QTextLayout(const QString& text); | |
29438 | QTextLayout(const QString& text, const QFont &font, QPaintDevice *paintdevice = 0); | |
29439 | QTextLayout(const QTextBlock &b); | |
29440 | ~QTextLayout(); | |
29441 | void setFont(const QFont &f); | |
29442 | QFont font() const; | |
29443 | void setText(const QString& string); | |
29444 | QString text() const; | |
29445 | void setTextOption(const QTextOption &option); | |
29446 | QTextOption textOption() const; | |
29447 | void setPreeditArea(int position, const QString &text); | |
29448 | int preeditAreaPosition() const; | |
29449 | QString preeditAreaText() const; | |
29450 | struct FormatRange { | |
29451 | int start; | |
29452 | int length; | |
29453 | QTextCharFormat format; | |
29454 | }; | |
29455 | void setAdditionalFormats(const QList<FormatRange> &overrides); | |
29456 | QList<FormatRange> additionalFormats() const; | |
29457 | void clearAdditionalFormats(); | |
29458 | void setCacheEnabled(bool enable); | |
29459 | bool cacheEnabled() const; | |
29460 | void beginLayout(); | |
29461 | void endLayout(); | |
29462 | void clearLayout(); | |
29463 | QTextLine createLine(); | |
29464 | int lineCount() const; | |
29465 | QTextLine lineAt(int i) const; | |
29466 | QTextLine lineForTextPosition(int pos) const; | |
29467 | enum CursorMode { | |
29468 | SkipCharacters, | |
29469 | SkipWords | |
29470 | }; | |
29471 | bool isValidCursorPosition(int pos) const; | |
29472 | int nextCursorPosition(int oldPos, CursorMode mode = SkipCharacters) const; | |
29473 | int previousCursorPosition(int oldPos, CursorMode mode = SkipCharacters) const; | |
29474 | void draw(QPainter *p, const QPointF &pos, const QVector<FormatRange> &selections = QVector<FormatRange>(), | |
29475 | const QRectF &clip = QRectF()) const; | |
29476 | void drawCursor(QPainter *p, const QPointF &pos, int cursorPosition) const; | |
29477 | void drawCursor(QPainter *p, const QPointF &pos, int cursorPosition, int width) const; | |
29478 | QPointF position() const; | |
29479 | void setPosition(const QPointF &p); | |
29480 | QRectF boundingRect() const; | |
29481 | qreal minimumWidth() const; | |
29482 | qreal maximumWidth() const; | |
29483 | QTextEngine *engine() const { return d; } | |
29484 | void setFlags(int flags); | |
29485 | private: | |
29486 | QTextLayout(QTextEngine *e) : d(e) {} | |
29487 | QTextLayout(const QTextLayout &); QTextLayout &operator=(const QTextLayout &); | |
29488 | friend class QPainter; | |
29489 | friend class QPSPrinter; | |
29490 | friend class QGraphicsSimpleTextItemPrivate; | |
29491 | friend class QGraphicsSimpleTextItem; | |
29492 | friend void qt_format_text(const QFont &font, const QRectF &_r, int tf, const QTextOption *, const QString& str, | |
29493 | QRectF *brect, int tabstops, int* tabarray, int tabarraylen, | |
29494 | QPainter *painter); | |
29495 | QTextEngine *d; | |
29496 | }; | |
29497 | class __attribute__((visibility("default"))) QTextLine | |
29498 | { | |
29499 | public: | |
29500 | inline QTextLine() : i(0), eng(0) {} | |
29501 | inline bool isValid() const { return eng; } | |
29502 | QRectF rect() const; | |
29503 | qreal x() const; | |
29504 | qreal y() const; | |
29505 | qreal width() const; | |
29506 | qreal ascent() const; | |
29507 | qreal descent() const; | |
29508 | qreal height() const; | |
29509 | qreal naturalTextWidth() const; | |
29510 | QRectF naturalTextRect() const; | |
29511 | enum Edge { | |
29512 | Leading, | |
29513 | Trailing | |
29514 | }; | |
29515 | enum CursorPosition { | |
29516 | CursorBetweenCharacters, | |
29517 | CursorOnCharacter | |
29518 | }; | |
29519 | qreal cursorToX(int *cursorPos, Edge edge = Leading) const; | |
29520 | inline qreal cursorToX(int cursorPos, Edge edge = Leading) const { return cursorToX(&cursorPos, edge); } | |
29521 | int xToCursor(qreal x, CursorPosition = CursorBetweenCharacters) const; | |
29522 | void setLineWidth(qreal width); | |
29523 | void setNumColumns(int columns); | |
29524 | void setNumColumns(int columns, qreal alignmentWidth); | |
29525 | void setPosition(const QPointF &pos); | |
29526 | QPointF position() const; | |
29527 | int textStart() const; | |
29528 | int textLength() const; | |
29529 | int lineNumber() const { return i; } | |
29530 | void draw(QPainter *p, const QPointF &point, const QTextLayout::FormatRange *selection = 0) const; | |
29531 | private: | |
29532 | QTextLine(int line, QTextEngine *e) : i(line), eng(e) {} | |
29533 | void layout_helper(int numGlyphs); | |
29534 | friend class QTextLayout; | |
29535 | int i; | |
29536 | QTextEngine *eng; | |
29537 | }; | |
29538 | class __attribute__((visibility("default"))) QTextFormatCollection | |
29539 | { | |
29540 | public: | |
29541 | QTextFormatCollection() {} | |
29542 | ~QTextFormatCollection(); | |
29543 | QTextFormatCollection(const QTextFormatCollection &rhs); | |
29544 | QTextFormatCollection &operator=(const QTextFormatCollection &rhs); | |
29545 | QTextFormat objectFormat(int objectIndex) const; | |
29546 | void setObjectFormat(int objectIndex, const QTextFormat &format); | |
29547 | int objectFormatIndex(int objectIndex) const; | |
29548 | void setObjectFormatIndex(int objectIndex, int formatIndex); | |
29549 | int createObjectIndex(const QTextFormat &f); | |
29550 | int indexForFormat(const QTextFormat &f); | |
29551 | bool hasFormatCached(const QTextFormat &format) const; | |
29552 | QTextFormat format(int idx) const; | |
29553 | inline QTextBlockFormat blockFormat(int index) const | |
29554 | { return format(index).toBlockFormat(); } | |
29555 | inline QTextCharFormat charFormat(int index) const | |
29556 | { return format(index).toCharFormat(); } | |
29557 | inline QTextListFormat listFormat(int index) const | |
29558 | { return format(index).toListFormat(); } | |
29559 | inline QTextTableFormat tableFormat(int index) const | |
29560 | { return format(index).toTableFormat(); } | |
29561 | inline QTextImageFormat imageFormat(int index) const | |
29562 | { return format(index).toImageFormat(); } | |
29563 | inline int numFormats() const { return formats.count(); } | |
29564 | typedef QVector<QTextFormat> FormatVector; | |
29565 | FormatVector formats; | |
29566 | QVector<qint32> objFormats; | |
29567 | QSet<uint> hashes; | |
29568 | inline QFont defaultFont() const { return defaultFnt; } | |
29569 | void setDefaultFont(const QFont &f); | |
29570 | private: | |
29571 | QFont defaultFnt; | |
29572 | }; | |
29573 | namespace QUnicodeTables { | |
29574 | struct Properties { | |
29575 | ushort category : 8; | |
29576 | ushort line_break_class : 8; | |
29577 | ushort direction : 8; | |
29578 | ushort combiningClass :8; | |
29579 | ushort joining : 2; | |
29580 | signed short digitValue : 6; | |
29581 | ushort unicodeVersion : 4; | |
29582 | ushort lowerCaseSpecial : 1; | |
29583 | ushort upperCaseSpecial : 1; | |
29584 | ushort titleCaseSpecial : 1; | |
29585 | ushort caseFoldSpecial : 1; | |
29586 | signed short mirrorDiff : 16; | |
29587 | signed short lowerCaseDiff : 16; | |
29588 | signed short upperCaseDiff : 16; | |
29589 | signed short titleCaseDiff : 16; | |
29590 | signed short caseFoldDiff : 16; | |
29591 | ushort graphemeBreak : 8; | |
29592 | ushort wordBreak : 8; | |
29593 | ushort sentenceBreak : 8; | |
29594 | }; | |
29595 | __attribute__((visibility("default"))) const Properties* properties(uint ucs4); | |
29596 | __attribute__((visibility("default"))) const Properties* properties(ushort ucs2); | |
29597 | enum Script { | |
29598 | Common, | |
29599 | Greek, | |
29600 | Cyrillic, | |
29601 | Armenian, | |
29602 | Hebrew, | |
29603 | Arabic, | |
29604 | Syriac, | |
29605 | Thaana, | |
29606 | Devanagari, | |
29607 | Bengali, | |
29608 | Gurmukhi, | |
29609 | Gujarati, | |
29610 | Oriya, | |
29611 | Tamil, | |
29612 | Telugu, | |
29613 | Kannada, | |
29614 | Malayalam, | |
29615 | Sinhala, | |
29616 | Thai, | |
29617 | Lao, | |
29618 | Tibetan, | |
29619 | Myanmar, | |
29620 | Georgian, | |
29621 | Hangul, | |
29622 | Ogham, | |
29623 | Runic, | |
29624 | Khmer, | |
29625 | Inherited, | |
29626 | ScriptCount = Inherited, | |
29627 | Latin = Common, | |
29628 | Ethiopic = Common, | |
29629 | Cherokee = Common, | |
29630 | CanadianAboriginal = Common, | |
29631 | Mongolian = Common, | |
29632 | Hiragana = Common, | |
29633 | Katakana = Common, | |
29634 | Bopomofo = Common, | |
29635 | Han = Common, | |
29636 | Yi = Common, | |
29637 | OldItalic = Common, | |
29638 | Gothic = Common, | |
29639 | Deseret = Common, | |
29640 | Tagalog = Common, | |
29641 | Hanunoo = Common, | |
29642 | Buhid = Common, | |
29643 | Tagbanwa = Common, | |
29644 | Limbu = Common, | |
29645 | TaiLe = Common, | |
29646 | LinearB = Common, | |
29647 | Ugaritic = Common, | |
29648 | Shavian = Common, | |
29649 | Osmanya = Common, | |
29650 | Cypriot = Common, | |
29651 | Braille = Common, | |
29652 | Buginese = Common, | |
29653 | Coptic = Common, | |
29654 | NewTaiLue = Common, | |
29655 | Glagolitic = Common, | |
29656 | Tifinagh = Common, | |
29657 | SylotiNagri = Common, | |
29658 | OldPersian = Common, | |
29659 | Kharoshthi = Common, | |
29660 | Balinese = Common, | |
29661 | Cuneiform = Common, | |
29662 | Phoenician = Common, | |
29663 | PhagsPa = Common, | |
29664 | Nko = Common | |
29665 | }; | |
29666 | enum { ScriptSentinel = 32 }; | |
29667 | enum LineBreakClass { | |
29668 | LineBreak_OP, LineBreak_CL, LineBreak_QU, LineBreak_GL, LineBreak_NS, | |
29669 | LineBreak_EX, LineBreak_SY, LineBreak_IS, LineBreak_PR, LineBreak_PO, | |
29670 | LineBreak_NU, LineBreak_AL, LineBreak_ID, LineBreak_IN, LineBreak_HY, | |
29671 | LineBreak_BA, LineBreak_BB, LineBreak_B2, LineBreak_ZW, LineBreak_CM, | |
29672 | LineBreak_WJ, LineBreak_H2, LineBreak_H3, LineBreak_JL, LineBreak_JV, | |
29673 | LineBreak_JT, LineBreak_SA, LineBreak_SG, | |
29674 | LineBreak_SP, LineBreak_CR, LineBreak_LF, LineBreak_BK | |
29675 | }; | |
29676 | __attribute__((visibility("default"))) QUnicodeTables::LineBreakClass lineBreakClass(uint ucs4); | |
29677 | inline int lineBreakClass(const QChar &ch) { | |
29678 | return QUnicodeTables::lineBreakClass(ch.unicode()); | |
29679 | } | |
29680 | __attribute__((visibility("default"))) int script(uint ucs4); | |
29681 | __attribute__((visibility("default"))) inline int script(const QChar &ch) { | |
29682 | return script(ch.unicode()); | |
29683 | } | |
29684 | enum GraphemeBreak { | |
29685 | GraphemeBreakOther, | |
29686 | GraphemeBreakCR, | |
29687 | GraphemeBreakLF, | |
29688 | GraphemeBreakControl, | |
29689 | GraphemeBreakExtend, | |
29690 | GraphemeBreakL, | |
29691 | GraphemeBreakV, | |
29692 | GraphemeBreakT, | |
29693 | GraphemeBreakLV, | |
29694 | GraphemeBreakLVT | |
29695 | }; | |
29696 | enum WordBreak { | |
29697 | WordBreakOther, | |
29698 | WordBreakFormat, | |
29699 | WordBreakKatakana, | |
29700 | WordBreakALetter, | |
29701 | WordBreakMidLetter, | |
29702 | WordBreakMidNum, | |
29703 | WordBreakNumeric, | |
29704 | WordBreakExtendNumLet | |
29705 | }; | |
29706 | enum SentenceBreak { | |
29707 | SentenceBreakOther, | |
29708 | SentenceBreakSep, | |
29709 | SentenceBreakFormat, | |
29710 | SentenceBreakSp, | |
29711 | SentenceBreakLower, | |
29712 | SentenceBreakUpper, | |
29713 | SentenceBreakOLetter, | |
29714 | SentenceBreakNumeric, | |
29715 | SentenceBreakATerm, | |
29716 | SentenceBreakSTerm, | |
29717 | SentenceBreakClose | |
29718 | }; | |
29719 | } | |
29720 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
29721 | class QStringList; | |
29722 | template <class T> class QList; | |
29723 | struct QFontDef; | |
29724 | class QFontEngine; | |
29725 | class QFontDatabasePrivate; | |
29726 | class __attribute__((visibility("default"))) QFontDatabase | |
29727 | { | |
29728 | public: static const QMetaObject staticMetaObject; private: | |
29729 | public: | |
29730 | enum WritingSystem { | |
29731 | Any, | |
29732 | Latin, | |
29733 | Greek, | |
29734 | Cyrillic, | |
29735 | Armenian, | |
29736 | Hebrew, | |
29737 | Arabic, | |
29738 | Syriac, | |
29739 | Thaana, | |
29740 | Devanagari, | |
29741 | Bengali, | |
29742 | Gurmukhi, | |
29743 | Gujarati, | |
29744 | Oriya, | |
29745 | Tamil, | |
29746 | Telugu, | |
29747 | Kannada, | |
29748 | Malayalam, | |
29749 | Sinhala, | |
29750 | Thai, | |
29751 | Lao, | |
29752 | Tibetan, | |
29753 | Myanmar, | |
29754 | Georgian, | |
29755 | Khmer, | |
29756 | SimplifiedChinese, | |
29757 | TraditionalChinese, | |
29758 | Japanese, | |
29759 | Korean, | |
29760 | Vietnamese, | |
29761 | Symbol, | |
29762 | Other = Symbol, | |
29763 | Ogham, | |
29764 | Runic, | |
29765 | WritingSystemsCount | |
29766 | }; | |
29767 | static QList<int> standardSizes(); | |
29768 | QFontDatabase(); | |
29769 | QList<WritingSystem> writingSystems() const; | |
29770 | QList<WritingSystem> writingSystems(const QString &family) const; | |
29771 | QStringList families(WritingSystem writingSystem = Any) const; | |
29772 | QStringList styles(const QString &family) const; | |
29773 | QList<int> pointSizes(const QString &family, const QString &style = QString()); | |
29774 | QList<int> smoothSizes(const QString &family, const QString &style); | |
29775 | QString styleString(const QFont &font); | |
29776 | QString styleString(const QFontInfo &fontInfo); | |
29777 | QFont font(const QString &family, const QString &style, int pointSize) const; | |
29778 | bool isBitmapScalable(const QString &family, const QString &style = QString()) const; | |
29779 | bool isSmoothlyScalable(const QString &family, const QString &style = QString()) const; | |
29780 | bool isScalable(const QString &family, const QString &style = QString()) const; | |
29781 | bool isFixedPitch(const QString &family, const QString &style = QString()) const; | |
29782 | bool italic(const QString &family, const QString &style) const; | |
29783 | bool bold(const QString &family, const QString &style) const; | |
29784 | int weight(const QString &family, const QString &style) const; | |
29785 | static QString writingSystemName(WritingSystem writingSystem); | |
29786 | static QString writingSystemSample(WritingSystem writingSystem); | |
29787 | static int addApplicationFont(const QString &fileName); | |
29788 | static int addApplicationFontFromData(const QByteArray &fontData); | |
29789 | static QStringList applicationFontFamilies(int id); | |
29790 | static bool removeApplicationFont(int id); | |
29791 | static bool removeAllApplicationFonts(); | |
29792 | static bool supportsThreadedFontRendering(); | |
29793 | private: | |
29794 | static void createDatabase(); | |
29795 | static void parseFontName(const QString &name, QString &foundry, QString &family); | |
29796 | static QFontEngine *findFont(int script, const QFontPrivate *fp, const QFontDef &request); | |
29797 | static void load(const QFontPrivate *d, int script); | |
29798 | friend struct QFontDef; | |
29799 | friend class QFontPrivate; | |
29800 | friend class QFontDialog; | |
29801 | friend class QFontDialogPrivate; | |
29802 | friend class QFontEngineMultiXLFD; | |
29803 | friend class QFontEngineMultiQWS; | |
29804 | QFontDatabasePrivate *d; | |
29805 | }; | |
29806 | struct QFixed { | |
29807 | public: | |
29808 | QFixed() : val(0) {} | |
29809 | QFixed(int i) : val(i<<6) {} | |
29810 | QFixed(long i) : val(i<<6) {} | |
29811 | QFixed &operator=(int i) { val = (i<<6); return *this; } | |
29812 | QFixed &operator=(long i) { val = (i<<6); return *this; } | |
29813 | static QFixed fromReal(qreal r) { QFixed f; f.val = (int)(r*qreal(64)); return f; } | |
29814 | static QFixed fromFixed(int fixed) { QFixed f; f.val = fixed; return f; } | |
29815 | inline int value() const { return val; } | |
29816 | inline void setValue(int value) { val = value; } | |
29817 | inline int toInt() const { return (((val)+32) & -64)>>6; } | |
29818 | inline qreal toReal() const { return ((qreal)val)/(qreal)64; } | |
29819 | inline int truncate() const { return val>>6; } | |
29820 | inline QFixed round() const { QFixed f; f.val = ((val)+32) & -64; return f; } | |
29821 | inline QFixed floor() const { QFixed f; f.val = (val) & -64; return f; } | |
29822 | inline QFixed ceil() const { QFixed f; f.val = (val+63) & -64; return f; } | |
29823 | inline QFixed operator+(int i) const { QFixed f; f.val = (val + (i<<6)); return f; } | |
29824 | inline QFixed operator+(uint i) const { QFixed f; f.val = (val + (i<<6)); return f; } | |
29825 | inline QFixed operator+(const QFixed &other) const { QFixed f; f.val = (val + other.val); return f; } | |
29826 | inline QFixed &operator+=(int i) { val += (i<<6); return *this; } | |
29827 | inline QFixed &operator+=(uint i) { val += (i<<6); return *this; } | |
29828 | inline QFixed &operator+=(const QFixed &other) { val += other.val; return *this; } | |
29829 | inline QFixed operator-(int i) const { QFixed f; f.val = (val - (i<<6)); return f; } | |
29830 | inline QFixed operator-(uint i) const { QFixed f; f.val = (val - (i<<6)); return f; } | |
29831 | inline QFixed operator-(const QFixed &other) const { QFixed f; f.val = (val - other.val); return f; } | |
29832 | inline QFixed &operator-=(int i) { val -= (i<<6); return *this; } | |
29833 | inline QFixed &operator-=(uint i) { val -= (i<<6); return *this; } | |
29834 | inline QFixed &operator-=(const QFixed &other) { val -= other.val; return *this; } | |
29835 | inline QFixed operator-() const { QFixed f; f.val = -val; return f; } | |
29836 | inline bool operator==(const QFixed &other) const { return val == other.val; } | |
29837 | inline bool operator!=(const QFixed &other) const { return val != other.val; } | |
29838 | inline bool operator<(const QFixed &other) const { return val < other.val; } | |
29839 | inline bool operator>(const QFixed &other) const { return val > other.val; } | |
29840 | inline bool operator<=(const QFixed &other) const { return val <= other.val; } | |
29841 | inline bool operator>=(const QFixed &other) const { return val >= other.val; } | |
29842 | inline bool operator!() const { return !val; } | |
29843 | inline QFixed &operator/=(int x) { val /= x; return *this; } | |
29844 | inline QFixed &operator/=(const QFixed &o) { | |
29845 | if (o.val == 0) { | |
29846 | val = 0x7FFFFFFFL; | |
29847 | } else { | |
29848 | bool neg = false; | |
29849 | qint64 a = val; | |
29850 | qint64 b = o.val; | |
29851 | if (a < 0) { a = -a; neg = true; } | |
29852 | if (b < 0) { b = -b; neg = !neg; } | |
29853 | int res = (int)(((a << 6) + (b >> 1)) / b); | |
29854 | val = (neg ? -res : res); | |
29855 | } | |
29856 | return *this; | |
29857 | } | |
29858 | inline QFixed operator/(int d) const { QFixed f; f.val = val/d; return f; } | |
29859 | inline QFixed operator/(QFixed b) const { QFixed f = *this; return (f /= b); } | |
29860 | inline QFixed operator>>(int d) const { QFixed f = *this; f.val >>= d; return f; } | |
29861 | inline QFixed &operator*=(int i) { val *= i; return *this; } | |
29862 | inline QFixed &operator*=(uint i) { val *= i; return *this; } | |
29863 | inline QFixed &operator*=(const QFixed &o) { | |
29864 | bool neg = false; | |
29865 | qint64 a = val; | |
29866 | qint64 b = o.val; | |
29867 | if (a < 0) { a = -a; neg = true; } | |
29868 | if (b < 0) { b = -b; neg = !neg; } | |
29869 | int res = (int)((a * b + 0x20L) >> 6); | |
29870 | val = neg ? -res : res; | |
29871 | return *this; | |
29872 | } | |
29873 | inline QFixed operator*(int i) const { QFixed f = *this; return (f *= i); } | |
29874 | inline QFixed operator*(uint i) const { QFixed f = *this; return (f *= i); } | |
29875 | inline QFixed operator*(const QFixed &o) const { QFixed f = *this; return (f *= o); } | |
29876 | private: | |
29877 | QFixed(qreal i) : val((int)(i*qreal(64))) {} | |
29878 | QFixed &operator=(qreal i) { val = (int)(i*qreal(64)); return *this; } | |
29879 | inline QFixed operator+(qreal i) const { QFixed f; f.val = (val + (int)(i*qreal(64))); return f; } | |
29880 | inline QFixed &operator+=(qreal i) { val += (int)(i*64); return *this; } | |
29881 | inline QFixed operator-(qreal i) const { QFixed f; f.val = (val - (int)(i*qreal(64))); return f; } | |
29882 | inline QFixed &operator-=(qreal i) { val -= (int)(i*64); return *this; } | |
29883 | inline QFixed &operator/=(qreal r) { val = (int)(val/r); return *this; } | |
29884 | inline QFixed operator/(qreal d) const { QFixed f; f.val = (int)(val/d); return f; } | |
29885 | inline QFixed &operator*=(qreal d) { val = (int) (val*d); return *this; } | |
29886 | inline QFixed operator*(qreal d) const { QFixed f = *this; return (f *= d); } | |
29887 | int val; | |
29888 | }; | |
29889 | template <> class QTypeInfo<QFixed> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QFixed)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QFixed"; } }; | |
29890 | inline int qRound(const QFixed &f) { return f.toInt(); } | |
29891 | inline int qFloor(const QFixed &f) { return f.floor().truncate(); } | |
29892 | inline QFixed operator*(int i, const QFixed &d) { return d*i; } | |
29893 | inline QFixed operator+(int i, const QFixed &d) { return d+i; } | |
29894 | inline QFixed operator-(int i, const QFixed &d) { return -(d-i); } | |
29895 | inline QFixed operator*(uint i, const QFixed &d) { return d*i; } | |
29896 | inline QFixed operator+(uint i, const QFixed &d) { return d+i; } | |
29897 | inline QFixed operator-(uint i, const QFixed &d) { return -(d-i); } | |
29898 | inline bool operator==(const QFixed &f, int i) { return f.value() == (i<<6); } | |
29899 | inline bool operator==(int i, const QFixed &f) { return f.value() == (i<<6); } | |
29900 | inline bool operator!=(const QFixed &f, int i) { return f.value() != (i<<6); } | |
29901 | inline bool operator!=(int i, const QFixed &f) { return f.value() != (i<<6); } | |
29902 | inline bool operator<=(const QFixed &f, int i) { return f.value() <= (i<<6); } | |
29903 | inline bool operator<=(int i, const QFixed &f) { return (i<<6) <= f.value(); } | |
29904 | inline bool operator>=(const QFixed &f, int i) { return f.value() >= (i<<6); } | |
29905 | inline bool operator>=(int i, const QFixed &f) { return (i<<6) >= f.value(); } | |
29906 | inline bool operator<(const QFixed &f, int i) { return f.value() < (i<<6); } | |
29907 | inline bool operator<(int i, const QFixed &f) { return (i<<6) < f.value(); } | |
29908 | inline bool operator>(const QFixed &f, int i) { return f.value() > (i<<6); } | |
29909 | inline bool operator>(int i, const QFixed &f) { return (i<<6) > f.value(); } | |
29910 | inline QDebug &operator<<(QDebug &dbg, const QFixed &f) | |
29911 | { return dbg << f.toReal(); } | |
29912 | struct QFixedPoint { | |
29913 | QFixed x; | |
29914 | QFixed y; | |
29915 | inline QFixedPoint() {} | |
29916 | inline QFixedPoint(const QFixed &_x, const QFixed &_y) : x(_x), y(_y) {} | |
29917 | QPointF toPointF() const { return QPointF(x.toReal(), y.toReal()); } | |
29918 | static QFixedPoint fromPointF(const QPointF &p) { | |
29919 | return QFixedPoint(QFixed::fromReal(p.x()), QFixed::fromReal(p.y())); | |
29920 | } | |
29921 | }; | |
29922 | template <> class QTypeInfo<QFixedPoint> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QFixedPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QFixedPoint"; } }; | |
29923 | inline QFixedPoint operator-(const QFixedPoint &p1, const QFixedPoint &p2) | |
29924 | { return QFixedPoint(p1.x - p2.x, p1.y - p2.y); } | |
29925 | inline QFixedPoint operator+(const QFixedPoint &p1, const QFixedPoint &p2) | |
29926 | { return QFixedPoint(p1.x + p2.x, p1.y + p2.y); } | |
29927 | struct QFixedSize { | |
29928 | QFixed width; | |
29929 | QFixed height; | |
29930 | QSizeF toSizeF() const { return QSizeF(width.toReal(), height.toReal()); } | |
29931 | static QFixedSize fromSizeF(const QSizeF &s) { | |
29932 | QFixedSize size; | |
29933 | size.width = QFixed::fromReal(s.width()); | |
29934 | size.height = QFixed::fromReal(s.height()); | |
29935 | return size; | |
29936 | } | |
29937 | }; | |
29938 | template <> class QTypeInfo<QFixedSize> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QFixedSize)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QFixedSize"; } }; | |
29939 | class QFontCache; | |
29940 | class QFontEngine; | |
29941 | struct QFontDef | |
29942 | { | |
29943 | inline QFontDef() | |
29944 | : pointSize(-1.0), pixelSize(-1), | |
29945 | styleStrategy(QFont::PreferDefault), styleHint(QFont::AnyStyle), | |
29946 | weight(50), fixedPitch(false), style(QFont::StyleNormal), stretch(100), | |
29947 | ignorePitch(true) | |
29948 | { | |
29949 | } | |
29950 | QString family; | |
29951 | qreal pointSize; | |
29952 | int pixelSize; | |
29953 | uint styleStrategy : 16; | |
29954 | uint styleHint : 8; | |
29955 | uint weight : 7; | |
29956 | uint fixedPitch : 1; | |
29957 | uint style : 2; | |
29958 | uint stretch : 12; | |
29959 | uint ignorePitch : 1; | |
29960 | uint fixedPitchComputed : 1; | |
29961 | int reserved : 16; | |
29962 | bool exactMatch(const QFontDef &other) const; | |
29963 | bool operator==(const QFontDef &other) const | |
29964 | { | |
29965 | return pixelSize == other.pixelSize | |
29966 | && weight == other.weight | |
29967 | && style == other.style | |
29968 | && stretch == other.stretch | |
29969 | && styleHint == other.styleHint | |
29970 | && styleStrategy == other.styleStrategy | |
29971 | && ignorePitch == other.ignorePitch && fixedPitch == other.fixedPitch | |
29972 | && family == other.family | |
29973 | ; | |
29974 | } | |
29975 | inline bool operator<(const QFontDef &other) const | |
29976 | { | |
29977 | if (pixelSize != other.pixelSize) return pixelSize < other.pixelSize; | |
29978 | if (weight != other.weight) return weight < other.weight; | |
29979 | if (style != other.style) return style < other.style; | |
29980 | if (stretch != other.stretch) return stretch < other.stretch; | |
29981 | if (styleHint != other.styleHint) return styleHint < other.styleHint; | |
29982 | if (styleStrategy != other.styleStrategy) return styleStrategy < other.styleStrategy; | |
29983 | if (family != other.family) return family < other.family; | |
29984 | if (ignorePitch != other.ignorePitch) return ignorePitch < other.ignorePitch; | |
29985 | if (fixedPitch != other.fixedPitch) return fixedPitch < other.fixedPitch; | |
29986 | return false; | |
29987 | } | |
29988 | }; | |
29989 | class QFontEngineData | |
29990 | { | |
29991 | public: | |
29992 | QFontEngineData(); | |
29993 | ~QFontEngineData(); | |
29994 | QAtomicInt ref; | |
29995 | QFontCache *fontCache; | |
29996 | QFontEngine *engines[QUnicodeTables::ScriptCount]; | |
29997 | }; | |
29998 | class __attribute__((visibility("default"))) QFontPrivate | |
29999 | { | |
30000 | public: | |
30001 | QFontPrivate(); | |
30002 | QFontPrivate(const QFontPrivate &other); | |
30003 | ~QFontPrivate(); | |
30004 | QFontEngine *engineForScript(int script) const; | |
30005 | void alterCharForCapitalization(QChar &c) const; | |
30006 | QAtomicInt ref; | |
30007 | QFontDef request; | |
30008 | mutable QFontEngineData *engineData; | |
30009 | int dpi; | |
30010 | int screen; | |
30011 | uint rawMode : 1; | |
30012 | uint underline : 1; | |
30013 | uint overline : 1; | |
30014 | uint strikeOut : 1; | |
30015 | uint kerning : 1; | |
30016 | uint capital : 3; | |
30017 | bool letterSpacingIsAbsolute : 1; | |
30018 | QFixed letterSpacing; | |
30019 | QFixed wordSpacing; | |
30020 | mutable QFontPrivate *scFont; | |
30021 | QFont smallCapsFont() const { return QFont(smallCapsFontPrivate()); } | |
30022 | QFontPrivate *smallCapsFontPrivate() const; | |
30023 | void resolve(uint mask, const QFontPrivate *other); | |
30024 | private: | |
30025 | QFontPrivate &operator=(const QFontPrivate &) { return *this; } | |
30026 | }; | |
30027 | class QFontCache : public QObject | |
30028 | { | |
30029 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
30030 | public: | |
30031 | static QFontCache *instance(); | |
30032 | static void cleanup(); | |
30033 | QFontCache(); | |
30034 | ~QFontCache(); | |
30035 | void clear(); | |
30036 | void removeEngineForFont(const QByteArray &fontName); | |
30037 | struct Key { | |
30038 | Key() : script(0), screen(0) { } | |
30039 | Key(const QFontDef &d, int c, int s = 0) | |
30040 | : def(d), script(c), screen(s) { } | |
30041 | QFontDef def; | |
30042 | int script; | |
30043 | int screen; | |
30044 | inline bool operator<(const Key &other) const | |
30045 | { | |
30046 | if (script != other.script) return script < other.script; | |
30047 | if (screen != other.screen) return screen < other.screen; | |
30048 | return def < other.def; | |
30049 | } | |
30050 | inline bool operator==(const Key &other) const | |
30051 | { return def == other.def && script == other.script && screen == other.screen; } | |
30052 | }; | |
30053 | typedef QMap<Key,QFontEngineData*> EngineDataCache; | |
30054 | EngineDataCache engineDataCache; | |
30055 | QFontEngineData *findEngineData(const Key &key) const; | |
30056 | void insertEngineData(const Key &key, QFontEngineData *engineData); | |
30057 | struct Engine { | |
30058 | Engine() : data(0), timestamp(0), hits(0) { } | |
30059 | Engine(QFontEngine *d) : data(d), timestamp(0), hits(0) { } | |
30060 | QFontEngine *data; | |
30061 | uint timestamp; | |
30062 | uint hits; | |
30063 | }; | |
30064 | typedef QMap<Key,Engine> EngineCache; | |
30065 | EngineCache engineCache; | |
30066 | QFontEngine *findEngine(const Key &key); | |
30067 | void insertEngine(const Key &key, QFontEngine *engine); | |
30068 | void cleanupPrinterFonts(); | |
30069 | private: | |
30070 | void increaseCost(uint cost); | |
30071 | void decreaseCost(uint cost); | |
30072 | void timerEvent(QTimerEvent *event); | |
30073 | static const uint min_cost; | |
30074 | uint total_cost, max_cost; | |
30075 | uint current_timestamp; | |
30076 | bool fast; | |
30077 | int timer_id; | |
30078 | }; | |
30079 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
30080 | class QPainter; | |
30081 | class QColorGroup; | |
30082 | class QPalette; | |
30083 | class QPoint; | |
30084 | class QColor; | |
30085 | class QBrush; | |
30086 | class QRect; | |
30087 | class QPixmap; | |
30088 | __attribute__((visibility("default"))) void qDrawShadeLine(QPainter *p, int x1, int y1, int x2, int y2, | |
30089 | const QPalette &pal, bool sunken = true, | |
30090 | int lineWidth = 1, int midLineWidth = 0); | |
30091 | __attribute__((visibility("default"))) void qDrawShadeLine(QPainter *p, const QPoint &p1, const QPoint &p2, | |
30092 | const QPalette &pal, bool sunken = true, | |
30093 | int lineWidth = 1, int midLineWidth = 0); | |
30094 | __attribute__((visibility("default"))) void qDrawShadeRect(QPainter *p, int x, int y, int w, int h, | |
30095 | const QPalette &pal, bool sunken = false, | |
30096 | int lineWidth = 1, int midLineWidth = 0, | |
30097 | const QBrush *fill = 0); | |
30098 | __attribute__((visibility("default"))) void qDrawShadeRect(QPainter *p, const QRect &r, | |
30099 | const QPalette &pal, bool sunken = false, | |
30100 | int lineWidth = 1, int midLineWidth = 0, | |
30101 | const QBrush *fill = 0); | |
30102 | __attribute__((visibility("default"))) void qDrawShadePanel(QPainter *p, int x, int y, int w, int h, | |
30103 | const QPalette &pal, bool sunken = false, | |
30104 | int lineWidth = 1, const QBrush *fill = 0); | |
30105 | __attribute__((visibility("default"))) void qDrawShadePanel(QPainter *p, const QRect &r, | |
30106 | const QPalette &pal, bool sunken = false, | |
30107 | int lineWidth = 1, const QBrush *fill = 0); | |
30108 | __attribute__((visibility("default"))) void qDrawWinButton(QPainter *p, int x, int y, int w, int h, | |
30109 | const QPalette &pal, bool sunken = false, | |
30110 | const QBrush *fill = 0); | |
30111 | __attribute__((visibility("default"))) void qDrawWinButton(QPainter *p, const QRect &r, | |
30112 | const QPalette &pal, bool sunken = false, | |
30113 | const QBrush *fill = 0); | |
30114 | __attribute__((visibility("default"))) void qDrawWinPanel(QPainter *p, int x, int y, int w, int h, | |
30115 | const QPalette &pal, bool sunken = false, | |
30116 | const QBrush *fill = 0); | |
30117 | __attribute__((visibility("default"))) void qDrawWinPanel(QPainter *p, const QRect &r, | |
30118 | const QPalette &pal, bool sunken = false, | |
30119 | const QBrush *fill = 0); | |
30120 | __attribute__((visibility("default"))) void qDrawPlainRect(QPainter *p, int x, int y, int w, int h, const QColor &, | |
30121 | int lineWidth = 1, const QBrush *fill = 0); | |
30122 | __attribute__((visibility("default"))) void qDrawPlainRect(QPainter *p, const QRect &r, const QColor &, | |
30123 | int lineWidth = 1, const QBrush *fill = 0); | |
30124 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
30125 | class __attribute__((visibility("default"))) QFontInfo | |
30126 | { | |
30127 | public: | |
30128 | QFontInfo(const QFont &); | |
30129 | QFontInfo(const QFontInfo &); | |
30130 | ~QFontInfo(); | |
30131 | QFontInfo &operator=(const QFontInfo &); | |
30132 | QString family() const; | |
30133 | int pixelSize() const; | |
30134 | int pointSize() const; | |
30135 | qreal pointSizeF() const; | |
30136 | bool italic() const; | |
30137 | QFont::Style style() const; | |
30138 | int weight() const; | |
30139 | inline bool bold() const { return weight() > QFont::Normal; } | |
30140 | bool underline() const; | |
30141 | bool overline() const; | |
30142 | bool strikeOut() const; | |
30143 | bool fixedPitch() const; | |
30144 | QFont::StyleHint styleHint() const; | |
30145 | bool rawMode() const; | |
30146 | bool exactMatch() const; | |
30147 | private: | |
30148 | QFontPrivate *d; | |
30149 | }; | |
30150 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
30151 | class QFontEngine; | |
30152 | class QTextCodec; | |
30153 | class QRect; | |
30154 | class __attribute__((visibility("default"))) QFontMetrics | |
30155 | { | |
30156 | public: | |
30157 | QFontMetrics(const QFont &); | |
30158 | QFontMetrics(const QFont &, QPaintDevice *pd); | |
30159 | QFontMetrics(const QFontMetrics &); | |
30160 | ~QFontMetrics(); | |
30161 | QFontMetrics &operator=(const QFontMetrics &); | |
30162 | int ascent() const; | |
30163 | int descent() const; | |
30164 | int height() const; | |
30165 | int leading() const; | |
30166 | int lineSpacing() const; | |
30167 | int minLeftBearing() const; | |
30168 | int minRightBearing() const; | |
30169 | int maxWidth() const; | |
30170 | int xHeight() const; | |
30171 | int averageCharWidth() const; | |
30172 | bool inFont(QChar) const; | |
30173 | int leftBearing(QChar) const; | |
30174 | int rightBearing(QChar) const; | |
30175 | int width(const QString &, int len = -1) const; | |
30176 | int width(QChar) const; | |
30177 | int charWidth(const QString &str, int pos) const; | |
30178 | QRect boundingRect(QChar) const; | |
30179 | QRect boundingRect(const QString &text) const; | |
30180 | QRect boundingRect(const QRect &r, int flags, const QString &text, int tabstops=0, int *tabarray=0) const; | |
30181 | inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text, | |
30182 | int tabstops=0, int *tabarray=0) const | |
30183 | { return boundingRect(QRect(x, y, w, h), flags, text, tabstops, tabarray); } | |
30184 | QSize size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const; | |
30185 | QRect tightBoundingRect(const QString &text) const; | |
30186 | QString elidedText(const QString &text, Qt::TextElideMode mode, int width, int flags = 0) const; | |
30187 | int underlinePos() const; | |
30188 | int overlinePos() const; | |
30189 | int strikeOutPos() const; | |
30190 | int lineWidth() const; | |
30191 | bool operator==(const QFontMetrics &other); | |
30192 | bool operator==(const QFontMetrics &other) const; | |
30193 | inline bool operator !=(const QFontMetrics &other) { return !operator==(other); } | |
30194 | inline bool operator !=(const QFontMetrics &other) const { return !operator==(other); } | |
30195 | private: | |
30196 | friend class QFontMetricsF; | |
30197 | friend class QStackTextEngine; | |
30198 | QFontPrivate *d; | |
30199 | }; | |
30200 | class __attribute__((visibility("default"))) QFontMetricsF | |
30201 | { | |
30202 | public: | |
30203 | QFontMetricsF(const QFont &); | |
30204 | QFontMetricsF(const QFont &, QPaintDevice *pd); | |
30205 | QFontMetricsF(const QFontMetrics &); | |
30206 | QFontMetricsF(const QFontMetricsF &); | |
30207 | ~QFontMetricsF(); | |
30208 | QFontMetricsF &operator=(const QFontMetricsF &); | |
30209 | QFontMetricsF &operator=(const QFontMetrics &); | |
30210 | qreal ascent() const; | |
30211 | qreal descent() const; | |
30212 | qreal height() const; | |
30213 | qreal leading() const; | |
30214 | qreal lineSpacing() const; | |
30215 | qreal minLeftBearing() const; | |
30216 | qreal minRightBearing() const; | |
30217 | qreal maxWidth() const; | |
30218 | qreal xHeight() const; | |
30219 | qreal averageCharWidth() const; | |
30220 | bool inFont(QChar) const; | |
30221 | qreal leftBearing(QChar) const; | |
30222 | qreal rightBearing(QChar) const; | |
30223 | qreal width(const QString &string) const; | |
30224 | qreal width(QChar) const; | |
30225 | QRectF boundingRect(const QString &string) const; | |
30226 | QRectF boundingRect(QChar) const; | |
30227 | QRectF boundingRect(const QRectF &r, int flags, const QString& string, int tabstops=0, int *tabarray=0) const; | |
30228 | QSizeF size(int flags, const QString& str, int tabstops=0, int *tabarray=0) const; | |
30229 | QRectF tightBoundingRect(const QString &text) const; | |
30230 | QString elidedText(const QString &text, Qt::TextElideMode mode, qreal width, int flags = 0) const; | |
30231 | qreal underlinePos() const; | |
30232 | qreal overlinePos() const; | |
30233 | qreal strikeOutPos() const; | |
30234 | qreal lineWidth() const; | |
30235 | bool operator==(const QFontMetricsF &other); | |
30236 | bool operator==(const QFontMetricsF &other) const; | |
30237 | inline bool operator !=(const QFontMetricsF &other) { return !operator==(other); } | |
30238 | inline bool operator !=(const QFontMetricsF &other) const { return !operator==(other); } | |
30239 | private: | |
30240 | QFontPrivate *d; | |
30241 | }; | |
30242 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
30243 | class QBrush; | |
30244 | class QFontInfo; | |
30245 | class QFontMetrics; | |
30246 | class QPaintDevice; | |
30247 | class QPainterPath; | |
30248 | class QPainterPrivate; | |
30249 | class QPen; | |
30250 | class QPolygon; | |
30251 | class QTextItem; | |
30252 | class QMatrix; | |
30253 | class QTransform; | |
30254 | class __attribute__((visibility("default"))) QPainter | |
30255 | { | |
30256 | inline QPainterPrivate* d_func() { return reinterpret_cast<QPainterPrivate *>(d_ptr); } inline const QPainterPrivate* d_func() const { return reinterpret_cast<const QPainterPrivate *>(d_ptr); } friend class QPainterPrivate; | |
30257 | public: static const QMetaObject staticMetaObject; private: | |
30258 | public: | |
30259 | enum RenderHint { | |
30260 | Antialiasing = 0x01, | |
30261 | TextAntialiasing = 0x02, | |
30262 | SmoothPixmapTransform = 0x04, | |
30263 | HighQualityAntialiasing = 0x08, | |
30264 | NonCosmeticDefaultPen = 0x10 | |
30265 | }; | |
30266 | typedef QFlags<RenderHint> RenderHints; | |
30267 | QPainter(); | |
30268 | explicit QPainter(QPaintDevice *); | |
30269 | ~QPainter(); | |
30270 | QPaintDevice *device() const; | |
30271 | bool begin(QPaintDevice *); | |
30272 | bool end(); | |
30273 | bool isActive() const; | |
30274 | void initFrom(const QWidget *widget); | |
30275 | enum CompositionMode { | |
30276 | CompositionMode_SourceOver, | |
30277 | CompositionMode_DestinationOver, | |
30278 | CompositionMode_Clear, | |
30279 | CompositionMode_Source, | |
30280 | CompositionMode_Destination, | |
30281 | CompositionMode_SourceIn, | |
30282 | CompositionMode_DestinationIn, | |
30283 | CompositionMode_SourceOut, | |
30284 | CompositionMode_DestinationOut, | |
30285 | CompositionMode_SourceAtop, | |
30286 | CompositionMode_DestinationAtop, | |
30287 | CompositionMode_Xor, | |
30288 | CompositionMode_Plus, | |
30289 | CompositionMode_Multiply, | |
30290 | CompositionMode_Screen, | |
30291 | CompositionMode_Overlay, | |
30292 | CompositionMode_Darken, | |
30293 | CompositionMode_Lighten, | |
30294 | CompositionMode_ColorDodge, | |
30295 | CompositionMode_ColorBurn, | |
30296 | CompositionMode_HardLight, | |
30297 | CompositionMode_SoftLight, | |
30298 | CompositionMode_Difference, | |
30299 | CompositionMode_Exclusion, | |
30300 | RasterOp_SourceOrDestination, | |
30301 | RasterOp_SourceAndDestination, | |
30302 | RasterOp_SourceXorDestination, | |
30303 | RasterOp_NotSourceAndNotDestination, | |
30304 | RasterOp_NotSourceOrNotDestination, | |
30305 | RasterOp_NotSourceXorDestination, | |
30306 | RasterOp_NotSource, | |
30307 | RasterOp_NotSourceAndDestination, | |
30308 | RasterOp_SourceAndNotDestination | |
30309 | }; | |
30310 | void setCompositionMode(CompositionMode mode); | |
30311 | CompositionMode compositionMode() const; | |
30312 | const QFont &font() const; | |
30313 | void setFont(const QFont &f); | |
30314 | QFontMetrics fontMetrics() const; | |
30315 | QFontInfo fontInfo() const; | |
30316 | void setPen(const QColor &color); | |
30317 | void setPen(const QPen &pen); | |
30318 | void setPen(Qt::PenStyle style); | |
30319 | const QPen &pen() const; | |
30320 | void setBrush(const QBrush &brush); | |
30321 | void setBrush(Qt::BrushStyle style); | |
30322 | const QBrush &brush() const; | |
30323 | void setBackgroundMode(Qt::BGMode mode); | |
30324 | Qt::BGMode backgroundMode() const; | |
30325 | QPoint brushOrigin() const; | |
30326 | inline void setBrushOrigin(int x, int y); | |
30327 | inline void setBrushOrigin(const QPoint &); | |
30328 | void setBrushOrigin(const QPointF &); | |
30329 | void setBackground(const QBrush &bg); | |
30330 | const QBrush &background() const; | |
30331 | qreal opacity() const; | |
30332 | void setOpacity(qreal opacity); | |
30333 | QRegion clipRegion() const; | |
30334 | QPainterPath clipPath() const; | |
30335 | void setClipRect(const QRectF &, Qt::ClipOperation op = Qt::ReplaceClip); | |
30336 | void setClipRect(const QRect &, Qt::ClipOperation op = Qt::ReplaceClip); | |
30337 | inline void setClipRect(int x, int y, int w, int h, Qt::ClipOperation op = Qt::ReplaceClip); | |
30338 | void setClipRegion(const QRegion &, Qt::ClipOperation op = Qt::ReplaceClip); | |
30339 | void setClipPath(const QPainterPath &path, Qt::ClipOperation op = Qt::ReplaceClip); | |
30340 | void setClipping(bool enable); | |
30341 | bool hasClipping() const; | |
30342 | void save(); | |
30343 | void restore(); | |
30344 | void setMatrix(const QMatrix &matrix, bool combine = false); | |
30345 | const QMatrix &matrix() const; | |
30346 | const QMatrix &deviceMatrix() const; | |
30347 | void resetMatrix(); | |
30348 | void setTransform(const QTransform &transform, bool combine = false); | |
30349 | const QTransform &transform() const; | |
30350 | const QTransform &deviceTransform() const; | |
30351 | void resetTransform(); | |
30352 | void setWorldMatrix(const QMatrix &matrix, bool combine = false); | |
30353 | const QMatrix &worldMatrix() const; | |
30354 | void setWorldTransform(const QTransform &matrix, bool combine = false); | |
30355 | const QTransform &worldTransform() const; | |
30356 | QMatrix combinedMatrix() const; | |
30357 | QTransform combinedTransform() const; | |
30358 | void setMatrixEnabled(bool enabled); | |
30359 | bool matrixEnabled() const; | |
30360 | void setWorldMatrixEnabled(bool enabled); | |
30361 | bool worldMatrixEnabled() const; | |
30362 | void scale(qreal sx, qreal sy); | |
30363 | void shear(qreal sh, qreal sv); | |
30364 | void rotate(qreal a); | |
30365 | void translate(const QPointF &offset); | |
30366 | inline void translate(const QPoint &offset); | |
30367 | inline void translate(qreal dx, qreal dy); | |
30368 | QRect window() const; | |
30369 | void setWindow(const QRect &window); | |
30370 | inline void setWindow(int x, int y, int w, int h); | |
30371 | QRect viewport() const; | |
30372 | void setViewport(const QRect &viewport); | |
30373 | inline void setViewport(int x, int y, int w, int h); | |
30374 | void setViewTransformEnabled(bool enable); | |
30375 | bool viewTransformEnabled() const; | |
30376 | void strokePath(const QPainterPath &path, const QPen &pen); | |
30377 | void fillPath(const QPainterPath &path, const QBrush &brush); | |
30378 | void drawPath(const QPainterPath &path); | |
30379 | inline void drawPoint(const QPointF &pt); | |
30380 | inline void drawPoint(const QPoint &p); | |
30381 | inline void drawPoint(int x, int y); | |
30382 | void drawPoints(const QPointF *points, int pointCount); | |
30383 | inline void drawPoints(const QPolygonF &points); | |
30384 | void drawPoints(const QPoint *points, int pointCount); | |
30385 | inline void drawPoints(const QPolygon &points); | |
30386 | inline void drawLine(const QLineF &line); | |
30387 | inline void drawLine(const QLine &line); | |
30388 | inline void drawLine(int x1, int y1, int x2, int y2); | |
30389 | inline void drawLine(const QPoint &p1, const QPoint &p2); | |
30390 | inline void drawLine(const QPointF &p1, const QPointF &p2); | |
30391 | void drawLines(const QLineF *lines, int lineCount); | |
30392 | inline void drawLines(const QVector<QLineF> &lines); | |
30393 | void drawLines(const QPointF *pointPairs, int lineCount); | |
30394 | inline void drawLines(const QVector<QPointF> &pointPairs); | |
30395 | void drawLines(const QLine *lines, int lineCount); | |
30396 | inline void drawLines(const QVector<QLine> &lines); | |
30397 | void drawLines(const QPoint *pointPairs, int lineCount); | |
30398 | inline void drawLines(const QVector<QPoint> &pointPairs); | |
30399 | inline void drawRect(const QRectF &rect); | |
30400 | inline void drawRect(int x1, int y1, int w, int h); | |
30401 | inline void drawRect(const QRect &rect); | |
30402 | void drawRects(const QRectF *rects, int rectCount); | |
30403 | inline void drawRects(const QVector<QRectF> &rectangles); | |
30404 | void drawRects(const QRect *rects, int rectCount); | |
30405 | inline void drawRects(const QVector<QRect> &rectangles); | |
30406 | void drawEllipse(const QRectF &r); | |
30407 | void drawEllipse(const QRect &r); | |
30408 | inline void drawEllipse(int x, int y, int w, int h); | |
30409 | inline void drawEllipse(const QPointF ¢er, qreal rx, qreal ry); | |
30410 | inline void drawEllipse(const QPoint ¢er, int rx, int ry); | |
30411 | void drawPolyline(const QPointF *points, int pointCount); | |
30412 | inline void drawPolyline(const QPolygonF &polyline); | |
30413 | void drawPolyline(const QPoint *points, int pointCount); | |
30414 | inline void drawPolyline(const QPolygon &polygon); | |
30415 | void drawPolygon(const QPointF *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill); | |
30416 | inline void drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule = Qt::OddEvenFill); | |
30417 | void drawPolygon(const QPoint *points, int pointCount, Qt::FillRule fillRule = Qt::OddEvenFill); | |
30418 | inline void drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule = Qt::OddEvenFill); | |
30419 | void drawConvexPolygon(const QPointF *points, int pointCount); | |
30420 | inline void drawConvexPolygon(const QPolygonF &polygon); | |
30421 | void drawConvexPolygon(const QPoint *points, int pointCount); | |
30422 | inline void drawConvexPolygon(const QPolygon &polygon); | |
30423 | void drawArc(const QRectF &rect, int a, int alen); | |
30424 | inline void drawArc(const QRect &, int a, int alen); | |
30425 | inline void drawArc(int x, int y, int w, int h, int a, int alen); | |
30426 | void drawPie(const QRectF &rect, int a, int alen); | |
30427 | inline void drawPie(int x, int y, int w, int h, int a, int alen); | |
30428 | inline void drawPie(const QRect &, int a, int alen); | |
30429 | void drawChord(const QRectF &rect, int a, int alen); | |
30430 | inline void drawChord(int x, int y, int w, int h, int a, int alen); | |
30431 | inline void drawChord(const QRect &, int a, int alen); | |
30432 | void drawRoundedRect(const QRectF &rect, qreal xRadius, qreal yRadius, | |
30433 | Qt::SizeMode mode = Qt::AbsoluteSize); | |
30434 | inline void drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, | |
30435 | Qt::SizeMode mode = Qt::AbsoluteSize); | |
30436 | inline void drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius, | |
30437 | Qt::SizeMode mode = Qt::AbsoluteSize); | |
30438 | void drawRoundRect(const QRectF &r, int xround = 25, int yround = 25); | |
30439 | inline void drawRoundRect(int x, int y, int w, int h, int = 25, int = 25); | |
30440 | inline void drawRoundRect(const QRect &r, int xround = 25, int yround = 25); | |
30441 | void drawTiledPixmap(const QRectF &rect, const QPixmap &pm, const QPointF &offset = QPointF()); | |
30442 | inline void drawTiledPixmap(int x, int y, int w, int h, const QPixmap &, int sx=0, int sy=0); | |
30443 | inline void drawTiledPixmap(const QRect &, const QPixmap &, const QPoint & = QPoint()); | |
30444 | void drawPicture(const QPointF &p, const QPicture &picture); | |
30445 | inline void drawPicture(int x, int y, const QPicture &picture); | |
30446 | inline void drawPicture(const QPoint &p, const QPicture &picture); | |
30447 | void drawPixmap(const QRectF &targetRect, const QPixmap &pixmap, const QRectF &sourceRect); | |
30448 | inline void drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect); | |
30449 | inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm, | |
30450 | int sx, int sy, int sw, int sh); | |
30451 | inline void drawPixmap(int x, int y, const QPixmap &pm, | |
30452 | int sx, int sy, int sw, int sh); | |
30453 | inline void drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr); | |
30454 | inline void drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr); | |
30455 | void drawPixmap(const QPointF &p, const QPixmap &pm); | |
30456 | inline void drawPixmap(const QPoint &p, const QPixmap &pm); | |
30457 | inline void drawPixmap(int x, int y, const QPixmap &pm); | |
30458 | inline void drawPixmap(const QRect &r, const QPixmap &pm); | |
30459 | inline void drawPixmap(int x, int y, int w, int h, const QPixmap &pm); | |
30460 | void drawImage(const QRectF &targetRect, const QImage &image, const QRectF &sourceRect, | |
30461 | Qt::ImageConversionFlags flags = Qt::AutoColor); | |
30462 | inline void drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect, | |
30463 | Qt::ImageConversionFlags flags = Qt::AutoColor); | |
30464 | inline void drawImage(const QPointF &p, const QImage &image, const QRectF &sr, | |
30465 | Qt::ImageConversionFlags flags = Qt::AutoColor); | |
30466 | inline void drawImage(const QPoint &p, const QImage &image, const QRect &sr, | |
30467 | Qt::ImageConversionFlags flags = Qt::AutoColor); | |
30468 | inline void drawImage(const QRectF &r, const QImage &image); | |
30469 | inline void drawImage(const QRect &r, const QImage &image); | |
30470 | void drawImage(const QPointF &p, const QImage &image); | |
30471 | inline void drawImage(const QPoint &p, const QImage &image); | |
30472 | inline void drawImage(int x, int y, const QImage &image, int sx = 0, int sy = 0, | |
30473 | int sw = -1, int sh = -1, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
30474 | void setLayoutDirection(Qt::LayoutDirection direction); | |
30475 | Qt::LayoutDirection layoutDirection() const; | |
30476 | void drawText(const QPointF &p, const QString &s); | |
30477 | inline void drawText(const QPoint &p, const QString &s); | |
30478 | inline void drawText(int x, int y, const QString &s); | |
30479 | void drawText(const QPointF &p, const QString &str, int tf, int justificationPadding); | |
30480 | void drawText(const QRectF &r, int flags, const QString &text, QRectF *br=0); | |
30481 | void drawText(const QRect &r, int flags, const QString &text, QRect *br=0); | |
30482 | inline void drawText(int x, int y, int w, int h, int flags, const QString &text, QRect *br=0); | |
30483 | void drawText(const QRectF &r, const QString &text, const QTextOption &o = QTextOption()); | |
30484 | QRectF boundingRect(const QRectF &rect, int flags, const QString &text); | |
30485 | QRect boundingRect(const QRect &rect, int flags, const QString &text); | |
30486 | inline QRect boundingRect(int x, int y, int w, int h, int flags, const QString &text); | |
30487 | QRectF boundingRect(const QRectF &rect, const QString &text, const QTextOption &o = QTextOption()); | |
30488 | void drawTextItem(const QPointF &p, const QTextItem &ti); | |
30489 | inline void drawTextItem(int x, int y, const QTextItem &ti); | |
30490 | inline void drawTextItem(const QPoint &p, const QTextItem &ti); | |
30491 | void fillRect(const QRectF &, const QBrush &); | |
30492 | inline void fillRect(int x, int y, int w, int h, const QBrush &); | |
30493 | void fillRect(const QRect &, const QBrush &); | |
30494 | void fillRect(const QRectF &, const QColor &color); | |
30495 | inline void fillRect(int x, int y, int w, int h, const QColor &color); | |
30496 | void fillRect(const QRect &, const QColor &color); | |
30497 | inline void fillRect(int x, int y, int w, int h, Qt::GlobalColor c); | |
30498 | inline void fillRect(const QRect &r, Qt::GlobalColor c); | |
30499 | inline void fillRect(const QRectF &r, Qt::GlobalColor c); | |
30500 | inline void fillRect(int x, int y, int w, int h, Qt::BrushStyle style); | |
30501 | inline void fillRect(const QRect &r, Qt::BrushStyle style); | |
30502 | inline void fillRect(const QRectF &r, Qt::BrushStyle style); | |
30503 | void eraseRect(const QRectF &); | |
30504 | inline void eraseRect(int x, int y, int w, int h); | |
30505 | inline void eraseRect(const QRect &); | |
30506 | void setRenderHint(RenderHint hint, bool on = true); | |
30507 | void setRenderHints(RenderHints hints, bool on = true); | |
30508 | RenderHints renderHints() const; | |
30509 | inline bool testRenderHint(RenderHint hint) const { return renderHints() & hint; } | |
30510 | QPaintEngine *paintEngine() const; | |
30511 | static void setRedirected(const QPaintDevice *device, QPaintDevice *replacement, | |
30512 | const QPoint& offset = QPoint()); | |
30513 | static QPaintDevice *redirected(const QPaintDevice *device, QPoint *offset = 0); | |
30514 | static void restoreRedirected(const QPaintDevice *device); | |
30515 | private: | |
30516 | QPainter(const QPainter &); QPainter &operator=(const QPainter &); | |
30517 | friend class Q3Painter; | |
30518 | QPainterPrivate *d_ptr; | |
30519 | friend class QFontEngine; | |
30520 | friend class QFontEngineBox; | |
30521 | friend class QFontEngineFT; | |
30522 | friend class QFontEngineMac; | |
30523 | friend class QFontEngineWin; | |
30524 | friend class QFontEngineXLFD; | |
30525 | friend class QWSManager; | |
30526 | friend class QPaintEngine; | |
30527 | friend class QOpenGLPaintEngine; | |
30528 | friend class QX11PaintEngine; | |
30529 | friend class QX11PaintEnginePrivate; | |
30530 | friend class QWin32PaintEngine; | |
30531 | friend class QWin32PaintEnginePrivate; | |
30532 | friend class QRasterPaintEngine; | |
30533 | friend class QAlphaPaintEngine; | |
30534 | friend class QPreviewPaintEngine; | |
30535 | }; | |
30536 | inline QFlags<QPainter::RenderHints::enum_type> operator|(QPainter::RenderHints::enum_type f1, QPainter::RenderHints::enum_type f2) { return QFlags<QPainter::RenderHints::enum_type>(f1) | f2; } inline QFlags<QPainter::RenderHints::enum_type> operator|(QPainter::RenderHints::enum_type f1, QFlags<QPainter::RenderHints::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QPainter::RenderHints::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
30537 | inline void QPainter::drawLine(const QLineF &l) | |
30538 | { | |
30539 | drawLines(&l, 1); | |
30540 | } | |
30541 | inline void QPainter::drawLine(const QLine &line) | |
30542 | { | |
30543 | drawLines(&line, 1); | |
30544 | } | |
30545 | inline void QPainter::drawLine(int x1, int y1, int x2, int y2) | |
30546 | { | |
30547 | QLine l(x1, y1, x2, y2); | |
30548 | drawLines(&l, 1); | |
30549 | } | |
30550 | inline void QPainter::drawLine(const QPoint &p1, const QPoint &p2) | |
30551 | { | |
30552 | QLine l(p1, p2); | |
30553 | drawLines(&l, 1); | |
30554 | } | |
30555 | inline void QPainter::drawLine(const QPointF &p1, const QPointF &p2) | |
30556 | { | |
30557 | drawLine(QLineF(p1, p2)); | |
30558 | } | |
30559 | inline void QPainter::drawLines(const QVector<QLineF> &lines) | |
30560 | { | |
30561 | drawLines(lines.constData(), lines.size()); | |
30562 | } | |
30563 | inline void QPainter::drawLines(const QVector<QLine> &lines) | |
30564 | { | |
30565 | drawLines(lines.constData(), lines.size()); | |
30566 | } | |
30567 | inline void QPainter::drawLines(const QVector<QPointF> &pointPairs) | |
30568 | { | |
30569 | drawLines(pointPairs.constData(), pointPairs.size() / 2); | |
30570 | } | |
30571 | inline void QPainter::drawLines(const QVector<QPoint> &pointPairs) | |
30572 | { | |
30573 | drawLines(pointPairs.constData(), pointPairs.size() / 2); | |
30574 | } | |
30575 | inline void QPainter::drawPolyline(const QPolygonF &polyline) | |
30576 | { | |
30577 | drawPolyline(polyline.constData(), polyline.size()); | |
30578 | } | |
30579 | inline void QPainter::drawPolyline(const QPolygon &polyline) | |
30580 | { | |
30581 | drawPolyline(polyline.constData(), polyline.size()); | |
30582 | } | |
30583 | inline void QPainter::drawPolygon(const QPolygonF &polygon, Qt::FillRule fillRule) | |
30584 | { | |
30585 | drawPolygon(polygon.constData(), polygon.size(), fillRule); | |
30586 | } | |
30587 | inline void QPainter::drawPolygon(const QPolygon &polygon, Qt::FillRule fillRule) | |
30588 | { | |
30589 | drawPolygon(polygon.constData(), polygon.size(), fillRule); | |
30590 | } | |
30591 | inline void QPainter::drawConvexPolygon(const QPolygonF &poly) | |
30592 | { | |
30593 | drawConvexPolygon(poly.constData(), poly.size()); | |
30594 | } | |
30595 | inline void QPainter::drawConvexPolygon(const QPolygon &poly) | |
30596 | { | |
30597 | drawConvexPolygon(poly.constData(), poly.size()); | |
30598 | } | |
30599 | inline void QPainter::drawRect(const QRectF &rect) | |
30600 | { | |
30601 | drawRects(&rect, 1); | |
30602 | } | |
30603 | inline void QPainter::drawRect(int x, int y, int w, int h) | |
30604 | { | |
30605 | QRect r(x, y, w, h); | |
30606 | drawRects(&r, 1); | |
30607 | } | |
30608 | inline void QPainter::drawRect(const QRect &r) | |
30609 | { | |
30610 | drawRects(&r, 1); | |
30611 | } | |
30612 | inline void QPainter::drawRects(const QVector<QRectF> &rects) | |
30613 | { | |
30614 | drawRects(rects.constData(), rects.size()); | |
30615 | } | |
30616 | inline void QPainter::drawRects(const QVector<QRect> &rects) | |
30617 | { | |
30618 | drawRects(rects.constData(), rects.size()); | |
30619 | } | |
30620 | inline void QPainter::drawPoint(const QPointF &p) | |
30621 | { | |
30622 | drawPoints(&p, 1); | |
30623 | } | |
30624 | inline void QPainter::drawPoint(int x, int y) | |
30625 | { | |
30626 | QPoint p(x, y); | |
30627 | drawPoints(&p, 1); | |
30628 | } | |
30629 | inline void QPainter::drawPoint(const QPoint &p) | |
30630 | { | |
30631 | drawPoints(&p, 1); | |
30632 | } | |
30633 | inline void QPainter::drawPoints(const QPolygonF &points) | |
30634 | { | |
30635 | drawPoints(points.constData(), points.size()); | |
30636 | } | |
30637 | inline void QPainter::drawPoints(const QPolygon &points) | |
30638 | { | |
30639 | drawPoints(points.constData(), points.size()); | |
30640 | } | |
30641 | inline void QPainter::drawRoundRect(int x, int y, int w, int h, int xRnd, int yRnd) | |
30642 | { | |
30643 | drawRoundRect(QRectF(x, y, w, h), xRnd, yRnd); | |
30644 | } | |
30645 | inline void QPainter::drawRoundRect(const QRect &rect, int xRnd, int yRnd) | |
30646 | { | |
30647 | drawRoundRect(QRectF(rect), xRnd, yRnd); | |
30648 | } | |
30649 | inline void QPainter::drawRoundedRect(int x, int y, int w, int h, qreal xRadius, qreal yRadius, | |
30650 | Qt::SizeMode mode) | |
30651 | { | |
30652 | drawRoundedRect(QRectF(x, y, w, h), xRadius, yRadius, mode); | |
30653 | } | |
30654 | inline void QPainter::drawRoundedRect(const QRect &rect, qreal xRadius, qreal yRadius, | |
30655 | Qt::SizeMode mode) | |
30656 | { | |
30657 | drawRoundedRect(QRectF(rect), xRadius, yRadius, mode); | |
30658 | } | |
30659 | inline void QPainter::drawEllipse(int x, int y, int w, int h) | |
30660 | { | |
30661 | drawEllipse(QRect(x, y, w, h)); | |
30662 | } | |
30663 | inline void QPainter::drawEllipse(const QPointF ¢er, qreal rx, qreal ry) | |
30664 | { | |
30665 | drawEllipse(QRectF(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry)); | |
30666 | } | |
30667 | inline void QPainter::drawEllipse(const QPoint ¢er, int rx, int ry) | |
30668 | { | |
30669 | drawEllipse(QRect(center.x() - rx, center.y() - ry, 2 * rx, 2 * ry)); | |
30670 | } | |
30671 | inline void QPainter::drawArc(const QRect &r, int a, int alen) | |
30672 | { | |
30673 | drawArc(QRectF(r), a, alen); | |
30674 | } | |
30675 | inline void QPainter::drawArc(int x, int y, int w, int h, int a, int alen) | |
30676 | { | |
30677 | drawArc(QRectF(x, y, w, h), a, alen); | |
30678 | } | |
30679 | inline void QPainter::drawPie(const QRect &rect, int a, int alen) | |
30680 | { | |
30681 | drawPie(QRectF(rect), a, alen); | |
30682 | } | |
30683 | inline void QPainter::drawPie(int x, int y, int w, int h, int a, int alen) | |
30684 | { | |
30685 | drawPie(QRectF(x, y, w, h), a, alen); | |
30686 | } | |
30687 | inline void QPainter::drawChord(const QRect &rect, int a, int alen) | |
30688 | { | |
30689 | drawChord(QRectF(rect), a, alen); | |
30690 | } | |
30691 | inline void QPainter::drawChord(int x, int y, int w, int h, int a, int alen) | |
30692 | { | |
30693 | drawChord(QRectF(x, y, w, h), a, alen); | |
30694 | } | |
30695 | inline void QPainter::setClipRect(int x, int y, int w, int h, Qt::ClipOperation op) | |
30696 | { | |
30697 | setClipRect(QRect(x, y, w, h), op); | |
30698 | } | |
30699 | inline void QPainter::eraseRect(const QRect &rect) | |
30700 | { | |
30701 | eraseRect(QRectF(rect)); | |
30702 | } | |
30703 | inline void QPainter::eraseRect(int x, int y, int w, int h) | |
30704 | { | |
30705 | eraseRect(QRectF(x, y, w, h)); | |
30706 | } | |
30707 | inline void QPainter::fillRect(int x, int y, int w, int h, const QBrush &b) | |
30708 | { | |
30709 | fillRect(QRect(x, y, w, h), b); | |
30710 | } | |
30711 | inline void QPainter::fillRect(int x, int y, int w, int h, const QColor &b) | |
30712 | { | |
30713 | fillRect(QRect(x, y, w, h), b); | |
30714 | } | |
30715 | inline void QPainter::fillRect(int x, int y, int w, int h, Qt::GlobalColor c) | |
30716 | { | |
30717 | fillRect(QRect(x, y, w, h), QColor(c)); | |
30718 | } | |
30719 | inline void QPainter::fillRect(const QRect &r, Qt::GlobalColor c) | |
30720 | { | |
30721 | fillRect(r, QColor(c)); | |
30722 | } | |
30723 | inline void QPainter::fillRect(const QRectF &r, Qt::GlobalColor c) | |
30724 | { | |
30725 | fillRect(r, QColor(c)); | |
30726 | } | |
30727 | inline void QPainter::fillRect(int x, int y, int w, int h, Qt::BrushStyle style) | |
30728 | { | |
30729 | fillRect(QRectF(x, y, w, h), QBrush(style)); | |
30730 | } | |
30731 | inline void QPainter::fillRect(const QRect &r, Qt::BrushStyle style) | |
30732 | { | |
30733 | fillRect(QRectF(r), QBrush(style)); | |
30734 | } | |
30735 | inline void QPainter::fillRect(const QRectF &r, Qt::BrushStyle style) | |
30736 | { | |
30737 | fillRect(r, QBrush(style)); | |
30738 | } | |
30739 | inline void QPainter::setBrushOrigin(int x, int y) | |
30740 | { | |
30741 | setBrushOrigin(QPoint(x, y)); | |
30742 | } | |
30743 | inline void QPainter::setBrushOrigin(const QPoint &p) | |
30744 | { | |
30745 | setBrushOrigin(QPointF(p)); | |
30746 | } | |
30747 | inline void QPainter::drawTiledPixmap(const QRect &rect, const QPixmap &pm, const QPoint &offset) | |
30748 | { | |
30749 | drawTiledPixmap(QRectF(rect), pm, QPointF(offset)); | |
30750 | } | |
30751 | inline void QPainter::drawTiledPixmap(int x, int y, int w, int h, const QPixmap &pm, int sx, int sy) | |
30752 | { | |
30753 | drawTiledPixmap(QRectF(x, y, w, h), pm, QPointF(sx, sy)); | |
30754 | } | |
30755 | inline void QPainter::drawPixmap(const QRect &targetRect, const QPixmap &pixmap, const QRect &sourceRect) | |
30756 | { | |
30757 | drawPixmap(QRectF(targetRect), pixmap, QRectF(sourceRect)); | |
30758 | } | |
30759 | inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm) | |
30760 | { | |
30761 | drawPixmap(QPointF(p), pm); | |
30762 | } | |
30763 | inline void QPainter::drawPixmap(const QRect &r, const QPixmap &pm) | |
30764 | { | |
30765 | drawPixmap(QRectF(r), pm, QRectF()); | |
30766 | } | |
30767 | inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm) | |
30768 | { | |
30769 | drawPixmap(QPointF(x, y), pm); | |
30770 | } | |
30771 | inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm) | |
30772 | { | |
30773 | drawPixmap(QRectF(x, y, w, h), pm, QRectF()); | |
30774 | } | |
30775 | inline void QPainter::drawPixmap(int x, int y, int w, int h, const QPixmap &pm, | |
30776 | int sx, int sy, int sw, int sh) | |
30777 | { | |
30778 | drawPixmap(QRectF(x, y, w, h), pm, QRectF(sx, sy, sw, sh)); | |
30779 | } | |
30780 | inline void QPainter::drawPixmap(int x, int y, const QPixmap &pm, | |
30781 | int sx, int sy, int sw, int sh) | |
30782 | { | |
30783 | drawPixmap(QRectF(x, y, -1, -1), pm, QRectF(sx, sy, sw, sh)); | |
30784 | } | |
30785 | inline void QPainter::drawPixmap(const QPointF &p, const QPixmap &pm, const QRectF &sr) | |
30786 | { | |
30787 | drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr); | |
30788 | } | |
30789 | inline void QPainter::drawPixmap(const QPoint &p, const QPixmap &pm, const QRect &sr) | |
30790 | { | |
30791 | drawPixmap(QRectF(p.x(), p.y(), -1, -1), pm, sr); | |
30792 | } | |
30793 | inline void QPainter::drawTextItem(int x, int y, const QTextItem &ti) | |
30794 | { | |
30795 | drawTextItem(QPointF(x, y), ti); | |
30796 | } | |
30797 | inline void QPainter::drawImage(const QRect &targetRect, const QImage &image, const QRect &sourceRect, | |
30798 | Qt::ImageConversionFlags flags) | |
30799 | { | |
30800 | drawImage(QRectF(targetRect), image, QRectF(sourceRect), flags); | |
30801 | } | |
30802 | inline void QPainter::drawImage(const QPointF &p, const QImage &image, const QRectF &sr, | |
30803 | Qt::ImageConversionFlags flags) | |
30804 | { | |
30805 | drawImage(QRectF(p.x(), p.y(), -1, -1), image, sr, flags); | |
30806 | } | |
30807 | inline void QPainter::drawImage(const QPoint &p, const QImage &image, const QRect &sr, | |
30808 | Qt::ImageConversionFlags flags) | |
30809 | { | |
30810 | drawImage(QRect(p.x(), p.y(), -1, -1), image, sr, flags); | |
30811 | } | |
30812 | inline void QPainter::drawImage(const QRectF &r, const QImage &image) | |
30813 | { | |
30814 | drawImage(r, image, QRect(0, 0, image.width(), image.height())); | |
30815 | } | |
30816 | inline void QPainter::drawImage(const QRect &r, const QImage &image) | |
30817 | { | |
30818 | drawImage(r, image, QRectF(0, 0, image.width(), image.height())); | |
30819 | } | |
30820 | inline void QPainter::drawImage(const QPoint &p, const QImage &image) | |
30821 | { | |
30822 | drawImage(QPointF(p), image); | |
30823 | } | |
30824 | inline void QPainter::drawImage(int x, int y, const QImage &image, int sx, int sy, int sw, int sh, | |
30825 | Qt::ImageConversionFlags flags) | |
30826 | { | |
30827 | if (sx == 0 && sy == 0 && sw == -1 && sh == -1 && flags == Qt::AutoColor) | |
30828 | drawImage(QPointF(x, y), image); | |
30829 | else | |
30830 | drawImage(QRectF(x, y, -1, -1), image, QRectF(sx, sy, sw, sh), flags); | |
30831 | } | |
30832 | inline void QPainter::drawTextItem(const QPoint &p, const QTextItem &ti) | |
30833 | { | |
30834 | drawTextItem(QPointF(p), ti); | |
30835 | } | |
30836 | inline void QPainter::drawText(const QPoint &p, const QString &s) | |
30837 | { | |
30838 | drawText(QPointF(p), s); | |
30839 | } | |
30840 | inline void QPainter::drawText(int x, int y, int w, int h, int flags, const QString &str, QRect *br) | |
30841 | { | |
30842 | drawText(QRect(x, y, w, h), flags, str, br); | |
30843 | } | |
30844 | inline void QPainter::drawText(int x, int y, const QString &s) | |
30845 | { | |
30846 | drawText(QPointF(x, y), s); | |
30847 | } | |
30848 | inline QRect QPainter::boundingRect(int x, int y, int w, int h, int flags, const QString &text) | |
30849 | { | |
30850 | return boundingRect(QRect(x, y, w, h), flags, text); | |
30851 | } | |
30852 | inline void QPainter::translate(qreal dx, qreal dy) | |
30853 | { | |
30854 | translate(QPointF(dx, dy)); | |
30855 | } | |
30856 | inline void QPainter::translate(const QPoint &offset) | |
30857 | { | |
30858 | translate(offset.x(), offset.y()); | |
30859 | } | |
30860 | inline void QPainter::setViewport(int x, int y, int w, int h) | |
30861 | { | |
30862 | setViewport(QRect(x, y, w, h)); | |
30863 | } | |
30864 | inline void QPainter::setWindow(int x, int y, int w, int h) | |
30865 | { | |
30866 | setWindow(QRect(x, y, w, h)); | |
30867 | } | |
30868 | inline void QPainter::drawPicture(int x, int y, const QPicture &p) | |
30869 | { | |
30870 | drawPicture(QPoint(x, y), p); | |
30871 | } | |
30872 | inline void QPainter::drawPicture(const QPoint &pt, const QPicture &p) | |
30873 | { | |
30874 | drawPicture(QPointF(pt), p); | |
30875 | } | |
30876 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
30877 | class QFontEngine; | |
30878 | class QLineF; | |
30879 | class QPaintDevice; | |
30880 | class QPaintEnginePrivate; | |
30881 | class QPainterPath; | |
30882 | class QPointF; | |
30883 | class QPolygonF; | |
30884 | class QRectF; | |
30885 | struct QGlyphLayout; | |
30886 | class QTextItemInt; | |
30887 | class QPaintEngineState; | |
30888 | class __attribute__((visibility("default"))) QTextItem { | |
30889 | public: | |
30890 | enum RenderFlag { | |
30891 | RightToLeft = 0x1, | |
30892 | Overline = 0x10, | |
30893 | Underline = 0x20, | |
30894 | StrikeOut = 0x40, | |
30895 | Dummy = 0xffffffff | |
30896 | }; | |
30897 | typedef QFlags<RenderFlag> RenderFlags; | |
30898 | qreal descent() const; | |
30899 | qreal ascent() const; | |
30900 | qreal width() const; | |
30901 | RenderFlags renderFlags() const; | |
30902 | QString text() const; | |
30903 | QFont font() const; | |
30904 | }; | |
30905 | template <> class QTypeInfo<QTextItem> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextItem)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextItem"; } }; | |
30906 | class __attribute__((visibility("default"))) QPaintEngine | |
30907 | { | |
30908 | inline QPaintEnginePrivate* d_func() { return reinterpret_cast<QPaintEnginePrivate *>(d_ptr); } inline const QPaintEnginePrivate* d_func() const { return reinterpret_cast<const QPaintEnginePrivate *>(d_ptr); } friend class QPaintEnginePrivate; | |
30909 | public: | |
30910 | enum PaintEngineFeature { | |
30911 | PrimitiveTransform = 0x00000001, | |
30912 | PatternTransform = 0x00000002, | |
30913 | PixmapTransform = 0x00000004, | |
30914 | PatternBrush = 0x00000008, | |
30915 | LinearGradientFill = 0x00000010, | |
30916 | RadialGradientFill = 0x00000020, | |
30917 | ConicalGradientFill = 0x00000040, | |
30918 | AlphaBlend = 0x00000080, | |
30919 | PorterDuff = 0x00000100, | |
30920 | PainterPaths = 0x00000200, | |
30921 | Antialiasing = 0x00000400, | |
30922 | BrushStroke = 0x00000800, | |
30923 | ConstantOpacity = 0x00001000, | |
30924 | MaskedBrush = 0x00002000, | |
30925 | PerspectiveTransform = 0x00004000, | |
30926 | BlendModes = 0x00008000, | |
30927 | ObjectBoundingModeGradients = 0x00010000, | |
30928 | RasterOpModes = 0x00020000, | |
30929 | PaintOutsidePaintEvent = 0x20000000, | |
30930 | AllFeatures = 0xffffffff | |
30931 | }; | |
30932 | typedef QFlags<PaintEngineFeature> PaintEngineFeatures; | |
30933 | enum DirtyFlag { | |
30934 | DirtyPen = 0x0001, | |
30935 | DirtyBrush = 0x0002, | |
30936 | DirtyBrushOrigin = 0x0004, | |
30937 | DirtyFont = 0x0008, | |
30938 | DirtyBackground = 0x0010, | |
30939 | DirtyBackgroundMode = 0x0020, | |
30940 | DirtyTransform = 0x0040, | |
30941 | DirtyClipRegion = 0x0080, | |
30942 | DirtyClipPath = 0x0100, | |
30943 | DirtyHints = 0x0200, | |
30944 | DirtyCompositionMode = 0x0400, | |
30945 | DirtyClipEnabled = 0x0800, | |
30946 | DirtyOpacity = 0x1000, | |
30947 | AllDirty = 0xffff | |
30948 | }; | |
30949 | typedef QFlags<DirtyFlag> DirtyFlags; | |
30950 | enum PolygonDrawMode { | |
30951 | OddEvenMode, | |
30952 | WindingMode, | |
30953 | ConvexMode, | |
30954 | PolylineMode | |
30955 | }; | |
30956 | explicit QPaintEngine(PaintEngineFeatures features=0); | |
30957 | virtual ~QPaintEngine(); | |
30958 | bool isActive() const { return active; } | |
30959 | void setActive(bool newState) { active = newState; } | |
30960 | virtual bool begin(QPaintDevice *pdev) = 0; | |
30961 | virtual bool end() = 0; | |
30962 | virtual void updateState(const QPaintEngineState &state) = 0; | |
30963 | virtual void drawRects(const QRect *rects, int rectCount); | |
30964 | virtual void drawRects(const QRectF *rects, int rectCount); | |
30965 | virtual void drawLines(const QLine *lines, int lineCount); | |
30966 | virtual void drawLines(const QLineF *lines, int lineCount); | |
30967 | virtual void drawEllipse(const QRectF &r); | |
30968 | virtual void drawEllipse(const QRect &r); | |
30969 | virtual void drawPath(const QPainterPath &path); | |
30970 | virtual void drawPoints(const QPointF *points, int pointCount); | |
30971 | virtual void drawPoints(const QPoint *points, int pointCount); | |
30972 | virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode); | |
30973 | virtual void drawPolygon(const QPoint *points, int pointCount, PolygonDrawMode mode); | |
30974 | virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr) = 0; | |
30975 | virtual void drawTextItem(const QPointF &p, const QTextItem &textItem); | |
30976 | virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s); | |
30977 | virtual void drawImage(const QRectF &r, const QImage &pm, const QRectF &sr, | |
30978 | Qt::ImageConversionFlags flags = Qt::AutoColor); | |
30979 | void setPaintDevice(QPaintDevice *device); | |
30980 | QPaintDevice *paintDevice() const; | |
30981 | void setSystemClip(const QRegion &baseClip); | |
30982 | QRegion systemClip() const; | |
30983 | void setSystemRect(const QRect &rect); | |
30984 | QRect systemRect() const; | |
30985 | virtual QPoint coordinateOffset() const; | |
30986 | enum Type { | |
30987 | X11, | |
30988 | Windows, | |
30989 | QuickDraw, CoreGraphics, MacPrinter, | |
30990 | QWindowSystem, | |
30991 | PostScript, | |
30992 | OpenGL, | |
30993 | Picture, | |
30994 | SVG, | |
30995 | Raster, | |
30996 | Direct3D, | |
30997 | Pdf, | |
30998 | OpenVG, | |
30999 | User = 50, | |
31000 | MaxUser = 100 | |
31001 | }; | |
31002 | virtual Type type() const = 0; | |
31003 | inline void fix_neg_rect(int *x, int *y, int *w, int *h); | |
31004 | inline bool testDirty(DirtyFlags df); | |
31005 | inline void setDirty(DirtyFlags df); | |
31006 | inline void clearDirty(DirtyFlags df); | |
31007 | bool hasFeature(PaintEngineFeatures feature) const { return (gccaps & feature) != 0; } | |
31008 | QPainter *painter() const; | |
31009 | void syncState(); | |
31010 | inline bool isExtended() const { return extended; } | |
31011 | protected: | |
31012 | QPaintEngine(QPaintEnginePrivate &data, PaintEngineFeatures devcaps=0); | |
31013 | QPaintEngineState *state; | |
31014 | PaintEngineFeatures gccaps; | |
31015 | uint active : 1; | |
31016 | uint selfDestruct : 1; | |
31017 | uint extended : 1; | |
31018 | QPaintEnginePrivate *d_ptr; | |
31019 | private: | |
31020 | void setAutoDestruct(bool autoDestr) { selfDestruct = autoDestr; } | |
31021 | bool autoDestruct() const { return selfDestruct; } | |
31022 | QPaintEngine(const QPaintEngine &); QPaintEngine &operator=(const QPaintEngine &); | |
31023 | friend class QFontEngineBox; | |
31024 | friend class QFontEngineMac; | |
31025 | friend class QFontEngineWin; | |
31026 | friend class QFontEngineQPF1; | |
31027 | friend class QFontEngineQPF; | |
31028 | friend class QPSPrintEngine; | |
31029 | friend class QMacPrintEngine; | |
31030 | friend class QMacPrintEnginePrivate; | |
31031 | friend class QtopiaPrintEngine; | |
31032 | friend class QtopiaPrintEnginePrivate; | |
31033 | friend class QProxyFontEngine; | |
31034 | friend class QPainter; | |
31035 | friend class QPainterPrivate; | |
31036 | friend class QWidget; | |
31037 | friend class QWidgetPrivate; | |
31038 | friend class QWin32PaintEngine; | |
31039 | friend class QWin32PaintEnginePrivate; | |
31040 | friend class QMacCGContext; | |
31041 | friend class QPreviewPaintEngine; | |
31042 | }; | |
31043 | class __attribute__((visibility("default"))) QPaintEngineState | |
31044 | { | |
31045 | public: | |
31046 | QPaintEngine::DirtyFlags state() const { return dirtyFlags; } | |
31047 | QPen pen() const; | |
31048 | QBrush brush() const; | |
31049 | QPointF brushOrigin() const; | |
31050 | QBrush backgroundBrush() const; | |
31051 | Qt::BGMode backgroundMode() const; | |
31052 | QFont font() const; | |
31053 | QMatrix matrix() const; | |
31054 | QTransform transform() const; | |
31055 | Qt::ClipOperation clipOperation() const; | |
31056 | QRegion clipRegion() const; | |
31057 | QPainterPath clipPath() const; | |
31058 | bool isClipEnabled() const; | |
31059 | QPainter::RenderHints renderHints() const; | |
31060 | QPainter::CompositionMode compositionMode() const; | |
31061 | qreal opacity() const; | |
31062 | QPainter *painter() const; | |
31063 | bool brushNeedsResolving() const; | |
31064 | bool penNeedsResolving() const; | |
31065 | protected: | |
31066 | friend class QPaintEngine; | |
31067 | friend class QRasterPaintEngine; | |
31068 | friend class QWidget; | |
31069 | friend class QPainter; | |
31070 | friend class QPainterPrivate; | |
31071 | friend class QMacPrintEnginePrivate; | |
31072 | QPaintEngine::DirtyFlags dirtyFlags; | |
31073 | }; | |
31074 | inline void QPaintEngine::fix_neg_rect(int *x, int *y, int *w, int *h) | |
31075 | { | |
31076 | if (*w < 0) { | |
31077 | *w = -*w; | |
31078 | *x -= *w - 1; | |
31079 | } | |
31080 | if (*h < 0) { | |
31081 | *h = -*h; | |
31082 | *y -= *h - 1; | |
31083 | } | |
31084 | } | |
31085 | inline bool QPaintEngine::testDirty(DirtyFlags df) { | |
31086 | qt_noop(); | |
31087 | return ((state->dirtyFlags & df) != 0); | |
31088 | } | |
31089 | inline void QPaintEngine::setDirty(DirtyFlags df) { | |
31090 | qt_noop(); | |
31091 | state->dirtyFlags |= df; | |
31092 | } | |
31093 | inline void QPaintEngine::clearDirty(DirtyFlags df) | |
31094 | { | |
31095 | qt_noop(); | |
31096 | state->dirtyFlags &= ~static_cast<uint>(df); | |
31097 | } | |
31098 | inline QFlags<QTextItem::RenderFlags::enum_type> operator|(QTextItem::RenderFlags::enum_type f1, QTextItem::RenderFlags::enum_type f2) { return QFlags<QTextItem::RenderFlags::enum_type>(f1) | f2; } inline QFlags<QTextItem::RenderFlags::enum_type> operator|(QTextItem::RenderFlags::enum_type f1, QFlags<QTextItem::RenderFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextItem::RenderFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
31099 | inline QFlags<QPaintEngine::PaintEngineFeatures::enum_type> operator|(QPaintEngine::PaintEngineFeatures::enum_type f1, QPaintEngine::PaintEngineFeatures::enum_type f2) { return QFlags<QPaintEngine::PaintEngineFeatures::enum_type>(f1) | f2; } inline QFlags<QPaintEngine::PaintEngineFeatures::enum_type> operator|(QPaintEngine::PaintEngineFeatures::enum_type f1, QFlags<QPaintEngine::PaintEngineFeatures::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QPaintEngine::PaintEngineFeatures::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
31100 | inline QFlags<QPaintEngine::DirtyFlags::enum_type> operator|(QPaintEngine::DirtyFlags::enum_type f1, QPaintEngine::DirtyFlags::enum_type f2) { return QFlags<QPaintEngine::DirtyFlags::enum_type>(f1) | f2; } inline QFlags<QPaintEngine::DirtyFlags::enum_type> operator|(QPaintEngine::DirtyFlags::enum_type f1, QFlags<QPaintEngine::DirtyFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QPaintEngine::DirtyFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
31101 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
31102 | class QTextObjectPrivate; | |
31103 | class QTextDocument; | |
31104 | class QTextDocumentPrivate; | |
31105 | class QTextCursor; | |
31106 | class QTextBlock; | |
31107 | class QTextFragment; | |
31108 | class QTextLayout; | |
31109 | class QTextList; | |
31110 | class __attribute__((visibility("default"))) QTextObject : public QObject | |
31111 | { | |
31112 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
31113 | protected: | |
31114 | explicit QTextObject(QTextDocument *doc); | |
31115 | ~QTextObject(); | |
31116 | void setFormat(const QTextFormat &format); | |
31117 | public: | |
31118 | QTextFormat format() const; | |
31119 | int formatIndex() const; | |
31120 | QTextDocument *document() const; | |
31121 | int objectIndex() const; | |
31122 | QTextDocumentPrivate *docHandle() const; | |
31123 | protected: | |
31124 | QTextObject(QTextObjectPrivate &p, QTextDocument *doc); | |
31125 | private: | |
31126 | inline QTextObjectPrivate* d_func() { return reinterpret_cast<QTextObjectPrivate *>(d_ptr); } inline const QTextObjectPrivate* d_func() const { return reinterpret_cast<const QTextObjectPrivate *>(d_ptr); } friend class QTextObjectPrivate; | |
31127 | QTextObject(const QTextObject &); QTextObject &operator=(const QTextObject &); | |
31128 | friend class QTextDocumentPrivate; | |
31129 | }; | |
31130 | class QTextBlockGroupPrivate; | |
31131 | class __attribute__((visibility("default"))) QTextBlockGroup : public QTextObject | |
31132 | { | |
31133 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
31134 | protected: | |
31135 | explicit QTextBlockGroup(QTextDocument *doc); | |
31136 | ~QTextBlockGroup(); | |
31137 | virtual void blockInserted(const QTextBlock &block); | |
31138 | virtual void blockRemoved(const QTextBlock &block); | |
31139 | virtual void blockFormatChanged(const QTextBlock &block); | |
31140 | QList<QTextBlock> blockList() const; | |
31141 | protected: | |
31142 | QTextBlockGroup(QTextBlockGroupPrivate &p, QTextDocument *doc); | |
31143 | private: | |
31144 | inline QTextBlockGroupPrivate* d_func() { return reinterpret_cast<QTextBlockGroupPrivate *>(d_ptr); } inline const QTextBlockGroupPrivate* d_func() const { return reinterpret_cast<const QTextBlockGroupPrivate *>(d_ptr); } friend class QTextBlockGroupPrivate; | |
31145 | QTextBlockGroup(const QTextBlockGroup &); QTextBlockGroup &operator=(const QTextBlockGroup &); | |
31146 | friend class QTextDocumentPrivate; | |
31147 | }; | |
31148 | class __attribute__((visibility("default"))) QTextFrameLayoutData { | |
31149 | public: | |
31150 | virtual ~QTextFrameLayoutData(); | |
31151 | }; | |
31152 | class QTextFramePrivate; | |
31153 | class __attribute__((visibility("default"))) QTextFrame : public QTextObject | |
31154 | { | |
31155 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
31156 | public: | |
31157 | explicit QTextFrame(QTextDocument *doc); | |
31158 | ~QTextFrame(); | |
31159 | inline void setFrameFormat(const QTextFrameFormat &format); | |
31160 | QTextFrameFormat frameFormat() const { return QTextObject::format().toFrameFormat(); } | |
31161 | QTextCursor firstCursorPosition() const; | |
31162 | QTextCursor lastCursorPosition() const; | |
31163 | int firstPosition() const; | |
31164 | int lastPosition() const; | |
31165 | QTextFrameLayoutData *layoutData() const; | |
31166 | void setLayoutData(QTextFrameLayoutData *data); | |
31167 | QList<QTextFrame *> childFrames() const; | |
31168 | QTextFrame *parentFrame() const; | |
31169 | class __attribute__((visibility("default"))) iterator { | |
31170 | QTextFrame *f; | |
31171 | int b; | |
31172 | int e; | |
31173 | QTextFrame *cf; | |
31174 | int cb; | |
31175 | friend class QTextFrame; | |
31176 | friend class QTextTableCell; | |
31177 | friend class QTextDocumentLayoutPrivate; | |
31178 | iterator(QTextFrame *frame, int block, int begin, int end); | |
31179 | public: | |
31180 | iterator(); | |
31181 | iterator(const iterator &o); | |
31182 | iterator &operator=(const iterator &o); | |
31183 | QTextFrame *parentFrame() const { return f; } | |
31184 | QTextFrame *currentFrame() const; | |
31185 | QTextBlock currentBlock() const; | |
31186 | bool atEnd() const { return !cf && cb == e; } | |
31187 | inline bool operator==(const iterator &o) const { return f == o.f && cf == o.cf && cb == o.cb; } | |
31188 | inline bool operator!=(const iterator &o) const { return f != o.f || cf != o.cf || cb != o.cb; } | |
31189 | iterator &operator++(); | |
31190 | inline iterator operator++(int) { iterator tmp = *this; operator++(); return tmp; } | |
31191 | iterator &operator--(); | |
31192 | inline iterator operator--(int) { iterator tmp = *this; operator--(); return tmp; } | |
31193 | }; | |
31194 | friend class iterator; | |
31195 | typedef iterator Iterator; | |
31196 | iterator begin() const; | |
31197 | iterator end() const; | |
31198 | protected: | |
31199 | QTextFrame(QTextFramePrivate &p, QTextDocument *doc); | |
31200 | private: | |
31201 | friend class QTextDocumentPrivate; | |
31202 | inline QTextFramePrivate* d_func() { return reinterpret_cast<QTextFramePrivate *>(d_ptr); } inline const QTextFramePrivate* d_func() const { return reinterpret_cast<const QTextFramePrivate *>(d_ptr); } friend class QTextFramePrivate; | |
31203 | QTextFrame(const QTextFrame &); QTextFrame &operator=(const QTextFrame &); | |
31204 | }; | |
31205 | template <> class QTypeInfo<QTextFrame::iterator> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextFrame::iterator)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextFrame::iterator"; } }; | |
31206 | inline void QTextFrame::setFrameFormat(const QTextFrameFormat &aformat) | |
31207 | { QTextObject::setFormat(aformat); } | |
31208 | class __attribute__((visibility("default"))) QTextBlockUserData { | |
31209 | public: | |
31210 | virtual ~QTextBlockUserData(); | |
31211 | }; | |
31212 | class __attribute__((visibility("default"))) QTextBlock | |
31213 | { | |
31214 | friend class QSyntaxHighlighter; | |
31215 | public: | |
31216 | inline QTextBlock(QTextDocumentPrivate *priv, int b) : p(priv), n(b) {} | |
31217 | inline QTextBlock() : p(0), n(0) {} | |
31218 | inline QTextBlock(const QTextBlock &o) : p(o.p), n(o.n) {} | |
31219 | inline QTextBlock &operator=(const QTextBlock &o) { p = o.p; n = o.n; return *this; } | |
31220 | inline bool isValid() const { return p != 0 && n != 0; } | |
31221 | inline bool operator==(const QTextBlock &o) const { return p == o.p && n == o.n; } | |
31222 | inline bool operator!=(const QTextBlock &o) const { return p != o.p || n != o.n; } | |
31223 | inline bool operator<(const QTextBlock &o) const { return position() < o.position(); } | |
31224 | int position() const; | |
31225 | int length() const; | |
31226 | bool contains(int position) const; | |
31227 | QTextLayout *layout() const; | |
31228 | void clearLayout(); | |
31229 | QTextBlockFormat blockFormat() const; | |
31230 | int blockFormatIndex() const; | |
31231 | QTextCharFormat charFormat() const; | |
31232 | int charFormatIndex() const; | |
31233 | QString text() const; | |
31234 | const QTextDocument *document() const; | |
31235 | QTextList *textList() const; | |
31236 | QTextBlockUserData *userData() const; | |
31237 | void setUserData(QTextBlockUserData *data); | |
31238 | int userState() const; | |
31239 | void setUserState(int state); | |
31240 | int revision() const; | |
31241 | void setRevision(int rev); | |
31242 | bool isVisible() const; | |
31243 | void setVisible(bool visible); | |
31244 | int blockNumber() const; | |
31245 | int firstLineNumber() const; | |
31246 | void setLineCount(int count); | |
31247 | int lineCount() const; | |
31248 | class __attribute__((visibility("default"))) iterator { | |
31249 | const QTextDocumentPrivate *p; | |
31250 | int b; | |
31251 | int e; | |
31252 | int n; | |
31253 | friend class QTextBlock; | |
31254 | iterator(const QTextDocumentPrivate *priv, int begin, int end, int f) : p(priv), b(begin), e(end), n(f) {} | |
31255 | public: | |
31256 | iterator() : p(0), b(0), e(0), n(0) {} | |
31257 | iterator(const iterator &o) : p(o.p), b(o.b), e(o.e), n(o.n) {} | |
31258 | QTextFragment fragment() const; | |
31259 | bool atEnd() const { return n == e; } | |
31260 | inline bool operator==(const iterator &o) const { return p == o.p && n == o.n; } | |
31261 | inline bool operator!=(const iterator &o) const { return p != o.p || n != o.n; } | |
31262 | iterator &operator++(); | |
31263 | inline iterator operator++(int) { iterator tmp = *this; operator++(); return tmp; } | |
31264 | iterator &operator--(); | |
31265 | inline iterator operator--(int) { iterator tmp = *this; operator--(); return tmp; } | |
31266 | }; | |
31267 | typedef iterator Iterator; | |
31268 | iterator begin() const; | |
31269 | iterator end() const; | |
31270 | QTextBlock next() const; | |
31271 | QTextBlock previous() const; | |
31272 | inline QTextDocumentPrivate *docHandle() const { return p; } | |
31273 | inline int fragmentIndex() const { return n; } | |
31274 | private: | |
31275 | QTextDocumentPrivate *p; | |
31276 | int n; | |
31277 | friend class QTextDocumentPrivate; | |
31278 | friend class QTextLayout; | |
31279 | }; | |
31280 | template <> class QTypeInfo<QTextBlock> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextBlock)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextBlock"; } }; | |
31281 | template <> class QTypeInfo<QTextBlock::iterator> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextBlock::iterator)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextBlock::iterator"; } }; | |
31282 | class __attribute__((visibility("default"))) QTextFragment | |
31283 | { | |
31284 | public: | |
31285 | inline QTextFragment(const QTextDocumentPrivate *priv, int f, int fe) : p(priv), n(f), ne(fe) {} | |
31286 | inline QTextFragment() : p(0), n(0), ne(0) {} | |
31287 | inline QTextFragment(const QTextFragment &o) : p(o.p), n(o.n), ne(o.ne) {} | |
31288 | inline QTextFragment &operator=(const QTextFragment &o) { p = o.p; n = o.n; ne = o.ne; return *this; } | |
31289 | inline bool isValid() const { return p && n; } | |
31290 | inline bool operator==(const QTextFragment &o) const { return p == o.p && n == o.n; } | |
31291 | inline bool operator!=(const QTextFragment &o) const { return p != o.p || n != o.n; } | |
31292 | inline bool operator<(const QTextFragment &o) const { return position() < o.position(); } | |
31293 | int position() const; | |
31294 | int length() const; | |
31295 | bool contains(int position) const; | |
31296 | QTextCharFormat charFormat() const; | |
31297 | int charFormatIndex() const; | |
31298 | QString text() const; | |
31299 | private: | |
31300 | const QTextDocumentPrivate *p; | |
31301 | int n; | |
31302 | int ne; | |
31303 | }; | |
31304 | template <> class QTypeInfo<QTextFragment> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextFragment)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextFragment"; } }; | |
31305 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
31306 | template <class T> | |
31307 | class QPointer | |
31308 | { | |
31309 | QObject *o; | |
31310 | public: | |
31311 | inline QPointer() : o(0) {} | |
31312 | inline QPointer(T *p) : o(p) | |
31313 | { QMetaObject::addGuard(&o); } | |
31314 | inline QPointer(const QPointer<T> &p) : o(p.o) | |
31315 | { QMetaObject::addGuard(&o); } | |
31316 | inline ~QPointer() | |
31317 | { QMetaObject::removeGuard(&o); } | |
31318 | inline QPointer<T> &operator=(const QPointer<T> &p) | |
31319 | { if (this != &p) QMetaObject::changeGuard(&o, p.o); return *this; } | |
31320 | inline QPointer<T> &operator=(T* p) | |
31321 | { if (o != p) QMetaObject::changeGuard(&o, p); return *this; } | |
31322 | inline bool isNull() const | |
31323 | { return !o; } | |
31324 | inline T* operator->() const | |
31325 | { return static_cast<T*>(const_cast<QObject*>(o)); } | |
31326 | inline T& operator*() const | |
31327 | { return *static_cast<T*>(const_cast<QObject*>(o)); } | |
31328 | inline operator T*() const | |
31329 | { return static_cast<T*>(const_cast<QObject*>(o)); } | |
31330 | inline T* data() const | |
31331 | { return static_cast<T*>(const_cast<QObject*>(o)); } | |
31332 | }; | |
31333 | template <class T> | |
31334 | inline bool operator==(const T *o, const QPointer<T> &p) | |
31335 | { return o == p.operator->(); } | |
31336 | template<class T> | |
31337 | inline bool operator==(const QPointer<T> &p, const T *o) | |
31338 | { return p.operator->() == o; } | |
31339 | template <class T> | |
31340 | inline bool operator==(T *o, const QPointer<T> &p) | |
31341 | { return o == p.operator->(); } | |
31342 | template<class T> | |
31343 | inline bool operator==(const QPointer<T> &p, T *o) | |
31344 | { return p.operator->() == o; } | |
31345 | template<class T> | |
31346 | inline bool operator==(const QPointer<T> &p1, const QPointer<T> &p2) | |
31347 | { return p1.operator->() == p2.operator->(); } | |
31348 | template <class T> | |
31349 | inline bool operator!=(const T *o, const QPointer<T> &p) | |
31350 | { return o != p.operator->(); } | |
31351 | template<class T> | |
31352 | inline bool operator!= (const QPointer<T> &p, const T *o) | |
31353 | { return p.operator->() != o; } | |
31354 | template <class T> | |
31355 | inline bool operator!=(T *o, const QPointer<T> &p) | |
31356 | { return o != p.operator->(); } | |
31357 | template<class T> | |
31358 | inline bool operator!= (const QPointer<T> &p, T *o) | |
31359 | { return p.operator->() != o; } | |
31360 | template<class T> | |
31361 | inline bool operator!= (const QPointer<T> &p1, const QPointer<T> &p2) | |
31362 | { return p1.operator->() != p2.operator->() ; } | |
31363 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
31364 | struct QReadWriteLockPrivate; | |
31365 | class __attribute__((visibility("default"))) QReadWriteLock | |
31366 | { | |
31367 | public: | |
31368 | enum RecursionMode { NonRecursive, Recursive }; | |
31369 | QReadWriteLock(); | |
31370 | QReadWriteLock(RecursionMode recursionMode); | |
31371 | ~QReadWriteLock(); | |
31372 | void lockForRead(); | |
31373 | bool tryLockForRead(); | |
31374 | bool tryLockForRead(int timeout); | |
31375 | void lockForWrite(); | |
31376 | bool tryLockForWrite(); | |
31377 | bool tryLockForWrite(int timeout); | |
31378 | void unlock(); | |
31379 | private: | |
31380 | QReadWriteLock(const QReadWriteLock &); QReadWriteLock &operator=(const QReadWriteLock &); | |
31381 | QReadWriteLockPrivate *d; | |
31382 | friend class QWaitCondition; | |
31383 | }; | |
31384 | class __attribute__((visibility("default"))) QReadLocker | |
31385 | { | |
31386 | public: | |
31387 | inline QReadLocker(QReadWriteLock *readWriteLock); | |
31388 | inline ~QReadLocker() | |
31389 | { unlock(); } | |
31390 | inline void unlock() | |
31391 | { | |
31392 | if (q_lock) { | |
31393 | if ((q_val & quintptr(1u)) == quintptr(1u)) { | |
31394 | q_val &= ~quintptr(1u); | |
31395 | q_lock->unlock(); | |
31396 | } | |
31397 | } | |
31398 | } | |
31399 | inline void relock() | |
31400 | { | |
31401 | if (q_lock) { | |
31402 | if ((q_val & quintptr(1u)) == quintptr(0u)) { | |
31403 | q_lock->lockForRead(); | |
31404 | q_val |= quintptr(1u); | |
31405 | } | |
31406 | } | |
31407 | } | |
31408 | inline QReadWriteLock *readWriteLock() const | |
31409 | { return reinterpret_cast<QReadWriteLock *>(q_val & ~quintptr(1u)); } | |
31410 | private: | |
31411 | QReadLocker(const QReadLocker &); QReadLocker &operator=(const QReadLocker &); | |
31412 | union { | |
31413 | QReadWriteLock *q_lock; | |
31414 | quintptr q_val; | |
31415 | }; | |
31416 | }; | |
31417 | inline QReadLocker::QReadLocker(QReadWriteLock *areadWriteLock) | |
31418 | : q_lock(areadWriteLock) | |
31419 | { | |
31420 | qt_noop(); | |
31421 | relock(); | |
31422 | } | |
31423 | class __attribute__((visibility("default"))) QWriteLocker | |
31424 | { | |
31425 | public: | |
31426 | inline QWriteLocker(QReadWriteLock *readWriteLock); | |
31427 | inline ~QWriteLocker() | |
31428 | { unlock(); } | |
31429 | inline void unlock() | |
31430 | { | |
31431 | if (q_lock) { | |
31432 | if ((q_val & quintptr(1u)) == quintptr(1u)) { | |
31433 | q_val &= ~quintptr(1u); | |
31434 | q_lock->unlock(); | |
31435 | } | |
31436 | } | |
31437 | } | |
31438 | inline void relock() | |
31439 | { | |
31440 | if (q_lock) { | |
31441 | if ((q_val & quintptr(1u)) == quintptr(0u)) { | |
31442 | q_lock->lockForWrite(); | |
31443 | q_val |= quintptr(1u); | |
31444 | } | |
31445 | } | |
31446 | } | |
31447 | inline QReadWriteLock *readWriteLock() const | |
31448 | { return reinterpret_cast<QReadWriteLock *>(q_val & ~quintptr(1u)); } | |
31449 | private: | |
31450 | QWriteLocker(const QWriteLocker &); QWriteLocker &operator=(const QWriteLocker &); | |
31451 | union{ | |
31452 | QReadWriteLock *q_lock; | |
31453 | quintptr q_val; | |
31454 | }; | |
31455 | }; | |
31456 | inline QWriteLocker::QWriteLocker(QReadWriteLock *areadWriteLock) | |
31457 | : q_lock(areadWriteLock) | |
31458 | { | |
31459 | qt_noop(); | |
31460 | relock(); | |
31461 | } | |
31462 | class QVariant; | |
31463 | class QThreadData; | |
31464 | class QObjectConnectionListVector; | |
31465 | struct QSignalSpyCallbackSet | |
31466 | { | |
31467 | typedef void (*BeginCallback)(QObject *caller, int method_index, void **argv); | |
31468 | typedef void (*EndCallback)(QObject *caller, int method_index); | |
31469 | BeginCallback signal_begin_callback, | |
31470 | slot_begin_callback; | |
31471 | EndCallback signal_end_callback, | |
31472 | slot_end_callback; | |
31473 | }; | |
31474 | void __attribute__((visibility("default"))) qt_register_signal_spy_callbacks(const QSignalSpyCallbackSet &callback_set); | |
31475 | extern QSignalSpyCallbackSet __attribute__((visibility("default"))) qt_signal_spy_callback_set; | |
31476 | inline QObjectData::~QObjectData() {} | |
31477 | enum { QObjectPrivateVersion = 0x040501 }; | |
31478 | class __attribute__((visibility("default"))) QObjectPrivate : public QObjectData | |
31479 | { | |
31480 | inline QObject* q_func() { return static_cast<QObject *>(q_ptr); } inline const QObject* q_func() const { return static_cast<const QObject *>(q_ptr); } friend class QObject; | |
31481 | public: | |
31482 | QObjectPrivate(int version = QObjectPrivateVersion); | |
31483 | virtual ~QObjectPrivate(); | |
31484 | QList<QObject *> unused; | |
31485 | QThreadData *threadData; | |
31486 | void moveToThread_helper(); | |
31487 | void setThreadData_helper(QThreadData *currentData, QThreadData *targetData); | |
31488 | void _q_reregisterTimers(void *pointer); | |
31489 | struct Sender | |
31490 | { | |
31491 | QObject *sender; | |
31492 | int signal; | |
31493 | int ref; | |
31494 | }; | |
31495 | Sender *currentSender; | |
31496 | QObject *currentChildBeingDeleted; | |
31497 | bool isSender(const QObject *receiver, const char *signal) const; | |
31498 | QObjectList receiverList(const char *signal) const; | |
31499 | QObjectList senderList() const; | |
31500 | QList<QPointer<QObject> > eventFilters; | |
31501 | void setParent_helper(QObject *); | |
31502 | void deleteChildren(); | |
31503 | static void clearGuards(QObject *); | |
31504 | struct ExtraData | |
31505 | { | |
31506 | QVector<QObjectUserData *> userData; | |
31507 | QList<QByteArray> propertyNames; | |
31508 | QList<QVariant> propertyValues; | |
31509 | }; | |
31510 | ExtraData *extraData; | |
31511 | mutable quint32 connectedSignals; | |
31512 | QString objectName; | |
31513 | struct Connection | |
31514 | { | |
31515 | QObject *receiver; | |
31516 | int method; | |
31517 | uint connectionType : 3; | |
31518 | QBasicAtomicPointer<int> argumentTypes; | |
31519 | }; | |
31520 | typedef QList<Connection> ConnectionList; | |
31521 | QObjectConnectionListVector *connectionLists; | |
31522 | void addConnection(int signal, Connection *c); | |
31523 | void removeReceiver(int signal, QObject *receiver); | |
31524 | void cleanConnectionLists(); | |
31525 | QList<Sender> senders; | |
31526 | void refSender(QObject *sender, int signal); | |
31527 | void derefSender(QObject *sender, int signal); | |
31528 | void removeSender(QObject *sender, int signal); | |
31529 | static Sender *setCurrentSender(QObject *receiver, | |
31530 | Sender *sender); | |
31531 | static void resetCurrentSender(QObject *receiver, | |
31532 | Sender *currentSender, | |
31533 | Sender *previousSender); | |
31534 | static int *setDeleteWatch(QObjectPrivate *d, int *newWatch); | |
31535 | static void resetDeleteWatch(QObjectPrivate *d, int *oldWatch, int deleteWatch); | |
31536 | int *deleteWatch; | |
31537 | static QObjectPrivate *get(QObject *o) { | |
31538 | return o->d_func(); | |
31539 | } | |
31540 | }; | |
31541 | template <> class QTypeInfo<QObjectPrivate::Connection> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QObjectPrivate::Connection)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QObjectPrivate::Connection"; } }; | |
31542 | template <> class QTypeInfo<QObjectPrivate::Sender> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QObjectPrivate::Sender)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QObjectPrivate::Sender"; } }; | |
31543 | class QSemaphore; | |
31544 | class __attribute__((visibility("default"))) QMetaCallEvent : public QEvent | |
31545 | { | |
31546 | public: | |
31547 | QMetaCallEvent(int id, const QObject *sender, int signalId, | |
31548 | int nargs = 0, int *types = 0, void **args = 0, QSemaphore *semaphore = 0); | |
31549 | ~QMetaCallEvent(); | |
31550 | inline int id() const { return id_; } | |
31551 | inline const QObject *sender() const { return sender_; } | |
31552 | inline int signalId() const { return signalId_; } | |
31553 | inline void **args() const { return args_; } | |
31554 | virtual int placeMetaCall(QObject *object); | |
31555 | private: | |
31556 | int id_; | |
31557 | const QObject *sender_; | |
31558 | int signalId_; | |
31559 | int nargs_; | |
31560 | int *types_; | |
31561 | void **args_; | |
31562 | QSemaphore *semaphore_; | |
31563 | }; | |
31564 | class __attribute__((visibility("default"))) QBoolBlocker | |
31565 | { | |
31566 | public: | |
31567 | inline QBoolBlocker(bool &b, bool value=true):block(b), reset(b){block = value;} | |
31568 | inline ~QBoolBlocker(){block = reset; } | |
31569 | private: | |
31570 | bool █ | |
31571 | bool reset; | |
31572 | }; | |
31573 | void __attribute__((visibility("default"))) qDeleteInEventHandler(QObject *o); | |
31574 | int __attribute__((visibility("default"))) qAllocMore(int alloc, int extra); | |
31575 | template <int N = 1> | |
31576 | class QFragment | |
31577 | { | |
31578 | public: | |
31579 | quint32 parent; | |
31580 | quint32 left; | |
31581 | quint32 right; | |
31582 | quint32 color; | |
31583 | quint32 size_left_array[N]; | |
31584 | quint32 size_array[N]; | |
31585 | enum {size_array_max = N }; | |
31586 | }; | |
31587 | template <class Fragment> | |
31588 | class QFragmentMapData | |
31589 | { | |
31590 | enum Color { Red, Black }; | |
31591 | public: | |
31592 | QFragmentMapData(); | |
31593 | ~QFragmentMapData(); | |
31594 | void init(); | |
31595 | class Header | |
31596 | { | |
31597 | public: | |
31598 | quint32 root; | |
31599 | quint32 tag; | |
31600 | quint32 freelist; | |
31601 | quint32 node_count; | |
31602 | quint32 allocated; | |
31603 | }; | |
31604 | enum {fragmentSize = sizeof(Fragment) }; | |
31605 | int length(uint field = 0) const; | |
31606 | inline Fragment *fragment(uint index) { | |
31607 | return (fragments + index); | |
31608 | } | |
31609 | inline const Fragment *fragment(uint index) const { | |
31610 | return (fragments + index); | |
31611 | } | |
31612 | inline Fragment &F(uint index) { return fragments[index] ; } | |
31613 | inline const Fragment &F(uint index) const { return fragments[index] ; } | |
31614 | inline bool isRoot(uint index) const { | |
31615 | return !fragment(index)->parent; | |
31616 | } | |
31617 | inline uint position(uint node, uint field = 0) const { | |
31618 | qt_noop(); | |
31619 | const Fragment *f = fragment(node); | |
31620 | uint offset = f->size_left_array[field]; | |
31621 | while (f->parent) { | |
31622 | uint p = f->parent; | |
31623 | f = fragment(p); | |
31624 | if (f->right == node) | |
31625 | offset += f->size_left_array[field] + f->size_array[field]; | |
31626 | node = p; | |
31627 | } | |
31628 | return offset; | |
31629 | } | |
31630 | inline uint sizeRight(uint node, uint field = 0) const { | |
31631 | qt_noop(); | |
31632 | uint sr = 0; | |
31633 | const Fragment *f = fragment(node); | |
31634 | node = f->right; | |
31635 | while (node) { | |
31636 | f = fragment(node); | |
31637 | sr += f->size_left_array[field] + f->size_array[field]; | |
31638 | node = f->right; | |
31639 | } | |
31640 | return sr; | |
31641 | } | |
31642 | inline uint sizeLeft(uint node, uint field = 0) const { | |
31643 | qt_noop(); | |
31644 | return fragment(node)->size_left_array[field]; | |
31645 | } | |
31646 | inline uint size(uint node, uint field = 0) const { | |
31647 | qt_noop(); | |
31648 | return fragment(node)->size_array[field]; | |
31649 | } | |
31650 | inline void setSize(uint node, int new_size, uint field = 0) { | |
31651 | qt_noop(); | |
31652 | Fragment *f = fragment(node); | |
31653 | int diff = new_size - f->size_array[field]; | |
31654 | f->size_array[field] = new_size; | |
31655 | while (f->parent) { | |
31656 | uint p = f->parent; | |
31657 | f = fragment(p); | |
31658 | if (f->left == node) | |
31659 | f->size_left_array[field] += diff; | |
31660 | node = p; | |
31661 | } | |
31662 | } | |
31663 | uint findNode(int k, uint field = 0) const; | |
31664 | uint insert_single(int key, uint length); | |
31665 | uint erase_single(uint f); | |
31666 | uint minimum(uint n) const { | |
31667 | while (n && fragment(n)->left) | |
31668 | n = fragment(n)->left; | |
31669 | return n; | |
31670 | } | |
31671 | uint maximum(uint n) const { | |
31672 | while (n && fragment(n)->right) | |
31673 | n = fragment(n)->right; | |
31674 | return n; | |
31675 | } | |
31676 | uint next(uint n) const; | |
31677 | uint previous(uint n) const; | |
31678 | inline uint root() const { | |
31679 | qt_noop(); | |
31680 | return head->root; | |
31681 | } | |
31682 | inline void setRoot(uint new_root) { | |
31683 | qt_noop(); | |
31684 | head->root = new_root; | |
31685 | } | |
31686 | union { | |
31687 | Header *head; | |
31688 | Fragment *fragments; | |
31689 | }; | |
31690 | private: | |
31691 | void rotateLeft(uint x); | |
31692 | void rotateRight(uint x); | |
31693 | void rebalance(uint x); | |
31694 | void removeAndRebalance(uint z); | |
31695 | uint createFragment(); | |
31696 | void freeFragment(uint f); | |
31697 | }; | |
31698 | template <class Fragment> | |
31699 | QFragmentMapData<Fragment>::QFragmentMapData() | |
31700 | { | |
31701 | init(); | |
31702 | } | |
31703 | template <class Fragment> | |
31704 | void QFragmentMapData<Fragment>::init() | |
31705 | { | |
31706 | fragments = (Fragment *)malloc(64*fragmentSize); | |
31707 | head->tag = (((quint32)'p') << 24) | (((quint32)'m') << 16) | (((quint32)'a') << 8) | 'p'; | |
31708 | head->root = 0; | |
31709 | head->freelist = 1; | |
31710 | head->node_count = 0; | |
31711 | head->allocated = 64; | |
31712 | F(head->freelist).right = 0; | |
31713 | } | |
31714 | template <class Fragment> | |
31715 | QFragmentMapData<Fragment>::~QFragmentMapData() | |
31716 | { | |
31717 | free(head); | |
31718 | } | |
31719 | template <class Fragment> | |
31720 | uint QFragmentMapData<Fragment>::createFragment() | |
31721 | { | |
31722 | qt_noop(); | |
31723 | uint freePos = head->freelist; | |
31724 | if (freePos == head->allocated) { | |
31725 | uint needed = qAllocMore((freePos+1)*fragmentSize, 0); | |
31726 | qt_noop(); | |
31727 | fragments = (Fragment *)realloc(fragments, needed); | |
31728 | head->allocated = needed/fragmentSize; | |
31729 | F(freePos).right = 0; | |
31730 | } | |
31731 | uint nextPos = F(freePos).right; | |
31732 | if (!nextPos) { | |
31733 | nextPos = freePos+1; | |
31734 | if (nextPos < head->allocated) | |
31735 | F(nextPos).right = 0; | |
31736 | } | |
31737 | head->freelist = nextPos; | |
31738 | ++head->node_count; | |
31739 | return freePos; | |
31740 | } | |
31741 | template <class Fragment> | |
31742 | void QFragmentMapData<Fragment>::freeFragment(uint i) | |
31743 | { | |
31744 | F(i).right = head->freelist; | |
31745 | head->freelist = i; | |
31746 | --head->node_count; | |
31747 | } | |
31748 | template <class Fragment> | |
31749 | uint QFragmentMapData<Fragment>::next(uint n) const { | |
31750 | qt_noop(); | |
31751 | if (F(n).right) { | |
31752 | n = F(n).right; | |
31753 | while (F(n).left) | |
31754 | n = F(n).left; | |
31755 | } else { | |
31756 | uint y = F(n).parent; | |
31757 | while (F(n).parent && n == F(y).right) { | |
31758 | n = y; | |
31759 | y = F(y).parent; | |
31760 | } | |
31761 | n = y; | |
31762 | } | |
31763 | return n; | |
31764 | } | |
31765 | template <class Fragment> | |
31766 | uint QFragmentMapData<Fragment>::previous(uint n) const { | |
31767 | if (!n) | |
31768 | return maximum(root()); | |
31769 | if (F(n).left) { | |
31770 | n = F(n).left; | |
31771 | while (F(n).right) | |
31772 | n = F(n).right; | |
31773 | } else { | |
31774 | uint y = F(n).parent; | |
31775 | while (F(n).parent && n == F(y).left) { | |
31776 | n = y; | |
31777 | y = F(y).parent; | |
31778 | } | |
31779 | n = y; | |
31780 | } | |
31781 | return n; | |
31782 | } | |
31783 | template <class Fragment> | |
31784 | void QFragmentMapData<Fragment>::rotateLeft(uint x) | |
31785 | { | |
31786 | uint p = F(x).parent; | |
31787 | uint y = F(x).right; | |
31788 | if (y) { | |
31789 | F(x).right = F(y).left; | |
31790 | if (F(y).left) | |
31791 | F(F(y).left).parent = x; | |
31792 | F(y).left = x; | |
31793 | F(y).parent = p; | |
31794 | } else { | |
31795 | F(x).right = 0; | |
31796 | } | |
31797 | if (!p) { | |
31798 | qt_noop(); | |
31799 | head->root = y; | |
31800 | } | |
31801 | else if (x == F(p).left) | |
31802 | F(p).left = y; | |
31803 | else | |
31804 | F(p).right = y; | |
31805 | F(x).parent = y; | |
31806 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31807 | F(y).size_left_array[field] += F(x).size_left_array[field] + F(x).size_array[field]; | |
31808 | } | |
31809 | template <class Fragment> | |
31810 | void QFragmentMapData<Fragment>::rotateRight(uint x) | |
31811 | { | |
31812 | uint y = F(x).left; | |
31813 | uint p = F(x).parent; | |
31814 | if (y) { | |
31815 | F(x).left = F(y).right; | |
31816 | if (F(y).right) | |
31817 | F(F(y).right).parent = x; | |
31818 | F(y).right = x; | |
31819 | F(y).parent = p; | |
31820 | } else { | |
31821 | F(x).left = 0; | |
31822 | } | |
31823 | if (!p) { | |
31824 | qt_noop(); | |
31825 | head->root = y; | |
31826 | } | |
31827 | else if (x == F(p).right) | |
31828 | F(p).right = y; | |
31829 | else | |
31830 | F(p).left = y; | |
31831 | F(x).parent = y; | |
31832 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31833 | F(x).size_left_array[field] -= F(y).size_left_array[field] + F(y).size_array[field]; | |
31834 | } | |
31835 | template <class Fragment> | |
31836 | void QFragmentMapData<Fragment>::rebalance(uint x) | |
31837 | { | |
31838 | F(x).color = Red; | |
31839 | while (F(x).parent && F(F(x).parent).color == Red) { | |
31840 | uint p = F(x).parent; | |
31841 | uint pp = F(p).parent; | |
31842 | qt_noop(); | |
31843 | if (p == F(pp).left) { | |
31844 | uint y = F(pp).right; | |
31845 | if (y && F(y).color == Red) { | |
31846 | F(p).color = Black; | |
31847 | F(y).color = Black; | |
31848 | F(pp).color = Red; | |
31849 | x = pp; | |
31850 | } else { | |
31851 | if (x == F(p).right) { | |
31852 | x = p; | |
31853 | rotateLeft(x); | |
31854 | p = F(x).parent; | |
31855 | pp = F(p).parent; | |
31856 | } | |
31857 | F(p).color = Black; | |
31858 | if (pp) { | |
31859 | F(pp).color = Red; | |
31860 | rotateRight(pp); | |
31861 | } | |
31862 | } | |
31863 | } else { | |
31864 | uint y = F(pp).left; | |
31865 | if (y && F(y).color == Red) { | |
31866 | F(p).color = Black; | |
31867 | F(y).color = Black; | |
31868 | F(pp).color = Red; | |
31869 | x = pp; | |
31870 | } else { | |
31871 | if (x == F(p).left) { | |
31872 | x = p; | |
31873 | rotateRight(x); | |
31874 | p = F(x).parent; | |
31875 | pp = F(p).parent; | |
31876 | } | |
31877 | F(p).color = Black; | |
31878 | if (pp) { | |
31879 | F(pp).color = Red; | |
31880 | rotateLeft(pp); | |
31881 | } | |
31882 | } | |
31883 | } | |
31884 | } | |
31885 | F(root()).color = Black; | |
31886 | } | |
31887 | template <class Fragment> | |
31888 | uint QFragmentMapData<Fragment>::erase_single(uint z) | |
31889 | { | |
31890 | uint w = previous(z); | |
31891 | uint y = z; | |
31892 | uint x; | |
31893 | uint p; | |
31894 | if (!F(y).left) { | |
31895 | x = F(y).right; | |
31896 | } else if (!F(y).right) { | |
31897 | x = F(y).left; | |
31898 | } else { | |
31899 | y = F(y).right; | |
31900 | while (F(y).left) | |
31901 | y = F(y).left; | |
31902 | x = F(y).right; | |
31903 | } | |
31904 | if (y != z) { | |
31905 | F(F(z).left).parent = y; | |
31906 | F(y).left = F(z).left; | |
31907 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31908 | F(y).size_left_array[field] = F(z).size_left_array[field]; | |
31909 | if (y != F(z).right) { | |
31910 | p = F(y).parent; | |
31911 | if (x) | |
31912 | F(x).parent = p; | |
31913 | F(p).left = x; | |
31914 | F(y).right = F(z).right; | |
31915 | F(F(z).right).parent = y; | |
31916 | uint n = p; | |
31917 | while (n != y) { | |
31918 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31919 | F(n).size_left_array[field] -= F(y).size_array[field]; | |
31920 | n = F(n).parent; | |
31921 | } | |
31922 | } else { | |
31923 | p = y; | |
31924 | } | |
31925 | uint zp = F(z).parent; | |
31926 | if (!zp) { | |
31927 | qt_noop(); | |
31928 | head->root = y; | |
31929 | } else if (F(zp).left == z) { | |
31930 | F(zp).left = y; | |
31931 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31932 | F(zp).size_left_array[field] -= F(z).size_array[field]; | |
31933 | } else { | |
31934 | F(zp).right = y; | |
31935 | } | |
31936 | F(y).parent = zp; | |
31937 | uint c = F(y).color; | |
31938 | F(y).color = F(z).color; | |
31939 | F(z).color = c; | |
31940 | y = z; | |
31941 | } else { | |
31942 | p = F(z).parent; | |
31943 | if (x) | |
31944 | F(x).parent = p; | |
31945 | if (!p) { | |
31946 | qt_noop(); | |
31947 | head->root = x; | |
31948 | } else if (F(p).left == z) { | |
31949 | F(p).left = x; | |
31950 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31951 | F(p).size_left_array[field] -= F(z).size_array[field]; | |
31952 | } else { | |
31953 | F(p).right = x; | |
31954 | } | |
31955 | } | |
31956 | uint n = z; | |
31957 | while (F(n).parent) { | |
31958 | uint p = F(n).parent; | |
31959 | if (F(p).left == n) { | |
31960 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
31961 | F(p).size_left_array[field] -= F(z).size_array[field]; | |
31962 | } | |
31963 | n = p; | |
31964 | } | |
31965 | freeFragment(z); | |
31966 | if (F(y).color != Red) { | |
31967 | while (F(x).parent && (x == 0 || F(x).color == Black)) { | |
31968 | if (x == F(p).left) { | |
31969 | uint w = F(p).right; | |
31970 | if (F(w).color == Red) { | |
31971 | F(w).color = Black; | |
31972 | F(p).color = Red; | |
31973 | rotateLeft(p); | |
31974 | w = F(p).right; | |
31975 | } | |
31976 | if ((F(w).left == 0 || F(F(w).left).color == Black) && | |
31977 | (F(w).right == 0 || F(F(w).right).color == Black)) { | |
31978 | F(w).color = Red; | |
31979 | x = p; | |
31980 | p = F(x).parent; | |
31981 | } else { | |
31982 | if (F(w).right == 0 || F(F(w).right).color == Black) { | |
31983 | if (F(w).left) | |
31984 | F(F(w).left).color = Black; | |
31985 | F(w).color = Red; | |
31986 | rotateRight(F(p).right); | |
31987 | w = F(p).right; | |
31988 | } | |
31989 | F(w).color = F(p).color; | |
31990 | F(p).color = Black; | |
31991 | if (F(w).right) | |
31992 | F(F(w).right).color = Black; | |
31993 | rotateLeft(p); | |
31994 | break; | |
31995 | } | |
31996 | } else { | |
31997 | uint w = F(p).left; | |
31998 | if (F(w).color == Red) { | |
31999 | F(w).color = Black; | |
32000 | F(p).color = Red; | |
32001 | rotateRight(p); | |
32002 | w = F(p).left; | |
32003 | } | |
32004 | if ((F(w).right == 0 || F(F(w).right).color == Black) && | |
32005 | (F(w).left == 0 || F(F(w).left).color == Black)) { | |
32006 | F(w).color = Red; | |
32007 | x = p; | |
32008 | p = F(x).parent; | |
32009 | } else { | |
32010 | if (F(w).left == 0 || F(F(w).left).color == Black) { | |
32011 | if (F(w).right) | |
32012 | F(F(w).right).color = Black; | |
32013 | F(w).color = Red; | |
32014 | rotateLeft(F(p).left); | |
32015 | w = F(p).left; | |
32016 | } | |
32017 | F(w).color = F(p).color; | |
32018 | F(p).color = Black; | |
32019 | if (F(w).left) | |
32020 | F(F(w).left).color = Black; | |
32021 | rotateRight(p); | |
32022 | break; | |
32023 | } | |
32024 | } | |
32025 | } | |
32026 | if (x) | |
32027 | F(x).color = Black; | |
32028 | } | |
32029 | return w; | |
32030 | } | |
32031 | template <class Fragment> | |
32032 | uint QFragmentMapData<Fragment>::findNode(int k, uint field) const | |
32033 | { | |
32034 | qt_noop(); | |
32035 | uint x = root(); | |
32036 | uint s = k; | |
32037 | while (x) { | |
32038 | if (sizeLeft(x, field) <= s) { | |
32039 | if (s < sizeLeft(x, field) + size(x, field)) | |
32040 | return x; | |
32041 | s -= sizeLeft(x, field) + size(x, field); | |
32042 | x = F(x).right; | |
32043 | } else { | |
32044 | x = F(x).left; | |
32045 | } | |
32046 | } | |
32047 | return 0; | |
32048 | } | |
32049 | template <class Fragment> | |
32050 | uint QFragmentMapData<Fragment>::insert_single(int key, uint length) | |
32051 | { | |
32052 | qt_noop(); | |
32053 | uint z = createFragment(); | |
32054 | F(z).left = 0; | |
32055 | F(z).right = 0; | |
32056 | F(z).size_array[0] = length; | |
32057 | for (uint field = 1; field < Fragment::size_array_max; ++field) | |
32058 | F(z).size_array[field] = 1; | |
32059 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
32060 | F(z).size_left_array[field] = 0; | |
32061 | uint y = 0; | |
32062 | uint x = root(); | |
32063 | qt_noop(); | |
32064 | uint s = key; | |
32065 | bool right = false; | |
32066 | while (x) { | |
32067 | y = x; | |
32068 | if (s <= F(x).size_left_array[0]) { | |
32069 | x = F(x).left; | |
32070 | right = false; | |
32071 | } else { | |
32072 | s -= F(x).size_left_array[0] + F(x).size_array[0]; | |
32073 | x = F(x).right; | |
32074 | right = true; | |
32075 | } | |
32076 | } | |
32077 | F(z).parent = y; | |
32078 | if (!y) { | |
32079 | head->root = z; | |
32080 | } else if (!right) { | |
32081 | F(y).left = z; | |
32082 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
32083 | F(y).size_left_array[field] = F(z).size_array[field]; | |
32084 | } else { | |
32085 | F(y).right = z; | |
32086 | } | |
32087 | while (y && F(y).parent) { | |
32088 | uint p = F(y).parent; | |
32089 | if (F(p).left == y) { | |
32090 | for (uint field = 0; field < Fragment::size_array_max; ++field) | |
32091 | F(p).size_left_array[field] += F(z).size_array[field]; | |
32092 | } | |
32093 | y = p; | |
32094 | } | |
32095 | rebalance(z); | |
32096 | return z; | |
32097 | } | |
32098 | template <class Fragment> | |
32099 | int QFragmentMapData<Fragment>::length(uint field) const { | |
32100 | uint root = this->root(); | |
32101 | return root ? sizeLeft(root, field) + size(root, field) + sizeRight(root, field) : 0; | |
32102 | } | |
32103 | template <class Fragment> | |
32104 | class QFragmentMap | |
32105 | { | |
32106 | public: | |
32107 | class Iterator | |
32108 | { | |
32109 | public: | |
32110 | QFragmentMap *pt; | |
32111 | quint32 n; | |
32112 | Iterator() : pt(0), n(0) {} | |
32113 | Iterator(QFragmentMap *p, int node) : pt(p), n(node) {} | |
32114 | Iterator(const Iterator& it) : pt(it.pt), n(it.n) {} | |
32115 | inline bool atEnd() const { return !n; } | |
32116 | bool operator==(const Iterator& it) const { return pt == it.pt && n == it.n; } | |
32117 | bool operator!=(const Iterator& it) const { return pt != it.pt || n != it.n; } | |
32118 | bool operator<(const Iterator &it) const { return position() < it.position(); } | |
32119 | Fragment *operator*() { qt_noop(); return pt->fragment(n); } | |
32120 | const Fragment *operator*() const { qt_noop(); return pt->fragment(n); } | |
32121 | Fragment *operator->() { qt_noop(); return pt->fragment(n); } | |
32122 | const Fragment *operator->() const { qt_noop(); return pt->fragment(n); } | |
32123 | int position() const { qt_noop(); return pt->data.position(n); } | |
32124 | const Fragment *value() const { qt_noop(); return pt->fragment(n); } | |
32125 | Fragment *value() { qt_noop(); return pt->fragment(n); } | |
32126 | Iterator& operator++() { | |
32127 | n = pt->data.next(n); | |
32128 | return *this; | |
32129 | } | |
32130 | Iterator& operator--() { | |
32131 | n = pt->data.previous(n); | |
32132 | return *this; | |
32133 | } | |
32134 | }; | |
32135 | class ConstIterator | |
32136 | { | |
32137 | public: | |
32138 | const QFragmentMap *pt; | |
32139 | quint32 n; | |
32140 | ConstIterator() : pt(0), n(0) {} | |
32141 | ConstIterator(const QFragmentMap *p, int node) : pt(p), n(node) {} | |
32142 | ConstIterator(const ConstIterator& it) : pt(it.pt), n(it.n) {} | |
32143 | ConstIterator(const Iterator& it) : pt(it.pt), n(it.n) {} | |
32144 | inline bool atEnd() const { return !n; } | |
32145 | bool operator==(const ConstIterator& it) const { return pt == it.pt && n == it.n; } | |
32146 | bool operator!=(const ConstIterator& it) const { return pt != it.pt || n != it.n; } | |
32147 | bool operator<(const ConstIterator &it) const { return position() < it.position(); } | |
32148 | const Fragment *operator*() const { qt_noop(); return pt->fragment(n); } | |
32149 | const Fragment *operator->() const { qt_noop(); return pt->fragment(n); } | |
32150 | int position() const { qt_noop(); return pt->data.position(n); } | |
32151 | int size() const { qt_noop(); return pt->data.size(n); } | |
32152 | const Fragment *value() const { qt_noop(); return pt->fragment(n); } | |
32153 | ConstIterator& operator++() { | |
32154 | n = pt->data.next(n); | |
32155 | return *this; | |
32156 | } | |
32157 | ConstIterator& operator--() { | |
32158 | n = pt->data.previous(n); | |
32159 | return *this; | |
32160 | } | |
32161 | }; | |
32162 | QFragmentMap() {} | |
32163 | ~QFragmentMap() | |
32164 | { | |
32165 | for (Iterator it = begin(); !it.atEnd(); ++it) | |
32166 | it.value()->free(); | |
32167 | } | |
32168 | inline void clear() { | |
32169 | for (Iterator it = begin(); !it.atEnd(); ++it) | |
32170 | it.value()->free(); | |
32171 | ::free(data.head); | |
32172 | data.init(); | |
32173 | } | |
32174 | inline Iterator begin() { return Iterator(this, data.minimum(data.root())); } | |
32175 | inline Iterator end() { return Iterator(this, 0); } | |
32176 | inline ConstIterator begin() const { return ConstIterator(this, data.minimum(data.root())); } | |
32177 | inline ConstIterator end() const { return ConstIterator(this, 0); } | |
32178 | inline ConstIterator last() const { return ConstIterator(this, data.maximum(data.root())); } | |
32179 | inline bool isEmpty() const { return data.head->node_count == 0; } | |
32180 | inline int numNodes() const { return data.head->node_count; } | |
32181 | int length(uint field = 0) const { return data.length(field); } | |
32182 | Iterator find(int k, uint field = 0) { return Iterator(this, data.findNode(k, field)); } | |
32183 | ConstIterator find(int k, uint field = 0) const { return ConstIterator(this, data.findNode(k, field)); } | |
32184 | uint findNode(int k, uint field = 0) const { return data.findNode(k, field); } | |
32185 | uint insert_single(int key, uint length) | |
32186 | { | |
32187 | uint f = data.insert_single(key, length); | |
32188 | if (f != 0) { | |
32189 | Fragment *frag = fragment(f); | |
32190 | qt_noop(); | |
32191 | frag->initialize(); | |
32192 | } | |
32193 | return f; | |
32194 | } | |
32195 | uint erase_single(uint f) | |
32196 | { | |
32197 | if (f != 0) { | |
32198 | Fragment *frag = fragment(f); | |
32199 | qt_noop(); | |
32200 | frag->free(); | |
32201 | } | |
32202 | return data.erase_single(f); | |
32203 | } | |
32204 | inline Fragment *fragment(uint index) { | |
32205 | qt_noop(); | |
32206 | return data.fragment(index); | |
32207 | } | |
32208 | inline const Fragment *fragment(uint index) const { | |
32209 | qt_noop(); | |
32210 | return data.fragment(index); | |
32211 | } | |
32212 | inline uint position(uint node, uint field = 0) const { return data.position(node, field); } | |
32213 | inline uint next(uint n) const { return data.next(n); } | |
32214 | inline uint previous(uint n) const { return data.previous(n); } | |
32215 | inline uint size(uint node, uint field = 0) const { return data.size(node, field); } | |
32216 | inline void setSize(uint node, int new_size, uint field = 0) | |
32217 | { data.setSize(node, new_size, field); | |
32218 | if (node != 0 && field == 0) { | |
32219 | Fragment *frag = fragment(node); | |
32220 | qt_noop(); | |
32221 | frag->invalidate(); | |
32222 | } | |
32223 | } | |
32224 | inline int firstNode() const { return data.minimum(data.root()); } | |
32225 | private: | |
32226 | friend class Iterator; | |
32227 | friend class ConstIterator; | |
32228 | QFragmentMapData<Fragment> data; | |
32229 | QFragmentMap(const QFragmentMap& m); | |
32230 | QFragmentMap& operator= (const QFragmentMap& m); | |
32231 | }; | |
32232 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
32233 | class QTextFormatCollection; | |
32234 | class QTextListFormat; | |
32235 | class QRect; | |
32236 | class QPainter; | |
32237 | class QPrinter; | |
32238 | class QAbstractTextDocumentLayout; | |
32239 | class QPoint; | |
32240 | class QTextCursor; | |
32241 | class QTextObject; | |
32242 | class QTextFormat; | |
32243 | class QTextFrame; | |
32244 | class QTextBlock; | |
32245 | class QTextCodec; | |
32246 | class QUrl; | |
32247 | class QVariant; | |
32248 | class QRectF; | |
32249 | class QTextOption; | |
32250 | template<typename T> class QVector; | |
32251 | namespace Qt | |
32252 | { | |
32253 | enum HitTestAccuracy { ExactHit, FuzzyHit }; | |
32254 | enum WhiteSpaceMode { | |
32255 | WhiteSpaceNormal, | |
32256 | WhiteSpacePre, | |
32257 | WhiteSpaceNoWrap, | |
32258 | WhiteSpaceModeUndefined = -1 | |
32259 | }; | |
32260 | __attribute__((visibility("default"))) bool mightBeRichText(const QString&); | |
32261 | __attribute__((visibility("default"))) QString escape(const QString& plain); | |
32262 | __attribute__((visibility("default"))) QString convertFromPlainText(const QString &plain, WhiteSpaceMode mode = WhiteSpacePre); | |
32263 | __attribute__((visibility("default"))) QTextCodec *codecForHtml(const QByteArray &ba); | |
32264 | } | |
32265 | class __attribute__((visibility("default"))) QAbstractUndoItem | |
32266 | { | |
32267 | public: | |
32268 | virtual ~QAbstractUndoItem() = 0; | |
32269 | virtual void undo() = 0; | |
32270 | virtual void redo() = 0; | |
32271 | }; | |
32272 | inline QAbstractUndoItem::~QAbstractUndoItem() | |
32273 | { | |
32274 | } | |
32275 | class QTextDocumentPrivate; | |
32276 | class __attribute__((visibility("default"))) QTextDocument : public QObject | |
32277 | { | |
32278 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
32279 | public: | |
32280 | explicit QTextDocument(QObject *parent = 0); | |
32281 | explicit QTextDocument(const QString &text, QObject *parent = 0); | |
32282 | ~QTextDocument(); | |
32283 | QTextDocument *clone(QObject *parent = 0) const; | |
32284 | bool isEmpty() const; | |
32285 | virtual void clear(); | |
32286 | void setUndoRedoEnabled(bool enable); | |
32287 | bool isUndoRedoEnabled() const; | |
32288 | bool isUndoAvailable() const; | |
32289 | bool isRedoAvailable() const; | |
32290 | int revision() const; | |
32291 | void setDocumentLayout(QAbstractTextDocumentLayout *layout); | |
32292 | QAbstractTextDocumentLayout *documentLayout() const; | |
32293 | enum MetaInformation { | |
32294 | DocumentTitle, | |
32295 | DocumentUrl | |
32296 | }; | |
32297 | void setMetaInformation(MetaInformation info, const QString &); | |
32298 | QString metaInformation(MetaInformation info) const; | |
32299 | QString toHtml(const QByteArray &encoding = QByteArray()) const; | |
32300 | void setHtml(const QString &html); | |
32301 | QString toPlainText() const; | |
32302 | void setPlainText(const QString &text); | |
32303 | QChar characterAt(int pos) const; | |
32304 | enum FindFlag | |
32305 | { | |
32306 | FindBackward = 0x00001, | |
32307 | FindCaseSensitively = 0x00002, | |
32308 | FindWholeWords = 0x00004 | |
32309 | }; | |
32310 | typedef QFlags<FindFlag> FindFlags; | |
32311 | QTextCursor find(const QString &subString, int from = 0, FindFlags options = 0) const; | |
32312 | QTextCursor find(const QString &subString, const QTextCursor &from, FindFlags options = 0) const; | |
32313 | QTextCursor find(const QRegExp &expr, int from = 0, FindFlags options = 0) const; | |
32314 | QTextCursor find(const QRegExp &expr, const QTextCursor &from, FindFlags options = 0) const; | |
32315 | QTextFrame *frameAt(int pos) const; | |
32316 | QTextFrame *rootFrame() const; | |
32317 | QTextObject *object(int objectIndex) const; | |
32318 | QTextObject *objectForFormat(const QTextFormat &) const; | |
32319 | QTextBlock findBlock(int pos) const; | |
32320 | QTextBlock findBlockByNumber(int blockNumber) const; | |
32321 | QTextBlock findBlockByLineNumber(int blockNumber) const; | |
32322 | QTextBlock begin() const; | |
32323 | QTextBlock end() const; | |
32324 | QTextBlock firstBlock() const; | |
32325 | QTextBlock lastBlock() const; | |
32326 | void setPageSize(const QSizeF &size); | |
32327 | QSizeF pageSize() const; | |
32328 | void setDefaultFont(const QFont &font); | |
32329 | QFont defaultFont() const; | |
32330 | int pageCount() const; | |
32331 | bool isModified() const; | |
32332 | void print(QPrinter *printer) const; | |
32333 | enum ResourceType { | |
32334 | HtmlResource = 1, | |
32335 | ImageResource = 2, | |
32336 | StyleSheetResource = 3, | |
32337 | UserResource = 100 | |
32338 | }; | |
32339 | QVariant resource(int type, const QUrl &name) const; | |
32340 | void addResource(int type, const QUrl &name, const QVariant &resource); | |
32341 | QVector<QTextFormat> allFormats() const; | |
32342 | void markContentsDirty(int from, int length); | |
32343 | void setUseDesignMetrics(bool b); | |
32344 | bool useDesignMetrics() const; | |
32345 | void drawContents(QPainter *painter, const QRectF &rect = QRectF()); | |
32346 | void setTextWidth(qreal width); | |
32347 | qreal textWidth() const; | |
32348 | qreal idealWidth() const; | |
32349 | qreal indentWidth() const; | |
32350 | void setIndentWidth(qreal width); | |
32351 | qreal documentMargin() const; | |
32352 | void setDocumentMargin(qreal margin); | |
32353 | void adjustSize(); | |
32354 | QSizeF size() const; | |
32355 | int blockCount() const; | |
32356 | int lineCount() const; | |
32357 | int characterCount() const; | |
32358 | void setDefaultStyleSheet(const QString &sheet); | |
32359 | QString defaultStyleSheet() const; | |
32360 | void undo(QTextCursor *cursor); | |
32361 | void redo(QTextCursor *cursor); | |
32362 | int maximumBlockCount() const; | |
32363 | void setMaximumBlockCount(int maximum); | |
32364 | QTextOption defaultTextOption() const; | |
32365 | void setDefaultTextOption(const QTextOption &option); | |
32366 | protected: | |
32367 | void contentsChange(int from, int charsRemoves, int charsAdded); | |
32368 | void contentsChanged(); | |
32369 | void undoAvailable(bool); | |
32370 | void redoAvailable(bool); | |
32371 | void undoCommandAdded(); | |
32372 | void modificationChanged(bool m); | |
32373 | void cursorPositionChanged(const QTextCursor &cursor); | |
32374 | void blockCountChanged(int newBlockCount); | |
32375 | void documentLayoutChanged(); | |
32376 | public : | |
32377 | void undo(); | |
32378 | void redo(); | |
32379 | void appendUndoItem(QAbstractUndoItem *); | |
32380 | void setModified(bool m = true); | |
32381 | protected: | |
32382 | virtual QTextObject *createObject(const QTextFormat &f); | |
32383 | virtual QVariant loadResource(int type, const QUrl &name); | |
32384 | QTextDocument(QTextDocumentPrivate &dd, QObject *parent); | |
32385 | public: | |
32386 | QTextDocumentPrivate *docHandle() const; | |
32387 | private: | |
32388 | QTextDocument(const QTextDocument &); QTextDocument &operator=(const QTextDocument &); | |
32389 | inline QTextDocumentPrivate* d_func() { return reinterpret_cast<QTextDocumentPrivate *>(d_ptr); } inline const QTextDocumentPrivate* d_func() const { return reinterpret_cast<const QTextDocumentPrivate *>(d_ptr); } friend class QTextDocumentPrivate; | |
32390 | friend class QTextObjectPrivate; | |
32391 | }; | |
32392 | inline QFlags<QTextDocument::FindFlags::enum_type> operator|(QTextDocument::FindFlags::enum_type f1, QTextDocument::FindFlags::enum_type f2) { return QFlags<QTextDocument::FindFlags::enum_type>(f1) | f2; } inline QFlags<QTextDocument::FindFlags::enum_type> operator|(QTextDocument::FindFlags::enum_type f1, QFlags<QTextDocument::FindFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextDocument::FindFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
32393 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
32394 | class QUrlPrivate; | |
32395 | class QDataStream; | |
32396 | class __attribute__((visibility("default"))) QUrl | |
32397 | { | |
32398 | public: | |
32399 | enum ParsingMode { | |
32400 | TolerantMode, | |
32401 | StrictMode | |
32402 | }; | |
32403 | enum FormattingOption { | |
32404 | None = 0x0, | |
32405 | RemoveScheme = 0x1, | |
32406 | RemovePassword = 0x2, | |
32407 | RemoveUserInfo = RemovePassword | 0x4, | |
32408 | RemovePort = 0x8, | |
32409 | RemoveAuthority = RemoveUserInfo | RemovePort | 0x10, | |
32410 | RemovePath = 0x20, | |
32411 | RemoveQuery = 0x40, | |
32412 | RemoveFragment = 0x80, | |
32413 | StripTrailingSlash = 0x10000 | |
32414 | }; | |
32415 | typedef QFlags<FormattingOption> FormattingOptions; | |
32416 | QUrl(); | |
32417 | QUrl(const QString &url); | |
32418 | QUrl(const QString &url, ParsingMode mode); | |
32419 | QUrl(const QUrl ©); | |
32420 | QUrl &operator =(const QUrl ©); | |
32421 | QUrl &operator =(const QString &url); | |
32422 | ~QUrl(); | |
32423 | void setUrl(const QString &url); | |
32424 | void setUrl(const QString &url, ParsingMode mode); | |
32425 | void setEncodedUrl(const QByteArray &url); | |
32426 | void setEncodedUrl(const QByteArray &url, ParsingMode mode); | |
32427 | bool isValid() const; | |
32428 | bool isEmpty() const; | |
32429 | void clear(); | |
32430 | void setScheme(const QString &scheme); | |
32431 | QString scheme() const; | |
32432 | void setAuthority(const QString &authority); | |
32433 | QString authority() const; | |
32434 | void setUserInfo(const QString &userInfo); | |
32435 | QString userInfo() const; | |
32436 | void setUserName(const QString &userName); | |
32437 | QString userName() const; | |
32438 | void setEncodedUserName(const QByteArray &userName); | |
32439 | QByteArray encodedUserName() const; | |
32440 | void setPassword(const QString &password); | |
32441 | QString password() const; | |
32442 | void setEncodedPassword(const QByteArray &password); | |
32443 | QByteArray encodedPassword() const; | |
32444 | void setHost(const QString &host); | |
32445 | QString host() const; | |
32446 | void setEncodedHost(const QByteArray &host); | |
32447 | QByteArray encodedHost() const; | |
32448 | void setPort(int port); | |
32449 | int port() const; | |
32450 | int port(int defaultPort) const; | |
32451 | void setPath(const QString &path); | |
32452 | QString path() const; | |
32453 | void setEncodedPath(const QByteArray &path); | |
32454 | QByteArray encodedPath() const; | |
32455 | bool hasQuery() const; | |
32456 | void setEncodedQuery(const QByteArray &query); | |
32457 | QByteArray encodedQuery() const; | |
32458 | void setQueryDelimiters(char valueDelimiter, char pairDelimiter); | |
32459 | char queryValueDelimiter() const; | |
32460 | char queryPairDelimiter() const; | |
32461 | void setQueryItems(const QList<QPair<QString, QString> > &query); | |
32462 | void addQueryItem(const QString &key, const QString &value); | |
32463 | QList<QPair<QString, QString> > queryItems() const; | |
32464 | bool hasQueryItem(const QString &key) const; | |
32465 | QString queryItemValue(const QString &key) const; | |
32466 | QStringList allQueryItemValues(const QString &key) const; | |
32467 | void removeQueryItem(const QString &key); | |
32468 | void removeAllQueryItems(const QString &key); | |
32469 | void setEncodedQueryItems(const QList<QPair<QByteArray, QByteArray> > &query); | |
32470 | void addEncodedQueryItem(const QByteArray &key, const QByteArray &value); | |
32471 | QList<QPair<QByteArray, QByteArray> > encodedQueryItems() const; | |
32472 | bool hasEncodedQueryItem(const QByteArray &key) const; | |
32473 | QByteArray encodedQueryItemValue(const QByteArray &key) const; | |
32474 | QList<QByteArray> allEncodedQueryItemValues(const QByteArray &key) const; | |
32475 | void removeEncodedQueryItem(const QByteArray &key); | |
32476 | void removeAllEncodedQueryItems(const QByteArray &key); | |
32477 | void setFragment(const QString &fragment); | |
32478 | QString fragment() const; | |
32479 | void setEncodedFragment(const QByteArray &fragment); | |
32480 | QByteArray encodedFragment() const; | |
32481 | bool hasFragment() const; | |
32482 | QUrl resolved(const QUrl &relative) const; | |
32483 | bool isRelative() const; | |
32484 | bool isParentOf(const QUrl &url) const; | |
32485 | static QUrl fromLocalFile(const QString &localfile); | |
32486 | QString toLocalFile() const; | |
32487 | QString toString(FormattingOptions options = None) const; | |
32488 | QByteArray toEncoded(FormattingOptions options = None) const; | |
32489 | static QUrl fromEncoded(const QByteArray &url); | |
32490 | static QUrl fromEncoded(const QByteArray &url, ParsingMode mode); | |
32491 | void detach(); | |
32492 | bool isDetached() const; | |
32493 | bool operator <(const QUrl &url) const; | |
32494 | bool operator ==(const QUrl &url) const; | |
32495 | bool operator !=(const QUrl &url) const; | |
32496 | static QString fromPercentEncoding(const QByteArray &); | |
32497 | static QByteArray toPercentEncoding(const QString &, | |
32498 | const QByteArray &exclude = QByteArray(), | |
32499 | const QByteArray &include = QByteArray()); | |
32500 | static QString fromPunycode(const QByteArray &); | |
32501 | static QByteArray toPunycode(const QString &); | |
32502 | static QString fromAce(const QByteArray &); | |
32503 | static QByteArray toAce(const QString &); | |
32504 | static QStringList idnWhitelist(); | |
32505 | static void setIdnWhitelist(const QStringList &); | |
32506 | QString errorString() const; | |
32507 | protected: | |
32508 | private: | |
32509 | QUrlPrivate *d; | |
32510 | public: | |
32511 | typedef QUrlPrivate * DataPtr; | |
32512 | inline DataPtr &data_ptr() { return d; } | |
32513 | }; | |
32514 | template <> class QTypeInfo<QUrl> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QUrl)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QUrl"; } }; | |
32515 | template <> inline bool qIsDetached<QUrl>(QUrl &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QUrl>(QUrl &value1, QUrl &value2) { const QUrl::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
32516 | inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QUrl::FormattingOptions::enum_type f2) { return QFlags<QUrl::FormattingOptions::enum_type>(f1) | f2; } inline QFlags<QUrl::FormattingOptions::enum_type> operator|(QUrl::FormattingOptions::enum_type f1, QFlags<QUrl::FormattingOptions::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QUrl::FormattingOptions::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
32517 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QUrl &); | |
32518 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QUrl &); | |
32519 | __attribute__((visibility("default"))) QDebug operator<<(QDebug, const QUrl &); | |
32520 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
32521 | class QPalettePrivate; | |
32522 | class QVariant; | |
32523 | class __attribute__((visibility("default"))) QPalette | |
32524 | { | |
32525 | public: static const QMetaObject staticMetaObject; private: | |
32526 | public: | |
32527 | QPalette(); | |
32528 | QPalette(const QColor &button); | |
32529 | QPalette(Qt::GlobalColor button); | |
32530 | QPalette(const QColor &button, const QColor &window); | |
32531 | QPalette(const QBrush &windowText, const QBrush &button, const QBrush &light, | |
32532 | const QBrush &dark, const QBrush &mid, const QBrush &text, | |
32533 | const QBrush &bright_text, const QBrush &base, const QBrush &window); | |
32534 | QPalette(const QColor &windowText, const QColor &window, const QColor &light, | |
32535 | const QColor &dark, const QColor &mid, const QColor &text, const QColor &base); | |
32536 | QPalette(const QPalette &palette); | |
32537 | ~QPalette(); | |
32538 | QPalette &operator=(const QPalette &palette); | |
32539 | operator QVariant() const; | |
32540 | enum ColorGroup { Active, Disabled, Inactive, NColorGroups, Current, All, Normal = Active }; | |
32541 | enum ColorRole { WindowText, Button, Light, Midlight, Dark, Mid, | |
32542 | Text, BrightText, ButtonText, Base, Window, Shadow, | |
32543 | Highlight, HighlightedText, | |
32544 | Link, LinkVisited, | |
32545 | AlternateBase, | |
32546 | NoRole, | |
32547 | ToolTipBase, ToolTipText, | |
32548 | NColorRoles = ToolTipText + 1, | |
32549 | Foreground = WindowText, Background = Window | |
32550 | }; | |
32551 | inline ColorGroup currentColorGroup() const { return static_cast<ColorGroup>(current_group); } | |
32552 | inline void setCurrentColorGroup(ColorGroup cg) { current_group = cg; } | |
32553 | inline const QColor &color(ColorGroup cg, ColorRole cr) const | |
32554 | { return brush(cg, cr).color(); } | |
32555 | const QBrush &brush(ColorGroup cg, ColorRole cr) const; | |
32556 | inline void setColor(ColorGroup cg, ColorRole cr, const QColor &color); | |
32557 | inline void setColor(ColorRole cr, const QColor &color); | |
32558 | inline void setBrush(ColorRole cr, const QBrush &brush); | |
32559 | bool isBrushSet(ColorGroup cg, ColorRole cr) const; | |
32560 | void setBrush(ColorGroup cg, ColorRole cr, const QBrush &brush); | |
32561 | void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button, | |
32562 | const QBrush &light, const QBrush &dark, const QBrush &mid, | |
32563 | const QBrush &text, const QBrush &bright_text, const QBrush &base, | |
32564 | const QBrush &window); | |
32565 | bool isEqual(ColorGroup cr1, ColorGroup cr2) const; | |
32566 | inline const QColor &color(ColorRole cr) const { return color(Current, cr); } | |
32567 | inline const QBrush &brush(ColorRole cr) const { return brush(Current, cr); } | |
32568 | inline const QBrush &foreground() const { return brush(WindowText); } | |
32569 | inline const QBrush &windowText() const { return brush(WindowText); } | |
32570 | inline const QBrush &button() const { return brush(Button); } | |
32571 | inline const QBrush &light() const { return brush(Light); } | |
32572 | inline const QBrush &dark() const { return brush(Dark); } | |
32573 | inline const QBrush &mid() const { return brush(Mid); } | |
32574 | inline const QBrush &text() const { return brush(Text); } | |
32575 | inline const QBrush &base() const { return brush(Base); } | |
32576 | inline const QBrush &alternateBase() const { return brush(AlternateBase); } | |
32577 | inline const QBrush &toolTipBase() const { return brush(ToolTipBase); } | |
32578 | inline const QBrush &toolTipText() const { return brush(ToolTipText); } | |
32579 | inline const QBrush &background() const { return brush(Window); } | |
32580 | inline const QBrush &window() const { return brush(Window); } | |
32581 | inline const QBrush &midlight() const { return brush(Midlight); } | |
32582 | inline const QBrush &brightText() const { return brush(BrightText); } | |
32583 | inline const QBrush &buttonText() const { return brush(ButtonText); } | |
32584 | inline const QBrush &shadow() const { return brush(Shadow); } | |
32585 | inline const QBrush &highlight() const { return brush(Highlight); } | |
32586 | inline const QBrush &highlightedText() const { return brush(HighlightedText); } | |
32587 | inline const QBrush &link() const { return brush(Link); } | |
32588 | inline const QBrush &linkVisited() const { return brush(LinkVisited); } | |
32589 | bool operator==(const QPalette &p) const; | |
32590 | inline bool operator!=(const QPalette &p) const { return !(operator==(p)); } | |
32591 | bool isCopyOf(const QPalette &p) const; | |
32592 | int serialNumber() const; | |
32593 | qint64 cacheKey() const; | |
32594 | QPalette resolve(const QPalette &) const; | |
32595 | inline uint resolve() const { return resolve_mask; } | |
32596 | inline void resolve(uint mask) { resolve_mask = mask; } | |
32597 | private: | |
32598 | void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button, | |
32599 | const QBrush &light, const QBrush &dark, const QBrush &mid, | |
32600 | const QBrush &text, const QBrush &bright_text, | |
32601 | const QBrush &base, const QBrush &alternate_base, | |
32602 | const QBrush &window, const QBrush &midlight, | |
32603 | const QBrush &button_text, const QBrush &shadow, | |
32604 | const QBrush &highlight, const QBrush &highlighted_text, | |
32605 | const QBrush &link, const QBrush &link_visited); | |
32606 | void setColorGroup(ColorGroup cr, const QBrush &windowText, const QBrush &button, | |
32607 | const QBrush &light, const QBrush &dark, const QBrush &mid, | |
32608 | const QBrush &text, const QBrush &bright_text, | |
32609 | const QBrush &base, const QBrush &alternate_base, | |
32610 | const QBrush &window, const QBrush &midlight, | |
32611 | const QBrush &button_text, const QBrush &shadow, | |
32612 | const QBrush &highlight, const QBrush &highlighted_text, | |
32613 | const QBrush &link, const QBrush &link_visited, | |
32614 | const QBrush &toolTipBase, const QBrush &toolTipText); | |
32615 | void init(); | |
32616 | void detach(); | |
32617 | QPalettePrivate *d; | |
32618 | uint current_group : 4; | |
32619 | uint resolve_mask : 28; | |
32620 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &s, const QPalette &p); | |
32621 | }; | |
32622 | inline void QPalette::setColor(ColorGroup acg, ColorRole acr, | |
32623 | const QColor &acolor) | |
32624 | { setBrush(acg, acr, QBrush(acolor)); } | |
32625 | inline void QPalette::setColor(ColorRole acr, const QColor &acolor) | |
32626 | { setColor(All, acr, acolor); } | |
32627 | inline void QPalette::setBrush(ColorRole acr, const QBrush &abrush) | |
32628 | { setBrush(All, acr, abrush); } | |
32629 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &ds, const QPalette &p); | |
32630 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &ds, QPalette &p); | |
32631 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
32632 | class QIconPrivate; | |
32633 | class QIconEngine; | |
32634 | class QIconEngineV2; | |
32635 | class __attribute__((visibility("default"))) QIcon | |
32636 | { | |
32637 | public: | |
32638 | enum Mode { Normal, Disabled, Active, Selected }; | |
32639 | enum State { On, Off }; | |
32640 | QIcon(); | |
32641 | QIcon(const QPixmap &pixmap); | |
32642 | QIcon(const QIcon &other); | |
32643 | explicit QIcon(const QString &fileName); | |
32644 | explicit QIcon(QIconEngine *engine); | |
32645 | explicit QIcon(QIconEngineV2 *engine); | |
32646 | ~QIcon(); | |
32647 | QIcon &operator=(const QIcon &other); | |
32648 | operator QVariant() const; | |
32649 | QPixmap pixmap(const QSize &size, Mode mode = Normal, State state = Off) const; | |
32650 | inline QPixmap pixmap(int w, int h, Mode mode = Normal, State state = Off) const | |
32651 | { return pixmap(QSize(w, h), mode, state); } | |
32652 | inline QPixmap pixmap(int extent, Mode mode = Normal, State state = Off) const | |
32653 | { return pixmap(QSize(extent, extent), mode, state); } | |
32654 | QSize actualSize(const QSize &size, Mode mode = Normal, State state = Off) const; | |
32655 | void paint(QPainter *painter, const QRect &rect, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const; | |
32656 | inline void paint(QPainter *painter, int x, int y, int w, int h, Qt::Alignment alignment = Qt::AlignCenter, Mode mode = Normal, State state = Off) const | |
32657 | { paint(painter, QRect(x, y, w, h), alignment, mode, state); } | |
32658 | bool isNull() const; | |
32659 | bool isDetached() const; | |
32660 | void detach(); | |
32661 | int serialNumber() const; | |
32662 | qint64 cacheKey() const; | |
32663 | void addPixmap(const QPixmap &pixmap, Mode mode = Normal, State state = Off); | |
32664 | void addFile(const QString &fileName, const QSize &size = QSize(), Mode mode = Normal, State state = Off); | |
32665 | QList<QSize> availableSizes(Mode mode = Normal, State state = Off) const; | |
32666 | private: | |
32667 | QIconPrivate *d; | |
32668 | friend __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QIcon &); | |
32669 | friend __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QIcon &); | |
32670 | public: | |
32671 | typedef QIconPrivate * DataPtr; | |
32672 | inline DataPtr &data_ptr() { return d; } | |
32673 | }; | |
32674 | template <> inline bool qIsDetached<QIcon>(QIcon &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QIcon>(QIcon &value1, QIcon &value2) { const QIcon::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
32675 | template <> class QTypeInfo<QIcon> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QIcon)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QIcon"; } }; | |
32676 | __attribute__((visibility("default"))) QDataStream &operator<<(QDataStream &, const QIcon &); | |
32677 | __attribute__((visibility("default"))) QDataStream &operator>>(QDataStream &, QIcon &); | |
32678 | namespace QCss | |
32679 | { | |
32680 | enum Property { | |
32681 | UnknownProperty, | |
32682 | BackgroundColor, | |
32683 | Color, | |
32684 | Float, | |
32685 | Font, | |
32686 | FontFamily, | |
32687 | FontSize, | |
32688 | FontStyle, | |
32689 | FontWeight, | |
32690 | Margin, | |
32691 | MarginBottom, | |
32692 | MarginLeft, | |
32693 | MarginRight, | |
32694 | MarginTop, | |
32695 | QtBlockIndent, | |
32696 | QtListIndent, | |
32697 | QtParagraphType, | |
32698 | QtTableType, | |
32699 | QtUserState, | |
32700 | TextDecoration, | |
32701 | TextIndent, | |
32702 | TextUnderlineStyle, | |
32703 | VerticalAlignment, | |
32704 | Whitespace, | |
32705 | QtSelectionForeground, | |
32706 | QtSelectionBackground, | |
32707 | Border, | |
32708 | BorderLeft, | |
32709 | BorderRight, | |
32710 | BorderTop, | |
32711 | BorderBottom, | |
32712 | Padding, | |
32713 | PaddingLeft, | |
32714 | PaddingRight, | |
32715 | PaddingTop, | |
32716 | PaddingBottom, | |
32717 | PageBreakBefore, | |
32718 | PageBreakAfter, | |
32719 | QtAlternateBackground, | |
32720 | BorderLeftStyle, | |
32721 | BorderRightStyle, | |
32722 | BorderTopStyle, | |
32723 | BorderBottomStyle, | |
32724 | BorderStyles, | |
32725 | BorderLeftColor, | |
32726 | BorderRightColor, | |
32727 | BorderTopColor, | |
32728 | BorderBottomColor, | |
32729 | BorderColor, | |
32730 | BorderLeftWidth, | |
32731 | BorderRightWidth, | |
32732 | BorderTopWidth, | |
32733 | BorderBottomWidth, | |
32734 | BorderWidth, | |
32735 | BorderTopLeftRadius, | |
32736 | BorderTopRightRadius, | |
32737 | BorderBottomLeftRadius, | |
32738 | BorderBottomRightRadius, | |
32739 | BorderRadius, | |
32740 | Background, | |
32741 | BackgroundOrigin, | |
32742 | BackgroundClip, | |
32743 | BackgroundRepeat, | |
32744 | BackgroundPosition, | |
32745 | BackgroundAttachment, | |
32746 | BackgroundImage, | |
32747 | BorderImage, | |
32748 | QtSpacing, | |
32749 | Width, | |
32750 | Height, | |
32751 | MinimumWidth, | |
32752 | MinimumHeight, | |
32753 | MaximumWidth, | |
32754 | MaximumHeight, | |
32755 | QtImage, | |
32756 | Left, | |
32757 | Right, | |
32758 | Top, | |
32759 | Bottom, | |
32760 | QtOrigin, | |
32761 | QtPosition, | |
32762 | Position, | |
32763 | QtStyleFeatures, | |
32764 | QtBackgroundRole, | |
32765 | ListStyleType, | |
32766 | ListStyle, | |
32767 | QtImageAlignment, | |
32768 | TextAlignment, | |
32769 | Outline, | |
32770 | OutlineOffset, | |
32771 | OutlineWidth, | |
32772 | OutlineColor, | |
32773 | OutlineStyle, | |
32774 | OutlineRadius, | |
32775 | OutlineTopLeftRadius, | |
32776 | OutlineTopRightRadius, | |
32777 | OutlineBottomLeftRadius, | |
32778 | OutlineBottomRightRadius, | |
32779 | FontVariant, | |
32780 | TextTransform, | |
32781 | NumProperties | |
32782 | }; | |
32783 | enum KnownValue { | |
32784 | UnknownValue, | |
32785 | Value_Normal, | |
32786 | Value_Pre, | |
32787 | Value_NoWrap, | |
32788 | Value_PreWrap, | |
32789 | Value_Small, | |
32790 | Value_Medium, | |
32791 | Value_Large, | |
32792 | Value_XLarge, | |
32793 | Value_XXLarge, | |
32794 | Value_Italic, | |
32795 | Value_Oblique, | |
32796 | Value_Bold, | |
32797 | Value_Underline, | |
32798 | Value_Overline, | |
32799 | Value_LineThrough, | |
32800 | Value_Sub, | |
32801 | Value_Super, | |
32802 | Value_Left, | |
32803 | Value_Right, | |
32804 | Value_Top, | |
32805 | Value_Bottom, | |
32806 | Value_Center, | |
32807 | Value_Native, | |
32808 | Value_Solid, | |
32809 | Value_Dotted, | |
32810 | Value_Dashed, | |
32811 | Value_DotDash, | |
32812 | Value_DotDotDash, | |
32813 | Value_Double, | |
32814 | Value_Groove, | |
32815 | Value_Ridge, | |
32816 | Value_Inset, | |
32817 | Value_Outset, | |
32818 | Value_Wave, | |
32819 | Value_Middle, | |
32820 | Value_Auto, | |
32821 | Value_Always, | |
32822 | Value_None, | |
32823 | Value_Transparent, | |
32824 | Value_Disc, | |
32825 | Value_Circle, | |
32826 | Value_Square, | |
32827 | Value_Decimal, | |
32828 | Value_LowerAlpha, | |
32829 | Value_UpperAlpha, | |
32830 | Value_SmallCaps, | |
32831 | Value_Uppercase, | |
32832 | Value_Lowercase, | |
32833 | Value_FirstColorRole, | |
32834 | Value_WindowText = Value_FirstColorRole, | |
32835 | Value_Button, | |
32836 | Value_Light, | |
32837 | Value_Midlight, | |
32838 | Value_Dark, | |
32839 | Value_Mid, | |
32840 | Value_Text, | |
32841 | Value_BrightText, | |
32842 | Value_ButtonText, | |
32843 | Value_Base, | |
32844 | Value_Window, | |
32845 | Value_Shadow, | |
32846 | Value_Highlight, | |
32847 | Value_HighlightedText, | |
32848 | Value_Link, | |
32849 | Value_LinkVisited, | |
32850 | Value_AlternateBase, | |
32851 | Value_LastColorRole = Value_AlternateBase, | |
32852 | Value_Disabled, | |
32853 | Value_Active, | |
32854 | Value_Selected, | |
32855 | Value_On, | |
32856 | Value_Off, | |
32857 | NumKnownValues | |
32858 | }; | |
32859 | enum BorderStyle { | |
32860 | BorderStyle_Unknown, | |
32861 | BorderStyle_None, | |
32862 | BorderStyle_Dotted, | |
32863 | BorderStyle_Dashed, | |
32864 | BorderStyle_Solid, | |
32865 | BorderStyle_Double, | |
32866 | BorderStyle_DotDash, | |
32867 | BorderStyle_DotDotDash, | |
32868 | BorderStyle_Groove, | |
32869 | BorderStyle_Ridge, | |
32870 | BorderStyle_Inset, | |
32871 | BorderStyle_Outset, | |
32872 | BorderStyle_Native, | |
32873 | NumKnownBorderStyles | |
32874 | }; | |
32875 | enum Edge { | |
32876 | TopEdge, | |
32877 | RightEdge, | |
32878 | BottomEdge, | |
32879 | LeftEdge, | |
32880 | NumEdges | |
32881 | }; | |
32882 | enum Corner { | |
32883 | TopLeftCorner, | |
32884 | TopRightCorner, | |
32885 | BottomLeftCorner, | |
32886 | BottomRightCorner | |
32887 | }; | |
32888 | enum TileMode { | |
32889 | TileMode_Unknown, | |
32890 | TileMode_Round, | |
32891 | TileMode_Stretch, | |
32892 | TileMode_Repeat, | |
32893 | NumKnownTileModes | |
32894 | }; | |
32895 | enum Repeat { | |
32896 | Repeat_Unknown, | |
32897 | Repeat_None, | |
32898 | Repeat_X, | |
32899 | Repeat_Y, | |
32900 | Repeat_XY, | |
32901 | NumKnownRepeats | |
32902 | }; | |
32903 | enum Origin { | |
32904 | Origin_Unknown, | |
32905 | Origin_Padding, | |
32906 | Origin_Border, | |
32907 | Origin_Content, | |
32908 | Origin_Margin, | |
32909 | NumKnownOrigins | |
32910 | }; | |
32911 | enum PositionMode { | |
32912 | PositionMode_Unknown, | |
32913 | PositionMode_Static, | |
32914 | PositionMode_Relative, | |
32915 | PositionMode_Absolute, | |
32916 | PositionMode_Fixed, | |
32917 | NumKnownPositionModes | |
32918 | }; | |
32919 | enum Attachment { | |
32920 | Attachment_Unknown, | |
32921 | Attachment_Fixed, | |
32922 | Attachment_Scroll, | |
32923 | NumKnownAttachments | |
32924 | }; | |
32925 | enum StyleFeature { | |
32926 | StyleFeature_None = 0, | |
32927 | StyleFeature_BackgroundColor = 1, | |
32928 | StyleFeature_BackgroundGradient = 2, | |
32929 | NumKnownStyleFeatures = 4 | |
32930 | }; | |
32931 | struct __attribute__((visibility("default"))) Value | |
32932 | { | |
32933 | enum Type { | |
32934 | Unknown, | |
32935 | Number, | |
32936 | Percentage, | |
32937 | Length, | |
32938 | String, | |
32939 | Identifier, | |
32940 | KnownIdentifier, | |
32941 | Uri, | |
32942 | Color, | |
32943 | Function, | |
32944 | TermOperatorSlash, | |
32945 | TermOperatorComma | |
32946 | }; | |
32947 | inline Value() : type(Unknown) { } | |
32948 | Type type; | |
32949 | QVariant variant; | |
32950 | QString toString() const; | |
32951 | }; | |
32952 | struct ColorData { | |
32953 | ColorData() : type(Invalid) {} | |
32954 | ColorData(const QColor &col) : color(col) , type(Color) {} | |
32955 | ColorData(QPalette::ColorRole r) : role(r) , type(Role) {} | |
32956 | QColor color; | |
32957 | QPalette::ColorRole role; | |
32958 | enum { Invalid, Color, Role} type; | |
32959 | }; | |
32960 | struct BrushData { | |
32961 | BrushData() : type(Invalid) {} | |
32962 | BrushData(const QBrush &br) : brush(br) , type(Brush) {} | |
32963 | BrushData(QPalette::ColorRole r) : role(r) , type(Role) {} | |
32964 | QBrush brush; | |
32965 | QPalette::ColorRole role; | |
32966 | enum { Invalid, Brush, Role, DependsOnThePalette } type; | |
32967 | }; | |
32968 | struct BackgroundData { | |
32969 | BrushData brush; | |
32970 | QString image; | |
32971 | Repeat repeat; | |
32972 | Qt::Alignment alignment; | |
32973 | }; | |
32974 | struct LengthData { | |
32975 | qreal number; | |
32976 | enum { None, Px, Ex, Em } unit; | |
32977 | }; | |
32978 | struct BorderData { | |
32979 | LengthData width; | |
32980 | BorderStyle style; | |
32981 | BrushData color; | |
32982 | }; | |
32983 | struct __attribute__((visibility("default"))) Declaration | |
32984 | { | |
32985 | struct DeclarationData : public QSharedData | |
32986 | { | |
32987 | inline DeclarationData() : propertyId(UnknownProperty), important(false) {} | |
32988 | QString property; | |
32989 | Property propertyId; | |
32990 | QVector<Value> values; | |
32991 | QVariant parsed; | |
32992 | bool important; | |
32993 | }; | |
32994 | QExplicitlySharedDataPointer<DeclarationData> d; | |
32995 | inline Declaration() : d(new DeclarationData()) {} | |
32996 | inline bool isEmpty() const { return d->property.isEmpty() && d->propertyId == UnknownProperty; } | |
32997 | QColor colorValue(const QPalette & = QPalette()) const; | |
32998 | void colorValues(QColor *c, const QPalette & = QPalette()) const; | |
32999 | QBrush brushValue(const QPalette & = QPalette()) const; | |
33000 | void brushValues(QBrush *c, const QPalette & = QPalette()) const; | |
33001 | BorderStyle styleValue() const; | |
33002 | void styleValues(BorderStyle *s) const; | |
33003 | Origin originValue() const; | |
33004 | Repeat repeatValue() const; | |
33005 | Qt::Alignment alignmentValue() const; | |
33006 | PositionMode positionValue() const; | |
33007 | Attachment attachmentValue() const; | |
33008 | int styleFeaturesValue() const; | |
33009 | bool intValue(int *i, const char *unit = 0) const; | |
33010 | bool realValue(qreal *r, const char *unit = 0) const; | |
33011 | QSize sizeValue() const; | |
33012 | QRect rectValue() const; | |
33013 | QString uriValue() const; | |
33014 | QIcon iconValue() const; | |
33015 | void borderImageValue(QString *image, int *cuts, TileMode *h, TileMode *v) const; | |
33016 | }; | |
33017 | const quint64 PseudoClass_Unknown = static_cast<unsigned long long>(0x0000000000000000ULL); | |
33018 | const quint64 PseudoClass_Enabled = static_cast<unsigned long long>(0x0000000000000001ULL); | |
33019 | const quint64 PseudoClass_Disabled = static_cast<unsigned long long>(0x0000000000000002ULL); | |
33020 | const quint64 PseudoClass_Pressed = static_cast<unsigned long long>(0x0000000000000004ULL); | |
33021 | const quint64 PseudoClass_Focus = static_cast<unsigned long long>(0x0000000000000008ULL); | |
33022 | const quint64 PseudoClass_Hover = static_cast<unsigned long long>(0x0000000000000010ULL); | |
33023 | const quint64 PseudoClass_Checked = static_cast<unsigned long long>(0x0000000000000020ULL); | |
33024 | const quint64 PseudoClass_Unchecked = static_cast<unsigned long long>(0x0000000000000040ULL); | |
33025 | const quint64 PseudoClass_Indeterminate = static_cast<unsigned long long>(0x0000000000000080ULL); | |
33026 | const quint64 PseudoClass_Unspecified = static_cast<unsigned long long>(0x0000000000000100ULL); | |
33027 | const quint64 PseudoClass_Selected = static_cast<unsigned long long>(0x0000000000000200ULL); | |
33028 | const quint64 PseudoClass_Horizontal = static_cast<unsigned long long>(0x0000000000000400ULL); | |
33029 | const quint64 PseudoClass_Vertical = static_cast<unsigned long long>(0x0000000000000800ULL); | |
33030 | const quint64 PseudoClass_Window = static_cast<unsigned long long>(0x0000000000001000ULL); | |
33031 | const quint64 PseudoClass_Children = static_cast<unsigned long long>(0x0000000000002000ULL); | |
33032 | const quint64 PseudoClass_Sibling = static_cast<unsigned long long>(0x0000000000004000ULL); | |
33033 | const quint64 PseudoClass_Default = static_cast<unsigned long long>(0x0000000000008000ULL); | |
33034 | const quint64 PseudoClass_First = static_cast<unsigned long long>(0x0000000000010000ULL); | |
33035 | const quint64 PseudoClass_Last = static_cast<unsigned long long>(0x0000000000020000ULL); | |
33036 | const quint64 PseudoClass_Middle = static_cast<unsigned long long>(0x0000000000040000ULL); | |
33037 | const quint64 PseudoClass_OnlyOne = static_cast<unsigned long long>(0x0000000000080000ULL); | |
33038 | const quint64 PseudoClass_PreviousSelected = static_cast<unsigned long long>(0x0000000000100000ULL); | |
33039 | const quint64 PseudoClass_NextSelected = static_cast<unsigned long long>(0x0000000000200000ULL); | |
33040 | const quint64 PseudoClass_Flat = static_cast<unsigned long long>(0x0000000000400000ULL); | |
33041 | const quint64 PseudoClass_Left = static_cast<unsigned long long>(0x0000000000800000ULL); | |
33042 | const quint64 PseudoClass_Right = static_cast<unsigned long long>(0x0000000001000000ULL); | |
33043 | const quint64 PseudoClass_Top = static_cast<unsigned long long>(0x0000000002000000ULL); | |
33044 | const quint64 PseudoClass_Bottom = static_cast<unsigned long long>(0x0000000004000000ULL); | |
33045 | const quint64 PseudoClass_Exclusive = static_cast<unsigned long long>(0x0000000008000000ULL); | |
33046 | const quint64 PseudoClass_NonExclusive = static_cast<unsigned long long>(0x0000000010000000ULL); | |
33047 | const quint64 PseudoClass_Frameless = static_cast<unsigned long long>(0x0000000020000000ULL); | |
33048 | const quint64 PseudoClass_ReadOnly = static_cast<unsigned long long>(0x0000000040000000ULL); | |
33049 | const quint64 PseudoClass_Active = static_cast<unsigned long long>(0x0000000080000000ULL); | |
33050 | const quint64 PseudoClass_Closable = static_cast<unsigned long long>(0x0000000100000000ULL); | |
33051 | const quint64 PseudoClass_Movable = static_cast<unsigned long long>(0x0000000200000000ULL); | |
33052 | const quint64 PseudoClass_Floatable = static_cast<unsigned long long>(0x0000000400000000ULL); | |
33053 | const quint64 PseudoClass_Minimized = static_cast<unsigned long long>(0x0000000800000000ULL); | |
33054 | const quint64 PseudoClass_Maximized = static_cast<unsigned long long>(0x0000001000000000ULL); | |
33055 | const quint64 PseudoClass_On = static_cast<unsigned long long>(0x0000002000000000ULL); | |
33056 | const quint64 PseudoClass_Off = static_cast<unsigned long long>(0x0000004000000000ULL); | |
33057 | const quint64 PseudoClass_Editable = static_cast<unsigned long long>(0x0000008000000000ULL); | |
33058 | const quint64 PseudoClass_Item = static_cast<unsigned long long>(0x0000010000000000ULL); | |
33059 | const quint64 PseudoClass_Closed = static_cast<unsigned long long>(0x0000020000000000ULL); | |
33060 | const quint64 PseudoClass_Open = static_cast<unsigned long long>(0x0000040000000000ULL); | |
33061 | const quint64 PseudoClass_EditFocus = static_cast<unsigned long long>(0x0000080000000000ULL); | |
33062 | const quint64 PseudoClass_Alternate = static_cast<unsigned long long>(0x0000100000000000ULL); | |
33063 | const quint64 PseudoClass_Any = static_cast<unsigned long long>(0x0000ffffffffffffULL); | |
33064 | const int NumPseudos = 46; | |
33065 | struct __attribute__((visibility("default"))) Pseudo | |
33066 | { | |
33067 | Pseudo() : negated(false) { } | |
33068 | quint64 type; | |
33069 | QString name; | |
33070 | QString function; | |
33071 | bool negated; | |
33072 | }; | |
33073 | struct __attribute__((visibility("default"))) AttributeSelector | |
33074 | { | |
33075 | enum ValueMatchType { | |
33076 | NoMatch, | |
33077 | MatchEqual, | |
33078 | MatchContains, | |
33079 | MatchBeginsWith | |
33080 | }; | |
33081 | inline AttributeSelector() : valueMatchCriterium(NoMatch) {} | |
33082 | QString name; | |
33083 | QString value; | |
33084 | ValueMatchType valueMatchCriterium; | |
33085 | }; | |
33086 | struct __attribute__((visibility("default"))) BasicSelector | |
33087 | { | |
33088 | inline BasicSelector() : relationToNext(NoRelation) {} | |
33089 | enum Relation { | |
33090 | NoRelation, | |
33091 | MatchNextSelectorIfAncestor, | |
33092 | MatchNextSelectorIfParent, | |
33093 | MatchNextSelectorIfPreceeds | |
33094 | }; | |
33095 | QString elementName; | |
33096 | QStringList ids; | |
33097 | QVector<Pseudo> pseudos; | |
33098 | QVector<AttributeSelector> attributeSelectors; | |
33099 | Relation relationToNext; | |
33100 | }; | |
33101 | struct __attribute__((visibility("default"))) Selector | |
33102 | { | |
33103 | QVector<BasicSelector> basicSelectors; | |
33104 | int specificity() const; | |
33105 | quint64 pseudoClass(quint64 *negated = 0) const; | |
33106 | QString pseudoElement() const; | |
33107 | }; | |
33108 | struct StyleRule; | |
33109 | struct MediaRule; | |
33110 | struct PageRule; | |
33111 | struct ImportRule; | |
33112 | struct __attribute__((visibility("default"))) ValueExtractor | |
33113 | { | |
33114 | ValueExtractor(const QVector<Declaration> &declarations, const QPalette & = QPalette()); | |
33115 | bool extractFont(QFont *font, int *fontSizeAdjustment); | |
33116 | bool extractBackground(QBrush *, QString *, Repeat *, Qt::Alignment *, QCss::Origin *, QCss::Attachment *, | |
33117 | QCss::Origin *); | |
33118 | bool extractGeometry(int *w, int *h, int *minw, int *minh, int *maxw, int *maxh); | |
33119 | bool extractPosition(int *l, int *t, int *r, int *b, QCss::Origin *, Qt::Alignment *, | |
33120 | QCss::PositionMode *, Qt::Alignment *); | |
33121 | bool extractBox(int *margins, int *paddings, int *spacing = 0); | |
33122 | bool extractBorder(int *borders, QBrush *colors, BorderStyle *Styles, QSize *radii); | |
33123 | bool extractOutline(int *borders, QBrush *colors, BorderStyle *Styles, QSize *radii, int *offsets); | |
33124 | bool extractPalette(QBrush *fg, QBrush *sfg, QBrush *sbg, QBrush *abg); | |
33125 | int extractStyleFeatures(); | |
33126 | bool extractImage(QIcon *icon, Qt::Alignment *a, QSize *size); | |
33127 | int lengthValue(const Declaration &decl); | |
33128 | private: | |
33129 | void extractFont(); | |
33130 | void borderValue(const Declaration &decl, int *width, QCss::BorderStyle *style, QBrush *color); | |
33131 | LengthData lengthValue(const Value& v); | |
33132 | void lengthValues(const Declaration &decl, int *m); | |
33133 | QSize sizeValue(const Declaration &decl); | |
33134 | void sizeValues(const Declaration &decl, QSize *radii); | |
33135 | QVector<Declaration> declarations; | |
33136 | QFont f; | |
33137 | int adjustment; | |
33138 | int fontExtracted; | |
33139 | QPalette pal; | |
33140 | }; | |
33141 | struct __attribute__((visibility("default"))) StyleRule | |
33142 | { | |
33143 | StyleRule() : order(0) { } | |
33144 | QVector<Selector> selectors; | |
33145 | QVector<Declaration> declarations; | |
33146 | int order; | |
33147 | }; | |
33148 | struct __attribute__((visibility("default"))) MediaRule | |
33149 | { | |
33150 | QStringList media; | |
33151 | QVector<StyleRule> styleRules; | |
33152 | }; | |
33153 | struct __attribute__((visibility("default"))) PageRule | |
33154 | { | |
33155 | QString selector; | |
33156 | QVector<Declaration> declarations; | |
33157 | }; | |
33158 | struct __attribute__((visibility("default"))) ImportRule | |
33159 | { | |
33160 | QString href; | |
33161 | QStringList media; | |
33162 | }; | |
33163 | enum StyleSheetOrigin { | |
33164 | StyleSheetOrigin_Unspecified, | |
33165 | StyleSheetOrigin_UserAgent, | |
33166 | StyleSheetOrigin_User, | |
33167 | StyleSheetOrigin_Author, | |
33168 | StyleSheetOrigin_Inline | |
33169 | }; | |
33170 | struct __attribute__((visibility("default"))) StyleSheet | |
33171 | { | |
33172 | StyleSheet() : origin(StyleSheetOrigin_Unspecified), depth(0) { } | |
33173 | QVector<StyleRule> styleRules; | |
33174 | QVector<MediaRule> mediaRules; | |
33175 | QVector<PageRule> pageRules; | |
33176 | QVector<ImportRule> importRules; | |
33177 | StyleSheetOrigin origin; | |
33178 | int depth; | |
33179 | QMultiHash<QString, StyleRule> nameIndex; | |
33180 | QMultiHash<QString, StyleRule> idIndex; | |
33181 | void buildIndexes(Qt::CaseSensitivity nameCaseSensitivity = Qt::CaseSensitive); | |
33182 | }; | |
33183 | class __attribute__((visibility("default"))) StyleSelector | |
33184 | { | |
33185 | public: | |
33186 | StyleSelector() : nameCaseSensitivity(Qt::CaseSensitive) {} | |
33187 | virtual ~StyleSelector(); | |
33188 | union NodePtr { | |
33189 | void *ptr; | |
33190 | int id; | |
33191 | }; | |
33192 | QVector<StyleRule> styleRulesForNode(NodePtr node); | |
33193 | QVector<Declaration> declarationsForNode(NodePtr node, const char *extraPseudo = 0); | |
33194 | virtual bool nodeNameEquals(NodePtr node, const QString& nodeName) const; | |
33195 | virtual QString attribute(NodePtr node, const QString &name) const = 0; | |
33196 | virtual bool hasAttributes(NodePtr node) const = 0; | |
33197 | virtual QStringList nodeIds(NodePtr node) const; | |
33198 | virtual QStringList nodeNames(NodePtr node) const = 0; | |
33199 | virtual bool isNullNode(NodePtr node) const = 0; | |
33200 | virtual NodePtr parentNode(NodePtr node) const = 0; | |
33201 | virtual NodePtr previousSiblingNode(NodePtr node) const = 0; | |
33202 | virtual NodePtr duplicateNode(NodePtr node) const = 0; | |
33203 | virtual void freeNode(NodePtr node) const = 0; | |
33204 | QVector<StyleSheet> styleSheets; | |
33205 | QString medium; | |
33206 | Qt::CaseSensitivity nameCaseSensitivity; | |
33207 | private: | |
33208 | void matchRule(NodePtr node, const StyleRule &rules, StyleSheetOrigin origin, | |
33209 | int depth, QMap<uint, StyleRule> *weightedRules); | |
33210 | bool selectorMatches(const Selector &rule, NodePtr node); | |
33211 | bool basicSelectorMatches(const BasicSelector &rule, NodePtr node); | |
33212 | }; | |
33213 | enum TokenType { | |
33214 | NONE, | |
33215 | S, | |
33216 | CDO, | |
33217 | CDC, | |
33218 | INCLUDES, | |
33219 | DASHMATCH, | |
33220 | LBRACE, | |
33221 | PLUS, | |
33222 | GREATER, | |
33223 | COMMA, | |
33224 | STRING, | |
33225 | INVALID, | |
33226 | IDENT, | |
33227 | HASH, | |
33228 | ATKEYWORD_SYM, | |
33229 | EXCLAMATION_SYM, | |
33230 | LENGTH, | |
33231 | PERCENTAGE, | |
33232 | NUMBER, | |
33233 | FUNCTION, | |
33234 | COLON, | |
33235 | SEMICOLON, | |
33236 | RBRACE, | |
33237 | SLASH, | |
33238 | MINUS, | |
33239 | DOT, | |
33240 | STAR, | |
33241 | LBRACKET, | |
33242 | RBRACKET, | |
33243 | EQUAL, | |
33244 | LPAREN, | |
33245 | RPAREN, | |
33246 | OR | |
33247 | }; | |
33248 | struct __attribute__((visibility("default"))) Symbol | |
33249 | { | |
33250 | inline Symbol() : start(0), len(-1) {} | |
33251 | TokenType token; | |
33252 | QString text; | |
33253 | int start, len; | |
33254 | QString lexem() const; | |
33255 | }; | |
33256 | class Scanner | |
33257 | { | |
33258 | public: | |
33259 | static QString preprocess(const QString &input, bool *hasEscapeSequences = 0); | |
33260 | static void scan(const QString &preprocessedInput, QVector<Symbol> *symbols); | |
33261 | static const char *tokenName(TokenType t); | |
33262 | }; | |
33263 | class __attribute__((visibility("default"))) Parser | |
33264 | { | |
33265 | public: | |
33266 | Parser(); | |
33267 | Parser(const QString &css, bool file = false); | |
33268 | void init(const QString &css, bool file = false); | |
33269 | bool parse(StyleSheet *styleSheet, Qt::CaseSensitivity nameCaseSensitivity = Qt::CaseSensitive); | |
33270 | Symbol errorSymbol(); | |
33271 | bool parseImport(ImportRule *importRule); | |
33272 | bool parseMedia(MediaRule *mediaRule); | |
33273 | bool parseMedium(QStringList *media); | |
33274 | bool parsePage(PageRule *pageRule); | |
33275 | bool parsePseudoPage(QString *selector); | |
33276 | bool parseNextOperator(Value *value); | |
33277 | bool parseCombinator(BasicSelector::Relation *relation); | |
33278 | bool parseProperty(Declaration *decl); | |
33279 | bool parseRuleset(StyleRule *styleRule); | |
33280 | bool parseSelector(Selector *sel); | |
33281 | bool parseSimpleSelector(BasicSelector *basicSel); | |
33282 | bool parseClass(QString *name); | |
33283 | bool parseElementName(QString *name); | |
33284 | bool parseAttrib(AttributeSelector *attr); | |
33285 | bool parsePseudo(Pseudo *pseudo); | |
33286 | bool parseNextDeclaration(Declaration *declaration); | |
33287 | bool parsePrio(Declaration *declaration); | |
33288 | bool parseExpr(QVector<Value> *values); | |
33289 | bool parseTerm(Value *value); | |
33290 | bool parseFunction(QString *name, QString *args); | |
33291 | bool parseHexColor(QColor *col); | |
33292 | bool testAndParseUri(QString *uri); | |
33293 | inline bool testRuleset() { return testSelector(); } | |
33294 | inline bool testSelector() { return testSimpleSelector(); } | |
33295 | inline bool parseNextSelector(Selector *sel) { if (!testSelector()) return recordError(); return parseSelector(sel); } | |
33296 | bool testSimpleSelector(); | |
33297 | inline bool parseNextSimpleSelector(BasicSelector *basicSel) { if (!testSimpleSelector()) return recordError(); return parseSimpleSelector(basicSel); } | |
33298 | inline bool testElementName() { return test(IDENT) || test(STAR); } | |
33299 | inline bool testClass() { return test(DOT); } | |
33300 | inline bool testAttrib() { return test(LBRACKET); } | |
33301 | inline bool testPseudo() { return test(COLON); } | |
33302 | inline bool testMedium() { return test(IDENT); } | |
33303 | inline bool parseNextMedium(QStringList *media) { if (!testMedium()) return recordError(); return parseMedium(media); } | |
33304 | inline bool testPseudoPage() { return test(COLON); } | |
33305 | inline bool testImport() { return testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("import")); } | |
33306 | inline bool testMedia() { return testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("media")); } | |
33307 | inline bool testPage() { return testTokenAndEndsWith(ATKEYWORD_SYM, QLatin1String("page")); } | |
33308 | inline bool testCombinator() { return test(PLUS) || test(GREATER) || test(S); } | |
33309 | inline bool testProperty() { return test(IDENT); } | |
33310 | bool testTerm(); | |
33311 | inline bool testExpr() { return testTerm(); } | |
33312 | inline bool parseNextExpr(QVector<Value> *values) { if (!testExpr()) return recordError(); return parseExpr(values); } | |
33313 | bool testPrio(); | |
33314 | inline bool testHexColor() { return test(HASH); } | |
33315 | inline bool testFunction() { return test(FUNCTION); } | |
33316 | inline bool parseNextFunction(QString *name, QString *args) { if (!testFunction()) return recordError(); return parseFunction(name, args); } | |
33317 | inline bool lookupElementName() const { return lookup() == IDENT || lookup() == STAR; } | |
33318 | inline void skipSpace() { while (test(S)) {}; } | |
33319 | inline bool hasNext() const { return index < symbols.count(); } | |
33320 | inline TokenType next() { return symbols.at(index++).token; } | |
33321 | bool next(TokenType t); | |
33322 | bool test(TokenType t); | |
33323 | inline void prev() { index--; } | |
33324 | inline const Symbol &symbol() const { return symbols.at(index - 1); } | |
33325 | inline QString lexem() const { return symbol().lexem(); } | |
33326 | QString unquotedLexem() const; | |
33327 | QString lexemUntil(TokenType t); | |
33328 | bool until(TokenType target, TokenType target2 = NONE); | |
33329 | inline TokenType lookup() const { | |
33330 | return (index - 1) < symbols.count() ? symbols.at(index - 1).token : NONE; | |
33331 | } | |
33332 | bool testTokenAndEndsWith(TokenType t, const QLatin1String &str); | |
33333 | inline bool recordError() { errorIndex = index; return false; } | |
33334 | QVector<Symbol> symbols; | |
33335 | int index; | |
33336 | int errorIndex; | |
33337 | bool hasEscapeSequences; | |
33338 | QString sourcePath; | |
33339 | }; | |
33340 | } | |
33341 | template <> struct QMetaTypeId< QCss::BackgroundData > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id) metatype_id = qRegisterMetaType< QCss::BackgroundData >("QCss::BackgroundData"); return metatype_id; } }; | |
33342 | template <> struct QMetaTypeId< QCss::LengthData > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id) metatype_id = qRegisterMetaType< QCss::LengthData >("QCss::LengthData"); return metatype_id; } }; | |
33343 | template <> struct QMetaTypeId< QCss::BorderData > { enum { Defined = 1 }; static int qt_metatype_id() { static QBasicAtomicInt metatype_id = { (0) }; if (!metatype_id) metatype_id = qRegisterMetaType< QCss::BorderData >("QCss::BorderData"); return metatype_id; } }; | |
33344 | class QTextFormatCollection; | |
33345 | class QTextFormat; | |
33346 | class QTextBlockFormat; | |
33347 | class QTextCursorPrivate; | |
33348 | class QAbstractTextDocumentLayout; | |
33349 | class QTextDocument; | |
33350 | class QTextFrame; | |
33351 | class QTextFragmentData : public QFragment<> | |
33352 | { | |
33353 | public: | |
33354 | inline void initialize() {} | |
33355 | inline void invalidate() const {} | |
33356 | inline void free() {} | |
33357 | int stringPosition; | |
33358 | int format; | |
33359 | }; | |
33360 | class QTextBlockData : public QFragment<3> | |
33361 | { | |
33362 | public: | |
33363 | inline void initialize() | |
33364 | { layout = 0; userData = 0; userState = -1; revision = 0; hidden = 0; } | |
33365 | void invalidate() const; | |
33366 | inline void free() | |
33367 | { delete layout; layout = 0; delete userData; userData = 0; } | |
33368 | mutable int format; | |
33369 | mutable QTextLayout *layout; | |
33370 | mutable QTextBlockUserData *userData; | |
33371 | mutable int userState; | |
33372 | mutable int revision : 31; | |
33373 | mutable uint hidden : 1; | |
33374 | }; | |
33375 | class QAbstractUndoItem; | |
33376 | class QTextUndoCommand | |
33377 | { | |
33378 | public: | |
33379 | enum Command { | |
33380 | Inserted = 0, | |
33381 | Removed = 1, | |
33382 | CharFormatChanged = 2, | |
33383 | BlockFormatChanged = 3, | |
33384 | BlockInserted = 4, | |
33385 | BlockRemoved = 5, | |
33386 | BlockAdded = 6, | |
33387 | BlockDeleted = 7, | |
33388 | GroupFormatChange = 8, | |
33389 | Custom = 256 | |
33390 | }; | |
33391 | enum Operation { | |
33392 | KeepCursor = 0, | |
33393 | MoveCursor = 1 | |
33394 | }; | |
33395 | quint16 command; | |
33396 | quint8 block; | |
33397 | quint8 operation; | |
33398 | int format; | |
33399 | quint32 strPos; | |
33400 | quint32 pos; | |
33401 | union { | |
33402 | int blockFormat; | |
33403 | quint32 length; | |
33404 | QAbstractUndoItem *custom; | |
33405 | int objectIndex; | |
33406 | }; | |
33407 | quint32 revision; | |
33408 | bool tryMerge(const QTextUndoCommand &other); | |
33409 | }; | |
33410 | template <> class QTypeInfo<QTextUndoCommand> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QTextUndoCommand)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QTextUndoCommand"; } }; | |
33411 | class QTextDocumentPrivate : public QObjectPrivate | |
33412 | { | |
33413 | inline QTextDocument* q_func() { return static_cast<QTextDocument *>(q_ptr); } inline const QTextDocument* q_func() const { return static_cast<const QTextDocument *>(q_ptr); } friend class QTextDocument; | |
33414 | public: | |
33415 | typedef QFragmentMap<QTextFragmentData> FragmentMap; | |
33416 | typedef FragmentMap::ConstIterator FragmentIterator; | |
33417 | typedef QFragmentMap<QTextBlockData> BlockMap; | |
33418 | QTextDocumentPrivate(); | |
33419 | ~QTextDocumentPrivate(); | |
33420 | void init(); | |
33421 | void clear(); | |
33422 | void setLayout(QAbstractTextDocumentLayout *layout); | |
33423 | void insert(int pos, const QString &text, int format); | |
33424 | void insert(int pos, int strPos, int strLength, int format); | |
33425 | int insertBlock(int pos, int blockFormat, int charFormat, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor); | |
33426 | int insertBlock(const QChar &blockSeparator, int pos, int blockFormat, int charFormat, | |
33427 | QTextUndoCommand::Operation op = QTextUndoCommand::MoveCursor); | |
33428 | void move(int from, int to, int length, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor); | |
33429 | void remove(int pos, int length, QTextUndoCommand::Operation = QTextUndoCommand::MoveCursor); | |
33430 | void aboutToRemoveCell(int cursorFrom, int cursorEnd); | |
33431 | QTextFrame *insertFrame(int start, int end, const QTextFrameFormat &format); | |
33432 | void removeFrame(QTextFrame *frame); | |
33433 | enum FormatChangeMode { MergeFormat, SetFormat, SetFormatAndPreserveObjectIndices }; | |
33434 | void setCharFormat(int pos, int length, const QTextCharFormat &newFormat, FormatChangeMode mode = SetFormat); | |
33435 | void setBlockFormat(const QTextBlock &from, const QTextBlock &to, | |
33436 | const QTextBlockFormat &newFormat, FormatChangeMode mode = SetFormat); | |
33437 | void emitUndoAvailable(bool available); | |
33438 | void emitRedoAvailable(bool available); | |
33439 | int undoRedo(bool undo); | |
33440 | inline void undo() { undoRedo(true); } | |
33441 | inline void redo() { undoRedo(false); } | |
33442 | void appendUndoItem(QAbstractUndoItem *); | |
33443 | inline void beginEditBlock() { editBlock++; } | |
33444 | void joinPreviousEditBlock(); | |
33445 | void endEditBlock(); | |
33446 | inline bool isInEditBlock() const { return editBlock; } | |
33447 | void enableUndoRedo(bool enable); | |
33448 | inline bool isUndoRedoEnabled() const { return undoEnabled; } | |
33449 | inline bool isUndoAvailable() const { return undoEnabled && undoState > 0; } | |
33450 | inline bool isRedoAvailable() const { return undoEnabled && undoState < undoStack.size(); } | |
33451 | inline QString buffer() const { return text; } | |
33452 | QString plainText() const; | |
33453 | inline int length() const { return fragments.length(); } | |
33454 | inline QTextFormatCollection *formatCollection() { return &formats; } | |
33455 | inline const QTextFormatCollection *formatCollection() const { return &formats; } | |
33456 | inline QAbstractTextDocumentLayout *layout() const { return lout; } | |
33457 | inline FragmentIterator find(int pos) const { return fragments.find(pos); } | |
33458 | inline FragmentIterator begin() const { return fragments.begin(); } | |
33459 | inline FragmentIterator end() const { return fragments.end(); } | |
33460 | inline QTextBlock blocksBegin() const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.firstNode()); } | |
33461 | inline QTextBlock blocksEnd() const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), 0); } | |
33462 | inline QTextBlock blocksFind(int pos) const { return QTextBlock(const_cast<QTextDocumentPrivate *>(this), blocks.findNode(pos)); } | |
33463 | int blockCharFormatIndex(int node) const; | |
33464 | inline int numBlocks() const { return blocks.numNodes(); } | |
33465 | const BlockMap &blockMap() const { return blocks; } | |
33466 | const FragmentMap &fragmentMap() const { return fragments; } | |
33467 | BlockMap &blockMap() { return blocks; } | |
33468 | FragmentMap &fragmentMap() { return fragments; } | |
33469 | static const QTextBlockData *block(const QTextBlock &it) { return it.p->blocks.fragment(it.n); } | |
33470 | int nextCursorPosition(int position, QTextLayout::CursorMode mode) const; | |
33471 | int previousCursorPosition(int position, QTextLayout::CursorMode mode) const; | |
33472 | void changeObjectFormat(QTextObject *group, int format); | |
33473 | void setModified(bool m); | |
33474 | inline bool isModified() const { return modified; } | |
33475 | inline QFont defaultFont() const { return formats.defaultFont(); } | |
33476 | inline void setDefaultFont(const QFont &f) { formats.setDefaultFont(f); } | |
33477 | private: | |
33478 | bool split(int pos); | |
33479 | bool unite(uint f); | |
33480 | void truncateUndoStack(); | |
33481 | void insert_string(int pos, uint strPos, uint length, int format, QTextUndoCommand::Operation op); | |
33482 | int insert_block(int pos, uint strPos, int format, int blockformat, QTextUndoCommand::Operation op, int command); | |
33483 | int remove_string(int pos, uint length, QTextUndoCommand::Operation op); | |
33484 | int remove_block(int pos, int *blockformat, int command, QTextUndoCommand::Operation op); | |
33485 | void insert_frame(QTextFrame *f); | |
33486 | void scan_frames(int pos, int charsRemoved, int charsAdded); | |
33487 | static void clearFrame(QTextFrame *f); | |
33488 | void adjustDocumentChangesAndCursors(int from, int addedOrRemoved, QTextUndoCommand::Operation op); | |
33489 | bool wasUndoAvailable; | |
33490 | bool wasRedoAvailable; | |
33491 | public: | |
33492 | void documentChange(int from, int length); | |
33493 | inline void addCursor(QTextCursorPrivate *c) { cursors.append(c); } | |
33494 | inline void removeCursor(QTextCursorPrivate *c) { cursors.removeAll(c); changedCursors.removeAll(c); } | |
33495 | QTextFrame *frameAt(int pos) const; | |
33496 | QTextFrame *rootFrame() const; | |
33497 | QTextObject *objectForIndex(int objectIndex) const; | |
33498 | QTextObject *objectForFormat(int formatIndex) const; | |
33499 | QTextObject *objectForFormat(const QTextFormat &f) const; | |
33500 | QTextObject *createObject(const QTextFormat &newFormat, int objectIndex = -1); | |
33501 | void deleteObject(QTextObject *object); | |
33502 | QTextDocument *document() { return q_func(); } | |
33503 | const QTextDocument *document() const { return q_func(); } | |
33504 | bool ensureMaximumBlockCount(); | |
33505 | private: | |
33506 | QTextDocumentPrivate(const QTextDocumentPrivate& m); | |
33507 | QTextDocumentPrivate& operator= (const QTextDocumentPrivate& m); | |
33508 | void appendUndoItem(const QTextUndoCommand &c); | |
33509 | void contentsChanged(); | |
33510 | void compressPieceTable(); | |
33511 | QString text; | |
33512 | uint unreachableCharacterCount; | |
33513 | QVector<QTextUndoCommand> undoStack; | |
33514 | bool undoEnabled; | |
33515 | int undoState; | |
33516 | int modifiedState; | |
33517 | bool modified; | |
33518 | int editBlock; | |
33519 | int docChangeFrom; | |
33520 | int docChangeOldLength; | |
33521 | int docChangeLength; | |
33522 | bool framesDirty; | |
33523 | QTextFormatCollection formats; | |
33524 | mutable QTextFrame *rtFrame; | |
33525 | QAbstractTextDocumentLayout *lout; | |
33526 | FragmentMap fragments; | |
33527 | BlockMap blocks; | |
33528 | int initialBlockCharFormatIndex; | |
33529 | QList<QTextCursorPrivate*> cursors; | |
33530 | QList<QTextCursorPrivate*> changedCursors; | |
33531 | QMap<int, QTextObject *> objects; | |
33532 | QMap<QUrl, QVariant> resources; | |
33533 | QMap<QUrl, QVariant> cachedResources; | |
33534 | QString defaultStyleSheet; | |
33535 | int lastBlockCount; | |
33536 | public: | |
33537 | QTextOption defaultTextOption; | |
33538 | QCss::StyleSheet parsedDefaultStyleSheet; | |
33539 | int maximumBlockCount; | |
33540 | bool needsEnsureMaximumBlockCount; | |
33541 | bool inContentsChange; | |
33542 | QSizeF pageSize; | |
33543 | QString title; | |
33544 | QString url; | |
33545 | qreal indentWidth; | |
33546 | qreal documentMargin; | |
33547 | void mergeCachedResources(const QTextDocumentPrivate *priv); | |
33548 | friend class QTextHtmlExporter; | |
33549 | friend class QTextCursor; | |
33550 | }; | |
33551 | class QTextTable; | |
33552 | class QTextHtmlExporter | |
33553 | { | |
33554 | public: | |
33555 | QTextHtmlExporter(const QTextDocument *_doc); | |
33556 | enum ExportMode { | |
33557 | ExportEntireDocument, | |
33558 | ExportFragment | |
33559 | }; | |
33560 | QString toHtml(const QByteArray &encoding, ExportMode mode = ExportEntireDocument); | |
33561 | private: | |
33562 | enum StyleMode { EmitStyleTag, OmitStyleTag }; | |
33563 | enum FrameType { TextFrame, TableFrame, RootFrame }; | |
33564 | void emitFrame(QTextFrame::Iterator frameIt); | |
33565 | void emitTextFrame(const QTextFrame *frame); | |
33566 | void emitBlock(const QTextBlock &block); | |
33567 | void emitTable(const QTextTable *table); | |
33568 | void emitFragment(const QTextFragment &fragment); | |
33569 | void emitBlockAttributes(const QTextBlock &block); | |
33570 | bool emitCharFormatStyle(const QTextCharFormat &format); | |
33571 | void emitTextLength(const char *attribute, const QTextLength &length); | |
33572 | void emitAlignment(Qt::Alignment alignment); | |
33573 | void emitFloatStyle(QTextFrameFormat::Position pos, StyleMode mode = EmitStyleTag); | |
33574 | void emitMargins(const QString &top, const QString &bottom, const QString &left, const QString &right); | |
33575 | void emitAttribute(const char *attribute, const QString &value); | |
33576 | void emitFrameStyle(const QTextFrameFormat &format, FrameType frameType); | |
33577 | void emitBorderStyle(QTextFrameFormat::BorderStyle style); | |
33578 | void emitPageBreakPolicy(QTextFormat::PageBreakFlags policy); | |
33579 | void emitFontFamily(const QString &family); | |
33580 | void emitBackgroundAttribute(const QTextFormat &format); | |
33581 | QString findUrlForImage(const QTextDocument *doc, qint64 cacheKey, bool isPixmap); | |
33582 | QString html; | |
33583 | QTextCharFormat defaultCharFormat; | |
33584 | const QTextDocument *doc; | |
33585 | bool fragmentMarkers; | |
33586 | }; | |
33587 | extern "C" { | |
33588 | typedef char hb_int8; | |
33589 | typedef unsigned char hb_uint8; | |
33590 | typedef short hb_int16; | |
33591 | typedef unsigned short hb_uint16; | |
33592 | typedef int hb_int32; | |
33593 | typedef unsigned int hb_uint32; | |
33594 | typedef hb_uint8 HB_Bool; | |
33595 | typedef hb_uint8 HB_Byte; | |
33596 | typedef hb_uint16 HB_UShort; | |
33597 | typedef hb_uint32 HB_UInt; | |
33598 | typedef hb_int8 HB_Char; | |
33599 | typedef hb_int16 HB_Short; | |
33600 | typedef hb_int32 HB_Int; | |
33601 | typedef hb_uint16 HB_UChar16; | |
33602 | typedef hb_uint32 HB_UChar32; | |
33603 | typedef hb_uint32 HB_Glyph; | |
33604 | typedef hb_int32 HB_Fixed; | |
33605 | typedef hb_int32 HB_16Dot16; | |
33606 | typedef void * HB_Pointer; | |
33607 | typedef hb_uint32 HB_Tag; | |
33608 | typedef enum { | |
33609 | HB_Err_Ok = 0x0000, | |
33610 | HB_Err_Not_Covered = 0xFFFF, | |
33611 | HB_Err_Invalid_Argument = 0x1A66, | |
33612 | HB_Err_Invalid_SubTable_Format = 0x157F, | |
33613 | HB_Err_Invalid_SubTable = 0x1570, | |
33614 | HB_Err_Read_Error = 0x6EAD, | |
33615 | HB_Err_Out_Of_Memory = 0xDEAD | |
33616 | } HB_Error; | |
33617 | typedef struct { | |
33618 | HB_Fixed x; | |
33619 | HB_Fixed y; | |
33620 | } HB_FixedPoint; | |
33621 | typedef struct HB_Font_ *HB_Font; | |
33622 | typedef struct HB_StreamRec_ *HB_Stream; | |
33623 | typedef struct HB_FaceRec_ *HB_Face; | |
33624 | } | |
33625 | extern "C" { | |
33626 | struct HB_LangSys_ | |
33627 | { | |
33628 | HB_UShort LookupOrderOffset; | |
33629 | HB_UShort ReqFeatureIndex; | |
33630 | HB_UShort FeatureCount; | |
33631 | HB_UShort* FeatureIndex; | |
33632 | }; | |
33633 | typedef struct HB_LangSys_ HB_LangSys; | |
33634 | struct HB_LangSysRecord_ | |
33635 | { | |
33636 | HB_UInt LangSysTag; | |
33637 | HB_LangSys LangSys; | |
33638 | }; | |
33639 | typedef struct HB_LangSysRecord_ HB_LangSysRecord; | |
33640 | struct HB_ScriptTable_ | |
33641 | { | |
33642 | HB_LangSys DefaultLangSys; | |
33643 | HB_UShort LangSysCount; | |
33644 | HB_LangSysRecord* LangSysRecord; | |
33645 | }; | |
33646 | typedef struct HB_ScriptTable_ HB_ScriptTable; | |
33647 | struct HB_ScriptRecord_ | |
33648 | { | |
33649 | HB_UInt ScriptTag; | |
33650 | HB_ScriptTable Script; | |
33651 | }; | |
33652 | typedef struct HB_ScriptRecord_ HB_ScriptRecord; | |
33653 | struct HB_ScriptList_ | |
33654 | { | |
33655 | HB_UShort ScriptCount; | |
33656 | HB_ScriptRecord* ScriptRecord; | |
33657 | }; | |
33658 | typedef struct HB_ScriptList_ HB_ScriptList; | |
33659 | struct HB_Feature_ | |
33660 | { | |
33661 | HB_UShort FeatureParams; | |
33662 | HB_UShort LookupListCount; | |
33663 | HB_UShort* LookupListIndex; | |
33664 | }; | |
33665 | typedef struct HB_Feature_ HB_Feature; | |
33666 | struct HB_FeatureRecord_ | |
33667 | { | |
33668 | HB_UInt FeatureTag; | |
33669 | HB_Feature Feature; | |
33670 | }; | |
33671 | typedef struct HB_FeatureRecord_ HB_FeatureRecord; | |
33672 | struct HB_FeatureList_ | |
33673 | { | |
33674 | HB_UShort FeatureCount; | |
33675 | HB_FeatureRecord* FeatureRecord; | |
33676 | HB_UShort* ApplyOrder; | |
33677 | HB_UShort ApplyCount; | |
33678 | }; | |
33679 | typedef struct HB_FeatureList_ HB_FeatureList; | |
33680 | typedef struct HB_SubTable_ HB_SubTable; | |
33681 | struct HB_Lookup_ | |
33682 | { | |
33683 | HB_UShort LookupType; | |
33684 | HB_UShort LookupFlag; | |
33685 | HB_UShort SubTableCount; | |
33686 | HB_SubTable* SubTable; | |
33687 | }; | |
33688 | typedef struct HB_Lookup_ HB_Lookup; | |
33689 | struct HB_LookupList_ | |
33690 | { | |
33691 | HB_UShort LookupCount; | |
33692 | HB_Lookup* Lookup; | |
33693 | HB_UInt* Properties; | |
33694 | }; | |
33695 | typedef struct HB_LookupList_ HB_LookupList; | |
33696 | struct HB_CoverageFormat1_ | |
33697 | { | |
33698 | HB_UShort GlyphCount; | |
33699 | HB_UShort* GlyphArray; | |
33700 | }; | |
33701 | typedef struct HB_CoverageFormat1_ HB_CoverageFormat1; | |
33702 | struct HB_RangeRecord_ | |
33703 | { | |
33704 | HB_UShort Start; | |
33705 | HB_UShort End; | |
33706 | HB_UShort StartCoverageIndex; | |
33707 | }; | |
33708 | typedef struct HB_RangeRecord_ HB_RangeRecord; | |
33709 | struct HB_CoverageFormat2_ | |
33710 | { | |
33711 | HB_UShort RangeCount; | |
33712 | HB_RangeRecord* RangeRecord; | |
33713 | }; | |
33714 | typedef struct HB_CoverageFormat2_ HB_CoverageFormat2; | |
33715 | struct HB_Coverage_ | |
33716 | { | |
33717 | HB_UShort CoverageFormat; | |
33718 | union | |
33719 | { | |
33720 | HB_CoverageFormat1 cf1; | |
33721 | HB_CoverageFormat2 cf2; | |
33722 | } cf; | |
33723 | }; | |
33724 | typedef struct HB_Coverage_ HB_Coverage; | |
33725 | struct HB_ClassDefFormat1_ | |
33726 | { | |
33727 | HB_UShort StartGlyph; | |
33728 | HB_UShort GlyphCount; | |
33729 | HB_UShort* ClassValueArray; | |
33730 | }; | |
33731 | typedef struct HB_ClassDefFormat1_ HB_ClassDefFormat1; | |
33732 | struct HB_ClassRangeRecord_ | |
33733 | { | |
33734 | HB_UShort Start; | |
33735 | HB_UShort End; | |
33736 | HB_UShort Class; | |
33737 | }; | |
33738 | typedef struct HB_ClassRangeRecord_ HB_ClassRangeRecord; | |
33739 | struct HB_ClassDefFormat2_ | |
33740 | { | |
33741 | HB_UShort ClassRangeCount; | |
33742 | HB_ClassRangeRecord* ClassRangeRecord; | |
33743 | }; | |
33744 | typedef struct HB_ClassDefFormat2_ HB_ClassDefFormat2; | |
33745 | struct HB_ClassDefinition_ | |
33746 | { | |
33747 | HB_Bool loaded; | |
33748 | HB_UShort ClassFormat; | |
33749 | union | |
33750 | { | |
33751 | HB_ClassDefFormat1 cd1; | |
33752 | HB_ClassDefFormat2 cd2; | |
33753 | } cd; | |
33754 | }; | |
33755 | typedef struct HB_ClassDefinition_ HB_ClassDefinition; | |
33756 | struct HB_Device_ | |
33757 | { | |
33758 | HB_UShort StartSize; | |
33759 | HB_UShort EndSize; | |
33760 | HB_UShort DeltaFormat; | |
33761 | HB_UShort* DeltaValue; | |
33762 | }; | |
33763 | typedef struct HB_Device_ HB_Device; | |
33764 | enum HB_Type_ | |
33765 | { | |
33766 | HB_Type_GSUB, | |
33767 | HB_Type_GPOS | |
33768 | }; | |
33769 | typedef enum HB_Type_ HB_Type; | |
33770 | } | |
33771 | extern "C" { | |
33772 | typedef struct HB_StreamRec_ | |
33773 | { | |
33774 | HB_Byte* base; | |
33775 | HB_UInt size; | |
33776 | HB_UInt pos; | |
33777 | HB_Byte* cursor; | |
33778 | } HB_StreamRec; | |
33779 | } | |
33780 | extern "C" { | |
33781 | typedef struct HB_AttachPoint_ HB_AttachPoint; | |
33782 | struct HB_AttachList_ | |
33783 | { | |
33784 | HB_Bool loaded; | |
33785 | HB_Coverage Coverage; | |
33786 | HB_UShort GlyphCount; | |
33787 | HB_AttachPoint* AttachPoint; | |
33788 | }; | |
33789 | typedef struct HB_AttachList_ HB_AttachList; | |
33790 | typedef struct HB_LigGlyph_ HB_LigGlyph; | |
33791 | struct HB_LigCaretList_ | |
33792 | { | |
33793 | HB_Bool loaded; | |
33794 | HB_Coverage Coverage; | |
33795 | HB_UShort LigGlyphCount; | |
33796 | HB_LigGlyph* LigGlyph; | |
33797 | }; | |
33798 | typedef struct HB_LigCaretList_ HB_LigCaretList; | |
33799 | struct HB_GDEFHeader_ | |
33800 | { | |
33801 | HB_UInt offset; | |
33802 | HB_16Dot16 Version; | |
33803 | HB_ClassDefinition GlyphClassDef; | |
33804 | HB_AttachList AttachList; | |
33805 | HB_LigCaretList LigCaretList; | |
33806 | HB_UInt MarkAttachClassDef_offset; | |
33807 | HB_ClassDefinition MarkAttachClassDef; | |
33808 | HB_UShort LastGlyph; | |
33809 | HB_UShort** NewGlyphClasses; | |
33810 | }; | |
33811 | typedef struct HB_GDEFHeader_ HB_GDEFHeader; | |
33812 | typedef struct HB_GDEFHeader_* HB_GDEF; | |
33813 | HB_Error HB_New_GDEF_Table( HB_GDEFHeader** retptr ); | |
33814 | HB_Error HB_Load_GDEF_Table( HB_Stream stream, | |
33815 | HB_GDEFHeader** gdef ); | |
33816 | HB_Error HB_Done_GDEF_Table ( HB_GDEFHeader* gdef ); | |
33817 | HB_Error HB_GDEF_Get_Glyph_Property( HB_GDEFHeader* gdef, | |
33818 | HB_UShort glyphID, | |
33819 | HB_UShort* property ); | |
33820 | HB_Error HB_GDEF_Build_ClassDefinition( HB_GDEFHeader* gdef, | |
33821 | HB_UShort num_glyphs, | |
33822 | HB_UShort glyph_count, | |
33823 | HB_UShort* glyph_array, | |
33824 | HB_UShort* class_array ); | |
33825 | } | |
33826 | extern "C" { | |
33827 | typedef struct HB_GlyphItemRec_ { | |
33828 | HB_UInt gindex; | |
33829 | HB_UInt properties; | |
33830 | HB_UInt cluster; | |
33831 | HB_UShort component; | |
33832 | HB_UShort ligID; | |
33833 | HB_UShort gproperties; | |
33834 | } HB_GlyphItemRec, *HB_GlyphItem; | |
33835 | typedef struct HB_PositionRec_ { | |
33836 | HB_Fixed x_pos; | |
33837 | HB_Fixed y_pos; | |
33838 | HB_Fixed x_advance; | |
33839 | HB_Fixed y_advance; | |
33840 | HB_UShort back; | |
33841 | HB_Bool new_advance; | |
33842 | HB_Short cursive_chain; | |
33843 | } HB_PositionRec, *HB_Position; | |
33844 | typedef struct HB_BufferRec_{ | |
33845 | HB_UInt allocated; | |
33846 | HB_UInt in_length; | |
33847 | HB_UInt out_length; | |
33848 | HB_UInt in_pos; | |
33849 | HB_UInt out_pos; | |
33850 | HB_Bool separate_out; | |
33851 | HB_GlyphItem in_string; | |
33852 | HB_GlyphItem out_string; | |
33853 | HB_GlyphItem alt_string; | |
33854 | HB_Position positions; | |
33855 | HB_UShort max_ligID; | |
33856 | } HB_BufferRec, *HB_Buffer; | |
33857 | HB_Error | |
33858 | hb_buffer_new( HB_Buffer *buffer ); | |
33859 | void | |
33860 | hb_buffer_free( HB_Buffer buffer ); | |
33861 | void | |
33862 | hb_buffer_clear( HB_Buffer buffer ); | |
33863 | HB_Error | |
33864 | hb_buffer_add_glyph( HB_Buffer buffer, | |
33865 | HB_UInt glyph_index, | |
33866 | HB_UInt properties, | |
33867 | HB_UInt cluster ); | |
33868 | } | |
33869 | extern "C" { | |
33870 | typedef HB_Error (*HB_MMFunction)(HB_Font font, | |
33871 | HB_UShort metric_id, | |
33872 | HB_Fixed* metric_value, | |
33873 | void* data ); | |
33874 | struct HB_GPOSHeader_ | |
33875 | { | |
33876 | HB_16Dot16 Version; | |
33877 | HB_ScriptList ScriptList; | |
33878 | HB_FeatureList FeatureList; | |
33879 | HB_LookupList LookupList; | |
33880 | HB_GDEFHeader* gdef; | |
33881 | HB_MMFunction mmfunc; | |
33882 | void* data; | |
33883 | }; | |
33884 | typedef struct HB_GPOSHeader_ HB_GPOSHeader; | |
33885 | typedef HB_GPOSHeader* HB_GPOS; | |
33886 | HB_Error HB_Load_GPOS_Table( HB_Stream stream, | |
33887 | HB_GPOSHeader** gpos, | |
33888 | HB_GDEFHeader* gdef, | |
33889 | HB_Stream gdefStream ); | |
33890 | HB_Error HB_Done_GPOS_Table( HB_GPOSHeader* gpos ); | |
33891 | HB_Error HB_GPOS_Select_Script( HB_GPOSHeader* gpos, | |
33892 | HB_UInt script_tag, | |
33893 | HB_UShort* script_index ); | |
33894 | HB_Error HB_GPOS_Select_Language( HB_GPOSHeader* gpos, | |
33895 | HB_UInt language_tag, | |
33896 | HB_UShort script_index, | |
33897 | HB_UShort* language_index, | |
33898 | HB_UShort* req_feature_index ); | |
33899 | HB_Error HB_GPOS_Select_Feature( HB_GPOSHeader* gpos, | |
33900 | HB_UInt feature_tag, | |
33901 | HB_UShort script_index, | |
33902 | HB_UShort language_index, | |
33903 | HB_UShort* feature_index ); | |
33904 | HB_Error HB_GPOS_Query_Scripts( HB_GPOSHeader* gpos, | |
33905 | HB_UInt** script_tag_list ); | |
33906 | HB_Error HB_GPOS_Query_Languages( HB_GPOSHeader* gpos, | |
33907 | HB_UShort script_index, | |
33908 | HB_UInt** language_tag_list ); | |
33909 | HB_Error HB_GPOS_Query_Features( HB_GPOSHeader* gpos, | |
33910 | HB_UShort script_index, | |
33911 | HB_UShort language_index, | |
33912 | HB_UInt** feature_tag_list ); | |
33913 | HB_Error HB_GPOS_Add_Feature( HB_GPOSHeader* gpos, | |
33914 | HB_UShort feature_index, | |
33915 | HB_UInt property ); | |
33916 | HB_Error HB_GPOS_Clear_Features( HB_GPOSHeader* gpos ); | |
33917 | HB_Error HB_GPOS_Register_MM_Function( HB_GPOSHeader* gpos, | |
33918 | HB_MMFunction mmfunc, | |
33919 | void* data ); | |
33920 | HB_Error HB_GPOS_Apply_String( HB_Font font, | |
33921 | HB_GPOSHeader* gpos, | |
33922 | HB_UShort load_flags, | |
33923 | HB_Buffer buffer, | |
33924 | HB_Bool dvi, | |
33925 | HB_Bool r2l ); | |
33926 | } | |
33927 | extern "C" { | |
33928 | typedef HB_UShort (*HB_AltFunction)(HB_UInt pos, | |
33929 | HB_UShort glyphID, | |
33930 | HB_UShort num_alternates, | |
33931 | HB_UShort* alternates, | |
33932 | void* data ); | |
33933 | struct HB_GSUBHeader_ | |
33934 | { | |
33935 | HB_UInt offset; | |
33936 | HB_16Dot16 Version; | |
33937 | HB_ScriptList ScriptList; | |
33938 | HB_FeatureList FeatureList; | |
33939 | HB_LookupList LookupList; | |
33940 | HB_GDEFHeader* gdef; | |
33941 | HB_AltFunction altfunc; | |
33942 | void* data; | |
33943 | }; | |
33944 | typedef struct HB_GSUBHeader_ HB_GSUBHeader; | |
33945 | typedef HB_GSUBHeader* HB_GSUB; | |
33946 | HB_Error HB_Load_GSUB_Table( HB_Stream stream, | |
33947 | HB_GSUBHeader** gsub, | |
33948 | HB_GDEFHeader* gdef, | |
33949 | HB_Stream gdefStream ); | |
33950 | HB_Error HB_Done_GSUB_Table( HB_GSUBHeader* gsub ); | |
33951 | HB_Error HB_GSUB_Select_Script( HB_GSUBHeader* gsub, | |
33952 | HB_UInt script_tag, | |
33953 | HB_UShort* script_index ); | |
33954 | HB_Error HB_GSUB_Select_Language( HB_GSUBHeader* gsub, | |
33955 | HB_UInt language_tag, | |
33956 | HB_UShort script_index, | |
33957 | HB_UShort* language_index, | |
33958 | HB_UShort* req_feature_index ); | |
33959 | HB_Error HB_GSUB_Select_Feature( HB_GSUBHeader* gsub, | |
33960 | HB_UInt feature_tag, | |
33961 | HB_UShort script_index, | |
33962 | HB_UShort language_index, | |
33963 | HB_UShort* feature_index ); | |
33964 | HB_Error HB_GSUB_Query_Scripts( HB_GSUBHeader* gsub, | |
33965 | HB_UInt** script_tag_list ); | |
33966 | HB_Error HB_GSUB_Query_Languages( HB_GSUBHeader* gsub, | |
33967 | HB_UShort script_index, | |
33968 | HB_UInt** language_tag_list ); | |
33969 | HB_Error HB_GSUB_Query_Features( HB_GSUBHeader* gsub, | |
33970 | HB_UShort script_index, | |
33971 | HB_UShort language_index, | |
33972 | HB_UInt** feature_tag_list ); | |
33973 | HB_Error HB_GSUB_Add_Feature( HB_GSUBHeader* gsub, | |
33974 | HB_UShort feature_index, | |
33975 | HB_UInt property ); | |
33976 | HB_Error HB_GSUB_Clear_Features( HB_GSUBHeader* gsub ); | |
33977 | HB_Error HB_GSUB_Register_Alternate_Function( HB_GSUBHeader* gsub, | |
33978 | HB_AltFunction altfunc, | |
33979 | void* data ); | |
33980 | HB_Error HB_GSUB_Apply_String( HB_GSUBHeader* gsub, | |
33981 | HB_Buffer buffer ); | |
33982 | } | |
33983 | extern "C" { | |
33984 | typedef enum { | |
33985 | HB_LineBreak_OP, HB_LineBreak_CL, HB_LineBreak_QU, HB_LineBreak_GL, HB_LineBreak_NS, | |
33986 | HB_LineBreak_EX, HB_LineBreak_SY, HB_LineBreak_IS, HB_LineBreak_PR, HB_LineBreak_PO, | |
33987 | HB_LineBreak_NU, HB_LineBreak_AL, HB_LineBreak_ID, HB_LineBreak_IN, HB_LineBreak_HY, | |
33988 | HB_LineBreak_BA, HB_LineBreak_BB, HB_LineBreak_B2, HB_LineBreak_ZW, HB_LineBreak_CM, | |
33989 | HB_LineBreak_WJ, HB_LineBreak_H2, HB_LineBreak_H3, HB_LineBreak_JL, HB_LineBreak_JV, | |
33990 | HB_LineBreak_JT, HB_LineBreak_SA, HB_LineBreak_SG, | |
33991 | HB_LineBreak_SP, HB_LineBreak_CR, HB_LineBreak_LF, HB_LineBreak_BK | |
33992 | } HB_LineBreakClass; | |
33993 | typedef enum | |
33994 | { | |
33995 | HB_NoCategory, | |
33996 | HB_Mark_NonSpacing, | |
33997 | HB_Mark_SpacingCombining, | |
33998 | HB_Mark_Enclosing, | |
33999 | HB_Number_DecimalDigit, | |
34000 | HB_Number_Letter, | |
34001 | HB_Number_Other, | |
34002 | HB_Separator_Space, | |
34003 | HB_Separator_Line, | |
34004 | HB_Separator_Paragraph, | |
34005 | HB_Other_Control, | |
34006 | HB_Other_Format, | |
34007 | HB_Other_Surrogate, | |
34008 | HB_Other_PrivateUse, | |
34009 | HB_Other_NotAssigned, | |
34010 | HB_Letter_Uppercase, | |
34011 | HB_Letter_Lowercase, | |
34012 | HB_Letter_Titlecase, | |
34013 | HB_Letter_Modifier, | |
34014 | HB_Letter_Other, | |
34015 | HB_Punctuation_Connector, | |
34016 | HB_Punctuation_Dash, | |
34017 | HB_Punctuation_Open, | |
34018 | HB_Punctuation_Close, | |
34019 | HB_Punctuation_InitialQuote, | |
34020 | HB_Punctuation_FinalQuote, | |
34021 | HB_Punctuation_Other, | |
34022 | HB_Symbol_Math, | |
34023 | HB_Symbol_Currency, | |
34024 | HB_Symbol_Modifier, | |
34025 | HB_Symbol_Other | |
34026 | } HB_CharCategory; | |
34027 | typedef enum | |
34028 | { | |
34029 | HB_Grapheme_Other, | |
34030 | HB_Grapheme_CR, | |
34031 | HB_Grapheme_LF, | |
34032 | HB_Grapheme_Control, | |
34033 | HB_Grapheme_Extend, | |
34034 | HB_Grapheme_L, | |
34035 | HB_Grapheme_V, | |
34036 | HB_Grapheme_T, | |
34037 | HB_Grapheme_LV, | |
34038 | HB_Grapheme_LVT | |
34039 | } HB_GraphemeClass; | |
34040 | typedef enum | |
34041 | { | |
34042 | HB_Word_Other, | |
34043 | HB_Word_Format, | |
34044 | HB_Word_Katakana, | |
34045 | HB_Word_ALetter, | |
34046 | HB_Word_MidLetter, | |
34047 | HB_Word_MidNum, | |
34048 | HB_Word_Numeric, | |
34049 | HB_Word_ExtendNumLet | |
34050 | } HB_WordClass; | |
34051 | typedef enum | |
34052 | { | |
34053 | HB_Sentence_Other, | |
34054 | HB_Sentence_Sep, | |
34055 | HB_Sentence_Format, | |
34056 | HB_Sentence_Sp, | |
34057 | HB_Sentence_Lower, | |
34058 | HB_Sentence_Upper, | |
34059 | HB_Sentence_OLetter, | |
34060 | HB_Sentence_Numeric, | |
34061 | HB_Sentence_ATerm, | |
34062 | HB_Sentence_STerm, | |
34063 | HB_Sentence_Close | |
34064 | } HB_SentenceClass; | |
34065 | HB_GraphemeClass HB_GetGraphemeClass(HB_UChar32 ch); | |
34066 | HB_WordClass HB_GetWordClass(HB_UChar32 ch); | |
34067 | HB_SentenceClass HB_GetSentenceClass(HB_UChar32 ch); | |
34068 | HB_LineBreakClass HB_GetLineBreakClass(HB_UChar32 ch); | |
34069 | void HB_GetGraphemeAndLineBreakClass(HB_UChar32 ch, HB_GraphemeClass *grapheme, HB_LineBreakClass *lineBreak); | |
34070 | void HB_GetUnicodeCharProperties(HB_UChar32 ch, HB_CharCategory *category, int *combiningClass); | |
34071 | HB_CharCategory HB_GetUnicodeCharCategory(HB_UChar32 ch); | |
34072 | int HB_GetUnicodeCharCombiningClass(HB_UChar32 ch); | |
34073 | HB_UChar16 HB_GetMirroredChar(HB_UChar16 ch); | |
34074 | void *HB_Library_Resolve(const char *library, const char *symbol); | |
34075 | void *HB_TextCodecForMib(int mib); | |
34076 | char *HB_TextCodec_ConvertFromUnicode(void *codec, const HB_UChar16 *unicode, hb_uint32 length, hb_uint32 *outputLength); | |
34077 | void HB_TextCodec_FreeResult(char *); | |
34078 | } | |
34079 | extern "C" { | |
34080 | HB_Pointer | |
34081 | _hb_alloc( size_t size, | |
34082 | HB_Error *perror_ ); | |
34083 | HB_Pointer | |
34084 | _hb_realloc( HB_Pointer block, | |
34085 | size_t new_size, | |
34086 | HB_Error *perror_ ); | |
34087 | void | |
34088 | _hb_free( HB_Pointer block ); | |
34089 | HB_Error | |
34090 | _hb_err (HB_Error code); | |
34091 | } | |
34092 | extern "C" { | |
34093 | void | |
34094 | _hb_close_stream( HB_Stream stream ); | |
34095 | HB_Int | |
34096 | _hb_stream_pos( HB_Stream stream ); | |
34097 | HB_Error | |
34098 | _hb_stream_seek( HB_Stream stream, | |
34099 | HB_UInt pos ); | |
34100 | HB_Error | |
34101 | _hb_stream_frame_enter( HB_Stream stream, | |
34102 | HB_UInt size ); | |
34103 | void | |
34104 | _hb_stream_frame_exit( HB_Stream stream ); | |
34105 | } | |
34106 | extern "C" { | |
34107 | typedef enum { | |
34108 | HB_Script_Common, | |
34109 | HB_Script_Greek, | |
34110 | HB_Script_Cyrillic, | |
34111 | HB_Script_Armenian, | |
34112 | HB_Script_Hebrew, | |
34113 | HB_Script_Arabic, | |
34114 | HB_Script_Syriac, | |
34115 | HB_Script_Thaana, | |
34116 | HB_Script_Devanagari, | |
34117 | HB_Script_Bengali, | |
34118 | HB_Script_Gurmukhi, | |
34119 | HB_Script_Gujarati, | |
34120 | HB_Script_Oriya, | |
34121 | HB_Script_Tamil, | |
34122 | HB_Script_Telugu, | |
34123 | HB_Script_Kannada, | |
34124 | HB_Script_Malayalam, | |
34125 | HB_Script_Sinhala, | |
34126 | HB_Script_Thai, | |
34127 | HB_Script_Lao, | |
34128 | HB_Script_Tibetan, | |
34129 | HB_Script_Myanmar, | |
34130 | HB_Script_Georgian, | |
34131 | HB_Script_Hangul, | |
34132 | HB_Script_Ogham, | |
34133 | HB_Script_Runic, | |
34134 | HB_Script_Khmer, | |
34135 | HB_Script_Inherited, | |
34136 | HB_ScriptCount = HB_Script_Inherited | |
34137 | } HB_Script; | |
34138 | typedef struct | |
34139 | { | |
34140 | hb_uint32 pos; | |
34141 | hb_uint32 length; | |
34142 | HB_Script script; | |
34143 | hb_uint8 bidiLevel; | |
34144 | } HB_ScriptItem; | |
34145 | typedef enum { | |
34146 | HB_NoBreak, | |
34147 | HB_SoftHyphen, | |
34148 | HB_Break, | |
34149 | HB_ForcedBreak | |
34150 | } HB_LineBreakType; | |
34151 | typedef struct { | |
34152 | unsigned lineBreakType :2; | |
34153 | unsigned whiteSpace :1; | |
34154 | unsigned charStop :1; | |
34155 | unsigned wordBoundary :1; | |
34156 | unsigned sentenceBoundary :1; | |
34157 | unsigned unused :2; | |
34158 | } HB_CharAttributes; | |
34159 | void HB_GetCharAttributes(const HB_UChar16 *string, hb_uint32 stringLength, | |
34160 | const HB_ScriptItem *items, hb_uint32 numItems, | |
34161 | HB_CharAttributes *attributes); | |
34162 | void HB_GetWordBoundaries(const HB_UChar16 *string, hb_uint32 stringLength, | |
34163 | const HB_ScriptItem *items, hb_uint32 numItems, | |
34164 | HB_CharAttributes *attributes); | |
34165 | void HB_GetSentenceBoundaries(const HB_UChar16 *string, hb_uint32 stringLength, | |
34166 | const HB_ScriptItem *items, hb_uint32 numItems, | |
34167 | HB_CharAttributes *attributes); | |
34168 | typedef enum { | |
34169 | HB_LeftToRight = 0, | |
34170 | HB_RightToLeft = 1 | |
34171 | } HB_StringToGlyphsFlags; | |
34172 | typedef enum { | |
34173 | HB_ShaperFlag_Default = 0, | |
34174 | HB_ShaperFlag_NoKerning = 1, | |
34175 | HB_ShaperFlag_UseDesignMetrics = 2 | |
34176 | } HB_ShaperFlag; | |
34177 | typedef enum { | |
34178 | HB_NoJustification= 0, | |
34179 | HB_Arabic_Space = 1, | |
34180 | HB_Character = 2, | |
34181 | HB_Space = 4, | |
34182 | HB_Arabic_Normal = 7, | |
34183 | HB_Arabic_Waw = 8, | |
34184 | HB_Arabic_BaRa = 9, | |
34185 | HB_Arabic_Alef = 10, | |
34186 | HB_Arabic_HaaDal = 11, | |
34187 | HB_Arabic_Seen = 12, | |
34188 | HB_Arabic_Kashida = 13 | |
34189 | } HB_JustificationClass; | |
34190 | typedef struct { | |
34191 | unsigned justification :4; | |
34192 | unsigned clusterStart :1; | |
34193 | unsigned mark :1; | |
34194 | unsigned zeroWidth :1; | |
34195 | unsigned dontPrint :1; | |
34196 | unsigned combiningClass :8; | |
34197 | } HB_GlyphAttributes; | |
34198 | typedef struct HB_FaceRec_ { | |
34199 | HB_Bool isSymbolFont; | |
34200 | HB_GDEF gdef; | |
34201 | HB_GSUB gsub; | |
34202 | HB_GPOS gpos; | |
34203 | HB_Bool supported_scripts[HB_ScriptCount]; | |
34204 | HB_Buffer buffer; | |
34205 | HB_Script current_script; | |
34206 | int current_flags; | |
34207 | HB_Bool has_opentype_kerning; | |
34208 | HB_Bool glyphs_substituted; | |
34209 | HB_GlyphAttributes *tmpAttributes; | |
34210 | unsigned int *tmpLogClusters; | |
34211 | int length; | |
34212 | int orig_nglyphs; | |
34213 | } HB_FaceRec; | |
34214 | typedef HB_Error (*HB_GetFontTableFunc)(void *font, HB_Tag tag, HB_Byte *buffer, HB_UInt *length); | |
34215 | HB_Face HB_NewFace(void *font, HB_GetFontTableFunc tableFunc); | |
34216 | void HB_FreeFace(HB_Face face); | |
34217 | typedef struct { | |
34218 | HB_Fixed x, y; | |
34219 | HB_Fixed width, height; | |
34220 | HB_Fixed xOffset, yOffset; | |
34221 | } HB_GlyphMetrics; | |
34222 | typedef enum { | |
34223 | HB_FontAscent | |
34224 | } HB_FontMetric; | |
34225 | typedef struct { | |
34226 | HB_Bool (*convertStringToGlyphIndices)(HB_Font font, const HB_UChar16 *string, hb_uint32 length, HB_Glyph *glyphs, hb_uint32 *numGlyphs, HB_Bool rightToLeft); | |
34227 | void (*getGlyphAdvances)(HB_Font font, const HB_Glyph *glyphs, hb_uint32 numGlyphs, HB_Fixed *advances, int flags ); | |
34228 | HB_Bool (*canRender)(HB_Font font, const HB_UChar16 *string, hb_uint32 length); | |
34229 | HB_Error (*getPointInOutline)(HB_Font font, HB_Glyph glyph, int flags , hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints); | |
34230 | void (*getGlyphMetrics)(HB_Font font, HB_Glyph glyph, HB_GlyphMetrics *metrics); | |
34231 | HB_Fixed (*getFontMetric)(HB_Font font, HB_FontMetric metric); | |
34232 | } HB_FontClass; | |
34233 | typedef struct HB_Font_ { | |
34234 | const HB_FontClass *klass; | |
34235 | HB_UShort x_ppem, y_ppem; | |
34236 | HB_16Dot16 x_scale, y_scale; | |
34237 | void *userData; | |
34238 | } HB_FontRec; | |
34239 | typedef struct { | |
34240 | const HB_UChar16 *string; | |
34241 | hb_uint32 stringLength; | |
34242 | HB_ScriptItem item; | |
34243 | HB_Font font; | |
34244 | HB_Face face; | |
34245 | int shaperFlags; | |
34246 | HB_Bool glyphIndicesPresent; | |
34247 | hb_uint32 initialGlyphCount; | |
34248 | hb_uint32 num_glyphs; | |
34249 | HB_Glyph *glyphs; | |
34250 | HB_GlyphAttributes *attributes; | |
34251 | HB_Fixed *advances; | |
34252 | HB_FixedPoint *offsets; | |
34253 | unsigned short *log_clusters; | |
34254 | HB_Bool kerning_applied; | |
34255 | } HB_ShaperItem; | |
34256 | HB_Bool HB_ShapeItem(HB_ShaperItem *item); | |
34257 | } | |
34258 | __attribute__((visibility("default"))) void qGetCharAttributes(const HB_UChar16 *string, hb_uint32 stringLength, | |
34259 | const HB_ScriptItem *items, hb_uint32 numItems, | |
34260 | HB_CharAttributes *attributes); | |
34261 | __attribute__((visibility("default"))) HB_Bool qShapeItem(HB_ShaperItem *item); | |
34262 | __attribute__((visibility("default"))) HB_Face qHBNewFace(void *font, HB_GetFontTableFunc tableFunc); | |
34263 | __attribute__((visibility("default"))) void qHBFreeFace(HB_Face); | |
34264 | template <> class QTypeInfo<HB_GlyphAttributes> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(HB_GlyphAttributes)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "HB_GlyphAttributes"; } }; | |
34265 | template <> class QTypeInfo<HB_FixedPoint> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(HB_FixedPoint)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "HB_FixedPoint"; } }; | |
34266 | class QFontPrivate; | |
34267 | class QFontEngine; | |
34268 | class QString; | |
34269 | class QPainter; | |
34270 | class QAbstractTextDocumentLayout; | |
34271 | struct glyph_metrics_t | |
34272 | { | |
34273 | inline glyph_metrics_t() | |
34274 | : x(100000), y(100000) {} | |
34275 | inline glyph_metrics_t(QFixed _x, QFixed _y, QFixed _width, QFixed _height, QFixed _xoff, QFixed _yoff) | |
34276 | : x(_x), | |
34277 | y(_y), | |
34278 | width(_width), | |
34279 | height(_height), | |
34280 | xoff(_xoff), | |
34281 | yoff(_yoff) | |
34282 | {} | |
34283 | QFixed x; | |
34284 | QFixed y; | |
34285 | QFixed width; | |
34286 | QFixed height; | |
34287 | QFixed xoff; | |
34288 | QFixed yoff; | |
34289 | glyph_metrics_t transformed(const QTransform &xform) const; | |
34290 | }; | |
34291 | template <> class QTypeInfo<glyph_metrics_t> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(glyph_metrics_t)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "glyph_metrics_t"; } }; | |
34292 | struct QScriptAnalysis | |
34293 | { | |
34294 | enum Flags { | |
34295 | None = 0, | |
34296 | Lowercase = 1, | |
34297 | Uppercase = 2, | |
34298 | SmallCaps = 3, | |
34299 | LineOrParagraphSeparator = 4, | |
34300 | Space = 5, | |
34301 | SpaceTabOrObject = Space, | |
34302 | Tab = 6, | |
34303 | TabOrObject = Tab, | |
34304 | Object = 7 | |
34305 | }; | |
34306 | unsigned short script : 8; | |
34307 | unsigned short bidiLevel : 6; | |
34308 | unsigned short flags : 3; | |
34309 | inline bool operator == (const QScriptAnalysis &other) const { | |
34310 | return script == other.script && bidiLevel == other.bidiLevel && flags == other.flags; | |
34311 | } | |
34312 | }; | |
34313 | template <> class QTypeInfo<QScriptAnalysis> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QScriptAnalysis)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QScriptAnalysis"; } }; | |
34314 | struct QGlyphJustification | |
34315 | { | |
34316 | inline QGlyphJustification() | |
34317 | : type(0), nKashidas(0), space_18d6(0) | |
34318 | {} | |
34319 | enum JustificationType { | |
34320 | JustifyNone, | |
34321 | JustifySpace, | |
34322 | JustifyKashida | |
34323 | }; | |
34324 | uint type :2; | |
34325 | uint nKashidas : 6; | |
34326 | uint space_18d6 : 24; | |
34327 | }; | |
34328 | template <> class QTypeInfo<QGlyphJustification> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QGlyphJustification)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QGlyphJustification"; } }; | |
34329 | struct QGlyphLayoutInstance | |
34330 | { | |
34331 | QFixedPoint offset; | |
34332 | QFixedPoint advance; | |
34333 | HB_Glyph glyph; | |
34334 | QGlyphJustification justification; | |
34335 | HB_GlyphAttributes attributes; | |
34336 | }; | |
34337 | struct QGlyphLayout | |
34338 | { | |
34339 | QFixedPoint *offsets; | |
34340 | HB_Glyph *glyphs; | |
34341 | QFixed *advances_x; | |
34342 | QFixed *advances_y; | |
34343 | QGlyphJustification *justifications; | |
34344 | HB_GlyphAttributes *attributes; | |
34345 | int numGlyphs; | |
34346 | inline QGlyphLayout() : numGlyphs(0) {} | |
34347 | inline explicit QGlyphLayout(char *address, int totalGlyphs) | |
34348 | { | |
34349 | offsets = reinterpret_cast<QFixedPoint *>(address); | |
34350 | int offset = totalGlyphs * sizeof(HB_FixedPoint); | |
34351 | glyphs = reinterpret_cast<HB_Glyph *>(address + offset); | |
34352 | offset += totalGlyphs * sizeof(HB_Glyph); | |
34353 | advances_x = reinterpret_cast<QFixed *>(address + offset); | |
34354 | offset += totalGlyphs * sizeof(QFixed); | |
34355 | advances_y = reinterpret_cast<QFixed *>(address + offset); | |
34356 | offset += totalGlyphs * sizeof(QFixed); | |
34357 | justifications = reinterpret_cast<QGlyphJustification *>(address + offset); | |
34358 | offset += totalGlyphs * sizeof(QGlyphJustification); | |
34359 | attributes = reinterpret_cast<HB_GlyphAttributes *>(address + offset); | |
34360 | numGlyphs = totalGlyphs; | |
34361 | } | |
34362 | inline QGlyphLayout mid(int position, int n = -1) const { | |
34363 | QGlyphLayout copy = *this; | |
34364 | copy.glyphs += position; | |
34365 | copy.advances_x += position; | |
34366 | copy.advances_y += position; | |
34367 | copy.offsets += position; | |
34368 | copy.justifications += position; | |
34369 | copy.attributes += position; | |
34370 | if (n == -1) | |
34371 | copy.numGlyphs -= position; | |
34372 | else | |
34373 | copy.numGlyphs = n; | |
34374 | return copy; | |
34375 | } | |
34376 | static inline int spaceNeededForGlyphLayout(int totalGlyphs) { | |
34377 | return totalGlyphs * (sizeof(HB_Glyph) + sizeof(HB_GlyphAttributes) | |
34378 | + sizeof(QFixed) + sizeof(QFixed) + sizeof(QFixedPoint) | |
34379 | + sizeof(QGlyphJustification)); | |
34380 | } | |
34381 | inline QFixed effectiveAdvance(int item) const | |
34382 | { return (advances_x[item] + QFixed::fromFixed(justifications[item].space_18d6)) * !attributes[item].dontPrint; } | |
34383 | inline QGlyphLayoutInstance instance(int position) const { | |
34384 | QGlyphLayoutInstance g; | |
34385 | g.offset.x = offsets[position].x; | |
34386 | g.offset.y = offsets[position].y; | |
34387 | g.glyph = glyphs[position]; | |
34388 | g.advance.x = advances_x[position]; | |
34389 | g.advance.y = advances_y[position]; | |
34390 | g.justification = justifications[position]; | |
34391 | g.attributes = attributes[position]; | |
34392 | return g; | |
34393 | } | |
34394 | inline void setInstance(int position, const QGlyphLayoutInstance &g) { | |
34395 | offsets[position].x = g.offset.x; | |
34396 | offsets[position].y = g.offset.y; | |
34397 | glyphs[position] = g.glyph; | |
34398 | advances_x[position] = g.advance.x; | |
34399 | advances_y[position] = g.advance.y; | |
34400 | justifications[position] = g.justification; | |
34401 | attributes[position] = g.attributes; | |
34402 | } | |
34403 | inline void clear(int first = 0, int last = -1) { | |
34404 | if (last == -1) | |
34405 | last = numGlyphs; | |
34406 | if (first == 0 && last == numGlyphs | |
34407 | && reinterpret_cast<char *>(offsets + numGlyphs) == reinterpret_cast<char *>(glyphs)) { | |
34408 | memset(offsets, 0, spaceNeededForGlyphLayout(numGlyphs)); | |
34409 | } else { | |
34410 | const int num = last - first; | |
34411 | memset(offsets + first, 0, num * sizeof(QFixedPoint)); | |
34412 | memset(glyphs + first, 0, num * sizeof(HB_Glyph)); | |
34413 | memset(advances_x + first, 0, num * sizeof(QFixed)); | |
34414 | memset(advances_y + first, 0, num * sizeof(QFixed)); | |
34415 | memset(justifications + first, 0, num * sizeof(QGlyphJustification)); | |
34416 | memset(attributes + first, 0, num * sizeof(HB_GlyphAttributes)); | |
34417 | } | |
34418 | } | |
34419 | inline char *data() { | |
34420 | return reinterpret_cast<char *>(offsets); | |
34421 | } | |
34422 | void grow(char *address, int totalGlyphs); | |
34423 | }; | |
34424 | class QVarLengthGlyphLayoutArray : private QVarLengthArray<void *>, public QGlyphLayout | |
34425 | { | |
34426 | private: | |
34427 | typedef QVarLengthArray<void *> Array; | |
34428 | public: | |
34429 | QVarLengthGlyphLayoutArray(int totalGlyphs) | |
34430 | : Array(spaceNeededForGlyphLayout(totalGlyphs) / sizeof(void *) + 1) | |
34431 | , QGlyphLayout(reinterpret_cast<char *>(Array::data()), totalGlyphs) | |
34432 | { | |
34433 | memset(Array::data(), 0, Array::size() * sizeof(void *)); | |
34434 | } | |
34435 | void resize(int totalGlyphs) | |
34436 | { | |
34437 | Array::resize(spaceNeededForGlyphLayout(totalGlyphs) / sizeof(void *) + 1); | |
34438 | *((QGlyphLayout *)this) = QGlyphLayout(reinterpret_cast<char *>(Array::data()), totalGlyphs); | |
34439 | memset(Array::data(), 0, Array::size() * sizeof(void *)); | |
34440 | } | |
34441 | }; | |
34442 | template <int N> struct QGlyphLayoutArray : public QGlyphLayout | |
34443 | { | |
34444 | public: | |
34445 | QGlyphLayoutArray() | |
34446 | : QGlyphLayout(reinterpret_cast<char *>(buffer), N) | |
34447 | { | |
34448 | memset(buffer, 0, sizeof(buffer)); | |
34449 | } | |
34450 | private: | |
34451 | void *buffer[(N * (sizeof(HB_Glyph) + sizeof(HB_GlyphAttributes) | |
34452 | + sizeof(QFixed) + sizeof(QFixed) + sizeof(QFixedPoint) | |
34453 | + sizeof(QGlyphJustification))) | |
34454 | / sizeof(void *) + 1]; | |
34455 | }; | |
34456 | struct QScriptItem; | |
34457 | class QTextItemInt : public QTextItem | |
34458 | { | |
34459 | public: | |
34460 | inline QTextItemInt() | |
34461 | : justified(false), underlineStyle(QTextCharFormat::NoUnderline), num_chars(0), chars(0), | |
34462 | logClusters(0), f(0), fontEngine(0) | |
34463 | {} | |
34464 | QTextItemInt(const QScriptItem &si, QFont *font, const QTextCharFormat &format = QTextCharFormat()); | |
34465 | QTextItemInt midItem(QFontEngine *fontEngine, int firstGlyphIndex, int numGlyphs) const; | |
34466 | QFixed descent; | |
34467 | QFixed ascent; | |
34468 | QFixed width; | |
34469 | RenderFlags flags; | |
34470 | bool justified; | |
34471 | QTextCharFormat::UnderlineStyle underlineStyle; | |
34472 | const QTextCharFormat charFormat; | |
34473 | int num_chars; | |
34474 | const QChar *chars; | |
34475 | const unsigned short *logClusters; | |
34476 | const QFont *f; | |
34477 | QGlyphLayout glyphs; | |
34478 | QFontEngine *fontEngine; | |
34479 | }; | |
34480 | inline bool qIsControlChar(ushort uc) | |
34481 | { | |
34482 | return uc >= 0x200b && uc <= 0x206f | |
34483 | && (uc <= 0x200f | |
34484 | || (uc >= 0x2028 && uc <= 0x202f ) | |
34485 | || uc >= 0x206a ); | |
34486 | } | |
34487 | struct QScriptItem | |
34488 | { | |
34489 | inline QScriptItem() | |
34490 | : position(0), | |
34491 | num_glyphs(0), descent(-1), ascent(-1), width(-1), | |
34492 | glyph_data_offset(0) {} | |
34493 | inline QScriptItem(int p, const QScriptAnalysis &a) | |
34494 | : position(p), analysis(a), | |
34495 | num_glyphs(0), descent(-1), ascent(-1), width(-1), | |
34496 | glyph_data_offset(0) {} | |
34497 | int position; | |
34498 | QScriptAnalysis analysis; | |
34499 | unsigned short num_glyphs; | |
34500 | QFixed descent; | |
34501 | QFixed ascent; | |
34502 | QFixed width; | |
34503 | int glyph_data_offset; | |
34504 | QFixed height() const { return ascent + descent + 1; } | |
34505 | }; | |
34506 | template <> class QTypeInfo<QScriptItem> { public: enum { isComplex = (((Q_MOVABLE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_MOVABLE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QScriptItem)>sizeof(void*)), isPointer = false, isDummy = (((Q_MOVABLE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QScriptItem"; } }; | |
34507 | typedef QVector<QScriptItem> QScriptItemArray; | |
34508 | struct QScriptLine | |
34509 | { | |
34510 | QScriptLine() | |
34511 | : from(0), length(0), | |
34512 | justified(0), gridfitted(0), | |
34513 | hasTrailingSpaces(0) {} | |
34514 | QFixed descent; | |
34515 | QFixed ascent; | |
34516 | QFixed x; | |
34517 | QFixed y; | |
34518 | QFixed width; | |
34519 | QFixed textWidth; | |
34520 | int from; | |
34521 | signed int length : 29; | |
34522 | mutable uint justified : 1; | |
34523 | mutable uint gridfitted : 1; | |
34524 | uint hasTrailingSpaces : 1; | |
34525 | QFixed height() const { return ascent + descent + 1; } | |
34526 | void setDefaultHeight(QTextEngine *eng); | |
34527 | void operator+=(const QScriptLine &other); | |
34528 | }; | |
34529 | template <> class QTypeInfo<QScriptLine> { public: enum { isComplex = (((Q_PRIMITIVE_TYPE) & Q_PRIMITIVE_TYPE) == 0), isStatic = (((Q_PRIMITIVE_TYPE) & (Q_MOVABLE_TYPE | Q_PRIMITIVE_TYPE)) == 0), isLarge = (sizeof(QScriptLine)>sizeof(void*)), isPointer = false, isDummy = (((Q_PRIMITIVE_TYPE) & Q_DUMMY_TYPE) != 0) }; static inline const char *name() { return "QScriptLine"; } }; | |
34530 | inline void QScriptLine::operator+=(const QScriptLine &other) | |
34531 | { | |
34532 | descent = qMax(descent, other.descent); | |
34533 | ascent = qMax(ascent, other.ascent); | |
34534 | textWidth += other.textWidth; | |
34535 | length += other.length; | |
34536 | } | |
34537 | typedef QVector<QScriptLine> QScriptLineArray; | |
34538 | class QFontPrivate; | |
34539 | class QTextFormatCollection; | |
34540 | class __attribute__((visibility("default"))) QTextEngine { | |
34541 | public: | |
34542 | struct LayoutData { | |
34543 | LayoutData(const QString &str, void **stack_memory, int mem_size); | |
34544 | LayoutData(); | |
34545 | ~LayoutData(); | |
34546 | mutable QScriptItemArray items; | |
34547 | int allocated; | |
34548 | int available_glyphs; | |
34549 | void **memory; | |
34550 | unsigned short *logClustersPtr; | |
34551 | QGlyphLayout glyphLayout; | |
34552 | mutable int used; | |
34553 | uint hasBidi : 1; | |
34554 | uint inLayout : 1; | |
34555 | uint memory_on_stack : 1; | |
34556 | bool haveCharAttributes; | |
34557 | QString string; | |
34558 | void reallocate(int totalGlyphs); | |
34559 | }; | |
34560 | QTextEngine(LayoutData *data); | |
34561 | QTextEngine(); | |
34562 | QTextEngine(const QString &str, const QFont &f); | |
34563 | ~QTextEngine(); | |
34564 | enum Mode { | |
34565 | WidthOnly = 0x07 | |
34566 | }; | |
34567 | enum ShaperFlag { | |
34568 | RightToLeft = 0x0001, | |
34569 | DesignMetrics = 0x0002, | |
34570 | GlyphIndicesOnly = 0x0004 | |
34571 | }; | |
34572 | typedef QFlags<ShaperFlag> ShaperFlags; | |
34573 | void invalidate(); | |
34574 | void clearLineData(); | |
34575 | void validate() const; | |
34576 | void itemize() const; | |
34577 | static void bidiReorder(int numRuns, const quint8 *levels, int *visualOrder); | |
34578 | const HB_CharAttributes *attributes() const; | |
34579 | void shape(int item) const; | |
34580 | void justify(const QScriptLine &si); | |
34581 | QFixed width(int charFrom, int numChars) const; | |
34582 | glyph_metrics_t boundingBox(int from, int len) const; | |
34583 | glyph_metrics_t tightBoundingBox(int from, int len) const; | |
34584 | int length(int item) const { | |
34585 | const QScriptItem &si = layoutData->items[item]; | |
34586 | int from = si.position; | |
34587 | item++; | |
34588 | return (item < layoutData->items.size() ? layoutData->items[item].position : layoutData->string.length()) - from; | |
34589 | } | |
34590 | int length(const QScriptItem *si) const { | |
34591 | int end; | |
34592 | if (si + 1 < layoutData->items.constData()+ layoutData->items.size()) | |
34593 | end = (si+1)->position; | |
34594 | else | |
34595 | end = layoutData->string.length(); | |
34596 | return end - si->position; | |
34597 | } | |
34598 | QFontEngine *fontEngine(const QScriptItem &si, QFixed *ascent = 0, QFixed *descent = 0) const; | |
34599 | QFont font(const QScriptItem &si) const; | |
34600 | inline QFont font() const { return fnt; } | |
34601 | inline unsigned short *logClusters(const QScriptItem *si) const | |
34602 | { return layoutData->logClustersPtr+si->position; } | |
34603 | inline QGlyphLayout availableGlyphs(const QScriptItem *si) const { | |
34604 | return layoutData->glyphLayout.mid(si->glyph_data_offset); | |
34605 | } | |
34606 | inline QGlyphLayout shapedGlyphs(const QScriptItem *si) const { | |
34607 | return layoutData->glyphLayout.mid(si->glyph_data_offset, si->num_glyphs); | |
34608 | } | |
34609 | inline void ensureSpace(int nGlyphs) const { | |
34610 | if (layoutData->glyphLayout.numGlyphs - layoutData->used < nGlyphs) | |
34611 | layoutData->reallocate((((layoutData->used + nGlyphs)*3/2 + 15) >> 4) << 4); | |
34612 | } | |
34613 | void freeMemory(); | |
34614 | int findItem(int strPos) const; | |
34615 | inline QTextFormatCollection *formats() const { | |
34616 | return block.docHandle()->formatCollection(); | |
34617 | } | |
34618 | QTextCharFormat format(const QScriptItem *si) const; | |
34619 | inline QAbstractTextDocumentLayout *docLayout() const { | |
34620 | return block.docHandle()->document()->documentLayout(); | |
34621 | } | |
34622 | int formatIndex(const QScriptItem *si) const; | |
34623 | QFixed calculateTabWidth(int index, QFixed x) const; | |
34624 | mutable QScriptLineArray lines; | |
34625 | QString text; | |
34626 | QFont fnt; | |
34627 | QTextBlock block; | |
34628 | QTextOption option; | |
34629 | QFixed minWidth; | |
34630 | QFixed maxWidth; | |
34631 | QPointF position; | |
34632 | uint ignoreBidi : 1; | |
34633 | uint cacheGlyphs : 1; | |
34634 | uint stackEngine : 1; | |
34635 | uint forceJustification : 1; | |
34636 | int *underlinePositions; | |
34637 | mutable LayoutData *layoutData; | |
34638 | inline bool hasFormats() const { return (block.docHandle() || specialData); } | |
34639 | struct SpecialData { | |
34640 | int preeditPosition; | |
34641 | QString preeditText; | |
34642 | QList<QTextLayout::FormatRange> addFormats; | |
34643 | QVector<int> addFormatIndices; | |
34644 | QVector<int> resolvedFormatIndices; | |
34645 | }; | |
34646 | SpecialData *specialData; | |
34647 | bool atWordSeparator(int position) const; | |
34648 | bool atSpace(int position) const; | |
34649 | void indexAdditionalFormats(); | |
34650 | QString elidedText(Qt::TextElideMode mode, const QFixed &width, int flags = 0) const; | |
34651 | void shapeLine(const QScriptLine &line); | |
34652 | private: | |
34653 | void setBoundary(int strPos) const; | |
34654 | void addRequiredBoundaries() const; | |
34655 | void shapeText(int item) const; | |
34656 | void shapeTextWithHarfbuzz(int item) const; | |
34657 | void splitItem(int item, int pos) const; | |
34658 | void resolveAdditionalFormats() const; | |
34659 | }; | |
34660 | class QStackTextEngine : public QTextEngine { | |
34661 | public: | |
34662 | enum { MemSize = 256*40/sizeof(void *) }; | |
34663 | QStackTextEngine(const QString &string, const QFont &f); | |
34664 | LayoutData _layoutData; | |
34665 | void *_memory[MemSize]; | |
34666 | }; | |
34667 | inline QFlags<QTextEngine::ShaperFlags::enum_type> operator|(QTextEngine::ShaperFlags::enum_type f1, QTextEngine::ShaperFlags::enum_type f2) { return QFlags<QTextEngine::ShaperFlags::enum_type>(f1) | f2; } inline QFlags<QTextEngine::ShaperFlags::enum_type> operator|(QTextEngine::ShaperFlags::enum_type f1, QFlags<QTextEngine::ShaperFlags::enum_type> f2) { return f2 | f1; } inline QIncompatibleFlag operator|(QTextEngine::ShaperFlags::enum_type f1, int f2) { return QIncompatibleFlag(int(f1) | f2); } | |
34668 | class __attribute__((visibility("default"))) QFontEngineGlyphCache | |
34669 | { | |
34670 | public: | |
34671 | QFontEngineGlyphCache(const QTransform &matrix) : m_transform(matrix) { } | |
34672 | enum Type { | |
34673 | Raster_RGBMask, | |
34674 | Raster_A8, | |
34675 | Raster_Mono | |
34676 | }; | |
34677 | virtual ~QFontEngineGlyphCache(); | |
34678 | QTransform m_transform; | |
34679 | }; | |
34680 | typedef QHash<void *, QList<QFontEngineGlyphCache *> > GlyphPointerHash; | |
34681 | typedef QHash<int, QList<QFontEngineGlyphCache *> > GlyphIntHash; | |
34682 | struct glyph_metrics_t; | |
34683 | typedef unsigned int glyph_t; | |
34684 | class QChar; | |
34685 | class QPainterPath; | |
34686 | class QTextEngine; | |
34687 | struct QGlyphLayout; | |
34688 | class __attribute__((visibility("default"))) QFontEngine : public QObject | |
34689 | { | |
34690 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
34691 | public: | |
34692 | enum Type { | |
34693 | Box, | |
34694 | Multi, | |
34695 | XLFD, | |
34696 | Win, | |
34697 | Mac, | |
34698 | Freetype, | |
34699 | QPF1, | |
34700 | QPF2, | |
34701 | Proxy, | |
34702 | TestFontEngine = 0x1000 | |
34703 | }; | |
34704 | QFontEngine(); | |
34705 | virtual ~QFontEngine(); | |
34706 | struct Properties { | |
34707 | QByteArray postscriptName; | |
34708 | QByteArray copyright; | |
34709 | QRectF boundingBox; | |
34710 | QFixed emSquare; | |
34711 | QFixed ascent; | |
34712 | QFixed descent; | |
34713 | QFixed leading; | |
34714 | QFixed italicAngle; | |
34715 | QFixed capHeight; | |
34716 | QFixed lineWidth; | |
34717 | }; | |
34718 | virtual Properties properties() const; | |
34719 | virtual void getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics); | |
34720 | QByteArray getSfntTable(uint ) const; | |
34721 | virtual bool getSfntTableData(uint , uchar * , uint * ) const { return false; } | |
34722 | struct FaceId { | |
34723 | FaceId() : index(0), encoding(0) {} | |
34724 | QByteArray filename; | |
34725 | int index; | |
34726 | int encoding; | |
34727 | }; | |
34728 | virtual FaceId faceId() const { return FaceId(); } | |
34729 | enum SynthesizedFlags { | |
34730 | SynthesizedItalic = 0x1, | |
34731 | SynthesizedBold = 0x2, | |
34732 | SynthesizedStretch = 0x4 | |
34733 | }; | |
34734 | virtual int synthesized() const { return 0; } | |
34735 | virtual QFixed emSquareSize() const { return ascent(); } | |
34736 | virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const = 0; | |
34737 | virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const {} | |
34738 | virtual void doKerning(QGlyphLayout *, QTextEngine::ShaperFlags) const; | |
34739 | virtual void draw(QPaintEngine *p, qreal x, qreal y, const QTextItemInt &si) = 0; | |
34740 | virtual void addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nglyphs, | |
34741 | QPainterPath *path, QTextItem::RenderFlags flags); | |
34742 | void getGlyphPositions(const QGlyphLayout &glyphs, const QTransform &matrix, QTextItem::RenderFlags flags, | |
34743 | QVarLengthArray<glyph_t> &glyphs_out, QVarLengthArray<QFixedPoint> &positions); | |
34744 | virtual void addOutlineToPath(qreal, qreal, const QGlyphLayout &, QPainterPath *, QTextItem::RenderFlags flags); | |
34745 | void addBitmapFontToPath(qreal x, qreal y, const QGlyphLayout &, QPainterPath *, QTextItem::RenderFlags); | |
34746 | virtual QImage alphaMapForGlyph(glyph_t) = 0; | |
34747 | virtual QImage alphaMapForGlyph(glyph_t, const QTransform &t); | |
34748 | virtual QImage alphaRGBMapForGlyph(glyph_t, int margin, const QTransform &t); | |
34749 | virtual void removeGlyphFromCache(glyph_t); | |
34750 | virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs) = 0; | |
34751 | virtual glyph_metrics_t boundingBox(glyph_t glyph) = 0; | |
34752 | virtual glyph_metrics_t boundingBox(glyph_t glyph, const QTransform &matrix); | |
34753 | glyph_metrics_t tightBoundingBox(const QGlyphLayout &glyphs); | |
34754 | virtual QFixed ascent() const = 0; | |
34755 | virtual QFixed descent() const = 0; | |
34756 | virtual QFixed leading() const = 0; | |
34757 | virtual QFixed xHeight() const; | |
34758 | virtual QFixed averageCharWidth() const; | |
34759 | virtual QFixed lineThickness() const; | |
34760 | virtual QFixed underlinePosition() const; | |
34761 | virtual qreal maxCharWidth() const = 0; | |
34762 | virtual qreal minLeftBearing() const { return qreal(); } | |
34763 | virtual qreal minRightBearing() const { return qreal(); } | |
34764 | virtual const char *name() const = 0; | |
34765 | virtual bool canRender(const QChar *string, int len) = 0; | |
34766 | virtual Type type() const = 0; | |
34767 | virtual int glyphCount() const; | |
34768 | HB_Font harfbuzzFont() const; | |
34769 | HB_Face harfbuzzFace() const; | |
34770 | virtual HB_Error getPointInOutline(HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints); | |
34771 | void setGlyphCache(void *key, QFontEngineGlyphCache *data); | |
34772 | void setGlyphCache(QFontEngineGlyphCache::Type key, QFontEngineGlyphCache *data); | |
34773 | QFontEngineGlyphCache *glyphCache(void *key, const QTransform &transform) const; | |
34774 | QFontEngineGlyphCache *glyphCache(QFontEngineGlyphCache::Type key, const QTransform &transform) const; | |
34775 | static const uchar *getCMap(const uchar *table, uint tableSize, bool *isSymbolFont, int *cmapSize); | |
34776 | static quint32 getTrueTypeGlyphIndex(const uchar *cmap, uint unicode); | |
34777 | QAtomicInt ref; | |
34778 | QFontDef fontDef; | |
34779 | uint cache_cost; | |
34780 | int cache_count; | |
34781 | uint fsType : 16; | |
34782 | bool symbol; | |
34783 | mutable HB_FontRec hbFont; | |
34784 | mutable HB_Face hbFace; | |
34785 | struct KernPair { | |
34786 | uint left_right; | |
34787 | QFixed adjust; | |
34788 | inline bool operator<(const KernPair &other) const | |
34789 | { | |
34790 | return left_right < other.left_right; | |
34791 | } | |
34792 | }; | |
34793 | QVector<KernPair> kerning_pairs; | |
34794 | void loadKerningPairs(QFixed scalingFactor); | |
34795 | int glyphFormat; | |
34796 | private: | |
34797 | void expireGlyphCache(); | |
34798 | GlyphPointerHash m_glyphPointerHash; | |
34799 | GlyphIntHash m_glyphIntHash; | |
34800 | mutable QList<QFontEngineGlyphCache*> m_glyphCacheQueue; | |
34801 | }; | |
34802 | inline bool operator ==(const QFontEngine::FaceId &f1, const QFontEngine::FaceId &f2) | |
34803 | { | |
34804 | return (f1.index == f2.index) && (f1.encoding == f2.encoding) && (f1.filename == f2.filename); | |
34805 | } | |
34806 | inline uint qHash(const QFontEngine::FaceId &f) | |
34807 | { | |
34808 | return qHash((f.index << 16) + f.encoding) + qHash(f.filename); | |
34809 | } | |
34810 | class QGlyph; | |
34811 | class QFontEngineQPF1Data; | |
34812 | class QFontEngineQPF1 : public QFontEngine | |
34813 | { | |
34814 | public: | |
34815 | QFontEngineQPF1(const QFontDef&, const QString &fn); | |
34816 | ~QFontEngineQPF1(); | |
34817 | virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const; | |
34818 | virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const; | |
34819 | virtual void draw(QPaintEngine *p, qreal x, qreal y, const QTextItemInt &si); | |
34820 | virtual void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags); | |
34821 | virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs); | |
34822 | virtual glyph_metrics_t boundingBox(glyph_t glyph); | |
34823 | virtual QFixed ascent() const; | |
34824 | virtual QFixed descent() const; | |
34825 | virtual QFixed leading() const; | |
34826 | virtual qreal maxCharWidth() const; | |
34827 | virtual qreal minLeftBearing() const; | |
34828 | virtual qreal minRightBearing() const; | |
34829 | virtual QFixed underlinePosition() const; | |
34830 | virtual QFixed lineThickness() const; | |
34831 | virtual Type type() const; | |
34832 | virtual bool canRender(const QChar *string, int len); | |
34833 | inline const char *name() const { return 0; } | |
34834 | virtual QImage alphaMapForGlyph(glyph_t); | |
34835 | QFontEngineQPF1Data *d; | |
34836 | }; | |
34837 | class QFontEngineBox : public QFontEngine | |
34838 | { | |
34839 | public: | |
34840 | QFontEngineBox(int size); | |
34841 | ~QFontEngineBox(); | |
34842 | virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags flags) const; | |
34843 | virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const; | |
34844 | void draw(QPaintEngine *p, qreal x, qreal y, const QTextItemInt &si); | |
34845 | virtual void addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags); | |
34846 | virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs); | |
34847 | virtual glyph_metrics_t boundingBox(glyph_t glyph); | |
34848 | virtual QFixed ascent() const; | |
34849 | virtual QFixed descent() const; | |
34850 | virtual QFixed leading() const; | |
34851 | virtual qreal maxCharWidth() const; | |
34852 | virtual qreal minLeftBearing() const { return 0; } | |
34853 | virtual qreal minRightBearing() const { return 0; } | |
34854 | virtual QImage alphaMapForGlyph(glyph_t); | |
34855 | virtual const char *name() const; | |
34856 | virtual bool canRender(const QChar *string, int len); | |
34857 | virtual Type type() const; | |
34858 | inline int size() const { return _size; } | |
34859 | private: | |
34860 | friend class QFontPrivate; | |
34861 | int _size; | |
34862 | }; | |
34863 | class __attribute__((visibility("default"))) QFontEngineMulti : public QFontEngine | |
34864 | { | |
34865 | public: | |
34866 | explicit QFontEngineMulti(int engineCount); | |
34867 | ~QFontEngineMulti(); | |
34868 | virtual bool stringToCMap(const QChar *str, int len, QGlyphLayout *glyphs, int *nglyphs, | |
34869 | QTextEngine::ShaperFlags flags) const; | |
34870 | virtual glyph_metrics_t boundingBox(const QGlyphLayout &glyphs); | |
34871 | virtual glyph_metrics_t boundingBox(glyph_t glyph); | |
34872 | virtual void recalcAdvances(QGlyphLayout *, QTextEngine::ShaperFlags) const; | |
34873 | virtual void doKerning(QGlyphLayout *, QTextEngine::ShaperFlags) const; | |
34874 | virtual void addOutlineToPath(qreal, qreal, const QGlyphLayout &, QPainterPath *, QTextItem::RenderFlags flags); | |
34875 | virtual QFixed ascent() const; | |
34876 | virtual QFixed descent() const; | |
34877 | virtual QFixed leading() const; | |
34878 | virtual QFixed xHeight() const; | |
34879 | virtual QFixed averageCharWidth() const; | |
34880 | virtual QImage alphaMapForGlyph(glyph_t); | |
34881 | virtual QFixed lineThickness() const; | |
34882 | virtual QFixed underlinePosition() const; | |
34883 | virtual qreal maxCharWidth() const; | |
34884 | virtual qreal minLeftBearing() const; | |
34885 | virtual qreal minRightBearing() const; | |
34886 | virtual inline Type type() const | |
34887 | { return QFontEngine::Multi; } | |
34888 | virtual bool canRender(const QChar *string, int len); | |
34889 | inline virtual const char *name() const | |
34890 | { return "Multi"; } | |
34891 | QFontEngine *engine(int at) const; | |
34892 | protected: | |
34893 | friend class QPSPrintEnginePrivate; | |
34894 | friend class QPSPrintEngineFontMulti; | |
34895 | virtual void loadEngine(int at) = 0; | |
34896 | QVector<QFontEngine *> engines; | |
34897 | }; | |
34898 | class QTestFontEngine : public QFontEngineBox | |
34899 | { | |
34900 | public: | |
34901 | QTestFontEngine(int size) : QFontEngineBox(size) {} | |
34902 | virtual Type type() const { return TestFontEngine; } | |
34903 | }; | |
34904 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
34905 | class QVariant; | |
34906 | class __attribute__((visibility("default"))) QBitmap : public QPixmap | |
34907 | { | |
34908 | public: | |
34909 | QBitmap(); | |
34910 | QBitmap(const QPixmap &); | |
34911 | QBitmap(int w, int h); | |
34912 | explicit QBitmap(const QSize &); | |
34913 | explicit QBitmap(const QString &fileName, const char *format=0); | |
34914 | ~QBitmap(); | |
34915 | QBitmap &operator=(const QPixmap &); | |
34916 | operator QVariant() const; | |
34917 | inline void clear() { fill(Qt::color0); } | |
34918 | static QBitmap fromImage(const QImage &image, Qt::ImageConversionFlags flags = Qt::AutoColor); | |
34919 | static QBitmap fromData(const QSize &size, const uchar *bits, | |
34920 | QImage::Format monoFormat = QImage::Format_MonoLSB); | |
34921 | QBitmap transformed(const QMatrix &) const; | |
34922 | QBitmap transformed(const QTransform &matrix) const; | |
34923 | }; | |
34924 | template <> inline bool qIsDetached<QBitmap>(QBitmap &t) { return t.isDetached(); } template <typename T> inline void qSwap(T &, T &); template <> inline void qSwap<QBitmap>(QBitmap &value1, QBitmap &value2) { const QBitmap::DataPtr t = value1.data_ptr(); value1.data_ptr() = value2.data_ptr(); value2.data_ptr() = t; } | |
34925 | template <typename Type> class QDataBuffer | |
34926 | { | |
34927 | public: | |
34928 | QDataBuffer(int res = 64) | |
34929 | { | |
34930 | capacity = res; | |
34931 | buffer = (Type*) qMalloc(capacity * sizeof(Type)); | |
34932 | siz = 0; | |
34933 | } | |
34934 | ~QDataBuffer() | |
34935 | { | |
34936 | qFree(buffer); | |
34937 | } | |
34938 | inline void reset() { siz = 0; } | |
34939 | inline bool isEmpty() const { return siz==0; } | |
34940 | inline int size() const { return siz; } | |
34941 | inline Type *data() const { return buffer; } | |
34942 | inline Type &at(int i) { qt_noop(); return buffer[i]; } | |
34943 | inline const Type &at(int i) const { qt_noop(); return buffer[i]; } | |
34944 | inline const Type &last() const { qt_noop(); return buffer[siz-1]; } | |
34945 | inline const Type &first() const { qt_noop(); return buffer[0]; } | |
34946 | inline void add(const Type &t) { | |
34947 | reserve(siz + 1); | |
34948 | buffer[siz] = t; | |
34949 | ++siz; | |
34950 | } | |
34951 | inline void resize(int size) { | |
34952 | reserve(size); | |
34953 | siz = size; | |
34954 | } | |
34955 | inline void reserve(int size) { | |
34956 | if (size > capacity) { | |
34957 | while (capacity < size) | |
34958 | capacity *= 2; | |
34959 | buffer = (Type*) qRealloc(buffer, capacity * sizeof(Type)); | |
34960 | } | |
34961 | } | |
34962 | inline void shrink(int size) { | |
34963 | capacity = size; | |
34964 | buffer = (Type*) qRealloc(buffer, capacity * sizeof(Type)); | |
34965 | } | |
34966 | inline void swap(QDataBuffer<Type> &other) { | |
34967 | qSwap(capacity, other.capacity); | |
34968 | qSwap(siz, other.siz); | |
34969 | qSwap(buffer, other.buffer); | |
34970 | } | |
34971 | inline QDataBuffer &operator<<(const Type &t) { add(t); return *this; } | |
34972 | private: | |
34973 | int capacity; | |
34974 | int siz; | |
34975 | Type *buffer; | |
34976 | }; | |
34977 | static const union { unsigned char c[8]; double d; } qt_be_inf_bytes = { { 0x7f, 0xf0, 0, 0, 0, 0, 0, 0 } }; | |
34978 | static const union { unsigned char c[8]; double d; } qt_le_inf_bytes = { { 0, 0, 0, 0, 0, 0, 0xf0, 0x7f } }; | |
34979 | static const union { unsigned char c[8]; double d; } qt_armfpa_inf_bytes = { { 0, 0, 0xf0, 0x7f, 0, 0, 0, 0 } }; | |
34980 | static inline double qt_inf() | |
34981 | { | |
34982 | return (QSysInfo::ByteOrder == QSysInfo::BigEndian | |
34983 | ? qt_be_inf_bytes.d | |
34984 | : qt_le_inf_bytes.d); | |
34985 | } | |
34986 | static const union { unsigned char c[8]; double d; } qt_be_snan_bytes = { { 0x7f, 0xf8, 0, 0, 0, 0, 0, 0 } }; | |
34987 | static const union { unsigned char c[8]; double d; } qt_le_snan_bytes = { { 0, 0, 0, 0, 0, 0, 0xf8, 0x7f } }; | |
34988 | static const union { unsigned char c[8]; double d; } qt_armfpa_snan_bytes = { { 0, 0, 0xf8, 0x7f, 0, 0, 0, 0 } }; | |
34989 | static inline double qt_snan() | |
34990 | { | |
34991 | return (QSysInfo::ByteOrder == QSysInfo::BigEndian | |
34992 | ? qt_be_snan_bytes.d | |
34993 | : qt_le_snan_bytes.d); | |
34994 | } | |
34995 | static const union { unsigned char c[8]; double d; } qt_be_qnan_bytes = { { 0xff, 0xf8, 0, 0, 0, 0, 0, 0 } }; | |
34996 | static const union { unsigned char c[8]; double d; } qt_le_qnan_bytes = { { 0, 0, 0, 0, 0, 0, 0xf8, 0xff } }; | |
34997 | static const union { unsigned char c[8]; double d; } qt_armfpa_qnan_bytes = { { 0, 0, 0xf8, 0xff, 0, 0, 0, 0 } }; | |
34998 | static inline double qt_qnan() | |
34999 | { | |
35000 | return (QSysInfo::ByteOrder == QSysInfo::BigEndian | |
35001 | ? qt_be_qnan_bytes.d | |
35002 | : qt_le_qnan_bytes.d); | |
35003 | } | |
35004 | static inline bool qt_is_inf(double d) | |
35005 | { | |
35006 | uchar *ch = (uchar *)&d; | |
35007 | if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { | |
35008 | return (ch[0] & 0x7f) == 0x7f && ch[1] == 0xf0; | |
35009 | } else { | |
35010 | return (ch[7] & 0x7f) == 0x7f && ch[6] == 0xf0; | |
35011 | } | |
35012 | } | |
35013 | static inline bool qt_is_nan(double d) | |
35014 | { | |
35015 | uchar *ch = (uchar *)&d; | |
35016 | if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { | |
35017 | return (ch[0] & 0x7f) == 0x7f && ch[1] > 0xf0; | |
35018 | } else { | |
35019 | return (ch[7] & 0x7f) == 0x7f && ch[6] > 0xf0; | |
35020 | } | |
35021 | } | |
35022 | static inline bool qt_is_finite(double d) | |
35023 | { | |
35024 | uchar *ch = (uchar *)&d; | |
35025 | if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { | |
35026 | return (ch[0] & 0x7f) != 0x7f || (ch[1] & 0xf0) != 0xf0; | |
35027 | } else { | |
35028 | return (ch[7] & 0x7f) != 0x7f || (ch[6] & 0xf0) != 0xf0; | |
35029 | } | |
35030 | } | |
35031 | static inline bool qt_is_inf(float d) | |
35032 | { | |
35033 | uchar *ch = (uchar *)&d; | |
35034 | if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { | |
35035 | return (ch[0] & 0x7f) == 0x7f && ch[1] == 0x80; | |
35036 | } else { | |
35037 | return (ch[3] & 0x7f) == 0x7f && ch[2] == 0x80; | |
35038 | } | |
35039 | } | |
35040 | static inline bool qt_is_nan(float d) | |
35041 | { | |
35042 | uchar *ch = (uchar *)&d; | |
35043 | if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { | |
35044 | return (ch[0] & 0x7f) == 0x7f && ch[1] > 0x80; | |
35045 | } else { | |
35046 | return (ch[3] & 0x7f) == 0x7f && ch[2] > 0x80; | |
35047 | } | |
35048 | } | |
35049 | static inline bool qt_is_finite(float d) | |
35050 | { | |
35051 | uchar *ch = (uchar *)&d; | |
35052 | if (QSysInfo::ByteOrder == QSysInfo::BigEndian) { | |
35053 | return (ch[0] & 0x7f) != 0x7f || (ch[1] & 0x80) != 0x80; | |
35054 | } else { | |
35055 | return (ch[3] & 0x7f) != 0x7f || (ch[2] & 0x80) != 0x80; | |
35056 | } | |
35057 | } | |
35058 | typedef qreal qfixed; | |
35059 | struct qfixed2d | |
35060 | { | |
35061 | qfixed x; | |
35062 | qfixed y; | |
35063 | bool operator==(const qfixed2d &other) const { return qFuzzyCompare(x, other.x) | |
35064 | && qFuzzyCompare(y, other.y); } | |
35065 | }; | |
35066 | QPointF qt_curves_for_arc(const QRectF &rect, qreal startAngle, qreal sweepLength, | |
35067 | QPointF *controlPoints, int *point_count); | |
35068 | qreal qt_t_for_arc_angle(qreal angle); | |
35069 | typedef void (*qStrokerMoveToHook)(qfixed x, qfixed y, void *data); | |
35070 | typedef void (*qStrokerLineToHook)(qfixed x, qfixed y, void *data); | |
35071 | typedef void (*qStrokerCubicToHook)(qfixed c1x, qfixed c1y, | |
35072 | qfixed c2x, qfixed c2y, | |
35073 | qfixed ex, qfixed ey, | |
35074 | void *data); | |
35075 | class __attribute__((visibility("default"))) QStrokerOps | |
35076 | { | |
35077 | public: | |
35078 | struct Element { | |
35079 | QPainterPath::ElementType type; | |
35080 | qfixed x; | |
35081 | qfixed y; | |
35082 | inline bool isMoveTo() const { return type == QPainterPath::MoveToElement; } | |
35083 | inline bool isLineTo() const { return type == QPainterPath::LineToElement; } | |
35084 | inline bool isCurveTo() const { return type == QPainterPath::CurveToElement; } | |
35085 | operator qfixed2d () { qfixed2d pt = { x, y }; return pt; } | |
35086 | }; | |
35087 | QStrokerOps(); | |
35088 | virtual ~QStrokerOps(); | |
35089 | void setMoveToHook(qStrokerMoveToHook moveToHook) { m_moveTo = moveToHook; } | |
35090 | void setLineToHook(qStrokerLineToHook lineToHook) { m_lineTo = lineToHook; } | |
35091 | void setCubicToHook(qStrokerCubicToHook cubicToHook) { m_cubicTo = cubicToHook; } | |
35092 | virtual void begin(void *customData); | |
35093 | virtual void end(); | |
35094 | inline void moveTo(qfixed x, qfixed y); | |
35095 | inline void lineTo(qfixed x, qfixed y); | |
35096 | inline void cubicTo(qfixed x1, qfixed y1, qfixed x2, qfixed y2, qfixed ex, qfixed ey); | |
35097 | void strokePath(const QPainterPath &path, void *data, const QTransform &matrix); | |
35098 | void strokePolygon(const QPointF *points, int pointCount, bool implicit_close, | |
35099 | void *data, const QTransform &matrix); | |
35100 | void strokeEllipse(const QRectF &ellipse, void *data, const QTransform &matrix); | |
35101 | QRectF clipRect() const { return m_clip_rect; } | |
35102 | void setClipRect(const QRectF &clip) { m_clip_rect = clip; } | |
35103 | protected: | |
35104 | inline void emitMoveTo(qfixed x, qfixed y); | |
35105 | inline void emitLineTo(qfixed x, qfixed y); | |
35106 | inline void emitCubicTo(qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey); | |
35107 | virtual void processCurrentSubpath() = 0; | |
35108 | QDataBuffer<Element> m_elements; | |
35109 | QRectF m_clip_rect; | |
35110 | private: | |
35111 | void *m_customData; | |
35112 | qStrokerMoveToHook m_moveTo; | |
35113 | qStrokerLineToHook m_lineTo; | |
35114 | qStrokerCubicToHook m_cubicTo; | |
35115 | }; | |
35116 | class __attribute__((visibility("default"))) QStroker : public QStrokerOps | |
35117 | { | |
35118 | public: | |
35119 | enum LineJoinMode { | |
35120 | FlatJoin, | |
35121 | SquareJoin, | |
35122 | MiterJoin, | |
35123 | RoundJoin, | |
35124 | RoundCap, | |
35125 | SvgMiterJoin | |
35126 | }; | |
35127 | QStroker(); | |
35128 | ~QStroker(); | |
35129 | void setStrokeWidth(qfixed width) { m_strokeWidth = width; } | |
35130 | qfixed strokeWidth() const { return m_strokeWidth; } | |
35131 | void setCapStyle(Qt::PenCapStyle capStyle) { m_capStyle = joinModeForCap(capStyle); } | |
35132 | Qt::PenCapStyle capStyle() const { return capForJoinMode(m_capStyle); } | |
35133 | LineJoinMode capStyleMode() const { return m_capStyle; } | |
35134 | void setJoinStyle(Qt::PenJoinStyle style) { m_joinStyle = joinModeForJoin(style); } | |
35135 | Qt::PenJoinStyle joinStyle() const { return joinForJoinMode(m_joinStyle); } | |
35136 | LineJoinMode joinStyleMode() const { return m_joinStyle; } | |
35137 | void setMiterLimit(qfixed length) { m_miterLimit = length; } | |
35138 | qfixed miterLimit() const { return m_miterLimit; } | |
35139 | void setCurveThreshold(qfixed threshold) { m_curveThreshold = threshold; } | |
35140 | qfixed curveThreshold() const { return m_curveThreshold; } | |
35141 | void joinPoints(qfixed x, qfixed y, const QLineF &nextLine, LineJoinMode join); | |
35142 | inline void emitMoveTo(qfixed x, qfixed y); | |
35143 | inline void emitLineTo(qfixed x, qfixed y); | |
35144 | inline void emitCubicTo(qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey); | |
35145 | protected: | |
35146 | static Qt::PenCapStyle capForJoinMode(LineJoinMode mode); | |
35147 | static LineJoinMode joinModeForCap(Qt::PenCapStyle); | |
35148 | static Qt::PenJoinStyle joinForJoinMode(LineJoinMode mode); | |
35149 | static LineJoinMode joinModeForJoin(Qt::PenJoinStyle joinStyle); | |
35150 | virtual void processCurrentSubpath(); | |
35151 | qfixed m_strokeWidth; | |
35152 | qfixed m_miterLimit; | |
35153 | qfixed m_curveThreshold; | |
35154 | LineJoinMode m_capStyle; | |
35155 | LineJoinMode m_joinStyle; | |
35156 | qfixed m_back1X; | |
35157 | qfixed m_back1Y; | |
35158 | qfixed m_back2X; | |
35159 | qfixed m_back2Y; | |
35160 | }; | |
35161 | class __attribute__((visibility("default"))) QDashStroker : public QStrokerOps | |
35162 | { | |
35163 | public: | |
35164 | QDashStroker(QStroker *stroker); | |
35165 | QStroker *stroker() const { return m_stroker; } | |
35166 | static QVector<qfixed> patternForStyle(Qt::PenStyle style); | |
35167 | void setDashPattern(const QVector<qfixed> &dashPattern) { m_dashPattern = dashPattern; } | |
35168 | QVector<qfixed> dashPattern() const { return m_dashPattern; } | |
35169 | void setDashOffset(qreal offset) { m_dashOffset = offset; } | |
35170 | qreal dashOffset() const { return m_dashOffset; } | |
35171 | virtual void begin(void *data); | |
35172 | virtual void end(); | |
35173 | protected: | |
35174 | virtual void processCurrentSubpath(); | |
35175 | QStroker *m_stroker; | |
35176 | QVector<qfixed> m_dashPattern; | |
35177 | qreal m_dashOffset; | |
35178 | }; | |
35179 | inline void QStrokerOps::emitMoveTo(qfixed x, qfixed y) | |
35180 | { | |
35181 | qt_noop(); | |
35182 | m_moveTo(x, y, m_customData); | |
35183 | } | |
35184 | inline void QStrokerOps::emitLineTo(qfixed x, qfixed y) | |
35185 | { | |
35186 | qt_noop(); | |
35187 | m_lineTo(x, y, m_customData); | |
35188 | } | |
35189 | inline void QStrokerOps::emitCubicTo(qfixed c1x, qfixed c1y, qfixed c2x, qfixed c2y, qfixed ex, qfixed ey) | |
35190 | { | |
35191 | qt_noop(); | |
35192 | m_cubicTo(c1x, c1y, c2x, c2y, ex, ey, m_customData); | |
35193 | } | |
35194 | inline void QStrokerOps::moveTo(qfixed x, qfixed y) | |
35195 | { | |
35196 | if (m_elements.size()>1) | |
35197 | processCurrentSubpath(); | |
35198 | m_elements.reset(); | |
35199 | Element e = { QPainterPath::MoveToElement, x, y }; | |
35200 | m_elements.add(e); | |
35201 | } | |
35202 | inline void QStrokerOps::lineTo(qfixed x, qfixed y) | |
35203 | { | |
35204 | Element e = { QPainterPath::LineToElement, x, y }; | |
35205 | m_elements.add(e); | |
35206 | } | |
35207 | inline void QStrokerOps::cubicTo(qfixed x1, qfixed y1, qfixed x2, qfixed y2, qfixed ex, qfixed ey) | |
35208 | { | |
35209 | Element c1 = { QPainterPath::CurveToElement, x1, y1 }; | |
35210 | Element c2 = { QPainterPath::CurveToDataElement, x2, y2 }; | |
35211 | Element e = { QPainterPath::CurveToDataElement, ex, ey }; | |
35212 | m_elements.add(c1); | |
35213 | m_elements.add(c2); | |
35214 | m_elements.add(e); | |
35215 | } | |
35216 | inline void QStroker::emitMoveTo(qfixed x, qfixed y) | |
35217 | { | |
35218 | m_back2X = m_back1X; | |
35219 | m_back2Y = m_back1Y; | |
35220 | m_back1X = x; | |
35221 | m_back1Y = y; | |
35222 | QStrokerOps::emitMoveTo(x, y); | |
35223 | } | |
35224 | inline void QStroker::emitLineTo(qfixed x, qfixed y) | |
35225 | { | |
35226 | m_back2X = m_back1X; | |
35227 | m_back2Y = m_back1Y; | |
35228 | m_back1X = x; | |
35229 | m_back1Y = y; | |
35230 | QStrokerOps::emitLineTo(x, y); | |
35231 | } | |
35232 | inline void QStroker::emitCubicTo(qfixed c1x, qfixed c1y, | |
35233 | qfixed c2x, qfixed c2y, | |
35234 | qfixed ex, qfixed ey) | |
35235 | { | |
35236 | if (c2x == ex && c2y == ey) { | |
35237 | if (c1x == ex && c1y == ey) { | |
35238 | m_back2X = m_back1X; | |
35239 | m_back2Y = m_back1Y; | |
35240 | } else { | |
35241 | m_back2X = c1x; | |
35242 | m_back2Y = c1y; | |
35243 | } | |
35244 | } else { | |
35245 | m_back2X = c2x; | |
35246 | m_back2Y = c2y; | |
35247 | } | |
35248 | m_back1X = ex; | |
35249 | m_back1Y = ey; | |
35250 | QStrokerOps::emitCubicTo(c1x, c1y, c2x, c2y, ex, ey); | |
35251 | } | |
35252 | inline void QDashStroker::begin(void *data) | |
35253 | { | |
35254 | qt_noop(); | |
35255 | m_stroker->begin(data); | |
35256 | QStrokerOps::begin(data); | |
35257 | } | |
35258 | inline void QDashStroker::end() | |
35259 | { | |
35260 | qt_noop(); | |
35261 | QStrokerOps::end(); | |
35262 | m_stroker->end(); | |
35263 | } | |
35264 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
35265 | class QPrinterPrivate; | |
35266 | class QPaintEngine; | |
35267 | class QPrintEngine; | |
35268 | class QPrinterInfo; | |
35269 | class __attribute__((visibility("default"))) QPrinter : public QPaintDevice | |
35270 | { | |
35271 | inline QPrinterPrivate* d_func() { return reinterpret_cast<QPrinterPrivate *>(d_ptr); } inline const QPrinterPrivate* d_func() const { return reinterpret_cast<const QPrinterPrivate *>(d_ptr); } friend class QPrinterPrivate; | |
35272 | public: | |
35273 | enum PrinterMode { ScreenResolution, PrinterResolution, HighResolution }; | |
35274 | explicit QPrinter(PrinterMode mode = ScreenResolution); | |
35275 | explicit QPrinter(const QPrinterInfo& printer, PrinterMode mode = ScreenResolution); | |
35276 | ~QPrinter(); | |
35277 | int devType() const; | |
35278 | enum Orientation { Portrait, Landscape }; | |
35279 | enum PageSize { A4, B5, Letter, Legal, Executive, | |
35280 | A0, A1, A2, A3, A5, A6, A7, A8, A9, B0, B1, | |
35281 | B10, B2, B3, B4, B6, B7, B8, B9, C5E, Comm10E, | |
35282 | DLE, Folio, Ledger, Tabloid, Custom, NPageSize = Custom, NPaperSize = Custom }; | |
35283 | typedef PageSize PaperSize; | |
35284 | enum PageOrder { FirstPageFirst, | |
35285 | LastPageFirst }; | |
35286 | enum ColorMode { GrayScale, | |
35287 | Color }; | |
35288 | enum PaperSource { OnlyOne, | |
35289 | Lower, | |
35290 | Middle, | |
35291 | Manual, | |
35292 | Envelope, | |
35293 | EnvelopeManual, | |
35294 | Auto, | |
35295 | Tractor, | |
35296 | SmallFormat, | |
35297 | LargeFormat, | |
35298 | LargeCapacity, | |
35299 | Cassette, | |
35300 | FormSource, | |
35301 | MaxPageSource | |
35302 | }; | |
35303 | enum PrinterState { Idle, | |
35304 | Active, | |
35305 | Aborted, | |
35306 | Error }; | |
35307 | enum OutputFormat { NativeFormat, PdfFormat, PostScriptFormat }; | |
35308 | enum PrintRange { AllPages, Selection, PageRange }; | |
35309 | enum Unit { | |
35310 | Millimeter, | |
35311 | Point, | |
35312 | Inch, | |
35313 | Pica, | |
35314 | Didot, | |
35315 | Cicero, | |
35316 | DevicePixel | |
35317 | }; | |
35318 | enum DuplexMode { | |
35319 | DuplexNone = 0, | |
35320 | DuplexAuto, | |
35321 | DuplexLongSide, | |
35322 | DuplexShortSide | |
35323 | }; | |
35324 | void setOutputFormat(OutputFormat format); | |
35325 | OutputFormat outputFormat() const; | |
35326 | void setPrinterName(const QString &); | |
35327 | QString printerName() const; | |
35328 | bool isValid() const; | |
35329 | void setOutputFileName(const QString &); | |
35330 | QString outputFileName()const; | |
35331 | void setPrintProgram(const QString &); | |
35332 | QString printProgram() const; | |
35333 | void setDocName(const QString &); | |
35334 | QString docName() const; | |
35335 | void setCreator(const QString &); | |
35336 | QString creator() const; | |
35337 | void setOrientation(Orientation); | |
35338 | Orientation orientation() const; | |
35339 | void setPageSize(PageSize); | |
35340 | PageSize pageSize() const; | |
35341 | void setPaperSize(PaperSize); | |
35342 | PaperSize paperSize() const; | |
35343 | void setPaperSize(const QSizeF &paperSize, Unit unit); | |
35344 | QSizeF paperSize(Unit unit) const; | |
35345 | void setPageOrder(PageOrder); | |
35346 | PageOrder pageOrder() const; | |
35347 | void setResolution(int); | |
35348 | int resolution() const; | |
35349 | void setColorMode(ColorMode); | |
35350 | ColorMode colorMode() const; | |
35351 | void setCollateCopies(bool collate); | |
35352 | bool collateCopies() const; | |
35353 | void setFullPage(bool); | |
35354 | bool fullPage() const; | |
35355 | void setNumCopies(int); | |
35356 | int numCopies() const; | |
35357 | void setPaperSource(PaperSource); | |
35358 | PaperSource paperSource() const; | |
35359 | void setDuplex(DuplexMode duplex); | |
35360 | DuplexMode duplex() const; | |
35361 | QList<int> supportedResolutions() const; | |
35362 | void setFontEmbeddingEnabled(bool enable); | |
35363 | bool fontEmbeddingEnabled() const; | |
35364 | void setDoubleSidedPrinting(bool enable); | |
35365 | bool doubleSidedPrinting() const; | |
35366 | QRect paperRect() const; | |
35367 | QRect pageRect() const; | |
35368 | QRectF paperRect(Unit) const; | |
35369 | QRectF pageRect(Unit) const; | |
35370 | QString printerSelectionOption() const; | |
35371 | void setPrinterSelectionOption(const QString &); | |
35372 | bool newPage(); | |
35373 | bool abort(); | |
35374 | PrinterState printerState() const; | |
35375 | QPaintEngine *paintEngine() const; | |
35376 | QPrintEngine *printEngine() const; | |
35377 | void setFromTo(int fromPage, int toPage); | |
35378 | int fromPage() const; | |
35379 | int toPage() const; | |
35380 | void setPrintRange(PrintRange range); | |
35381 | PrintRange printRange() const; | |
35382 | void setPageMargins(qreal left, qreal top, qreal right, qreal bottom, Unit unit); | |
35383 | void getPageMargins(qreal *left, qreal *top, qreal *right, qreal *bottom, Unit unit) const; | |
35384 | protected: | |
35385 | int metric(PaintDeviceMetric) const; | |
35386 | void setEngines(QPrintEngine *printEngine, QPaintEngine *paintEngine); | |
35387 | private: | |
35388 | void init(PrinterMode mode); | |
35389 | QPrinter(const QPrinter &); QPrinter &operator=(const QPrinter &); | |
35390 | QPrinterPrivate *d_ptr; | |
35391 | friend class QPrintDialogPrivate; | |
35392 | friend class QAbstractPrintDialog; | |
35393 | friend class QAbstractPrintDialogPrivate; | |
35394 | friend class QPrintPreviewWidgetPrivate; | |
35395 | friend class QTextDocument; | |
35396 | friend class QPageSetupWidget; | |
35397 | }; | |
35398 | class QFontSubset | |
35399 | { | |
35400 | public: | |
35401 | QFontSubset(QFontEngine *fe, int obj_id = 0) | |
35402 | : object_id(obj_id), noEmbed(false), fontEngine(fe), downloaded_glyphs(0), standard_font(false) | |
35403 | { fontEngine->ref.ref(); addGlyph(0); } | |
35404 | ~QFontSubset() { | |
35405 | if (!fontEngine->ref.deref()) | |
35406 | delete fontEngine; | |
35407 | } | |
35408 | QByteArray toTruetype() const; | |
35409 | QByteArray toType1() const; | |
35410 | QByteArray type1AddedGlyphs() const; | |
35411 | QByteArray widthArray() const; | |
35412 | QByteArray createToUnicodeMap() const; | |
35413 | QVector<int> getReverseMap() const; | |
35414 | QByteArray glyphName(unsigned int glyph, const QVector<int> reverseMap) const; | |
35415 | static QByteArray glyphName(unsigned short unicode, bool symbol); | |
35416 | int addGlyph(int index); | |
35417 | const int object_id; | |
35418 | bool noEmbed; | |
35419 | QFontEngine *fontEngine; | |
35420 | QList<int> glyph_indices; | |
35421 | mutable int downloaded_glyphs; | |
35422 | mutable bool standard_font; | |
35423 | int nGlyphs() const { return glyph_indices.size(); } | |
35424 | mutable QFixed emSquare; | |
35425 | mutable QVector<QFixed> widths; | |
35426 | }; | |
35427 | class QPaintDevice; | |
35428 | class QPaintEnginePrivate | |
35429 | { | |
35430 | inline QPaintEngine* q_func() { return static_cast<QPaintEngine *>(q_ptr); } inline const QPaintEngine* q_func() const { return static_cast<const QPaintEngine *>(q_ptr); } friend class QPaintEngine; | |
35431 | public: | |
35432 | QPaintEnginePrivate() : pdev(0), q_ptr(0), currentClipWidget(0), hasSystemTransform(0), | |
35433 | hasSystemViewport(0) {} | |
35434 | virtual ~QPaintEnginePrivate() { } | |
35435 | QPaintDevice *pdev; | |
35436 | QPaintEngine *q_ptr; | |
35437 | QRegion systemClip; | |
35438 | QRegion systemViewport; | |
35439 | QTransform systemTransform; | |
35440 | QWidget *currentClipWidget; | |
35441 | uint hasSystemTransform : 1; | |
35442 | uint hasSystemViewport : 1; | |
35443 | inline void transformSystemClip() | |
35444 | { | |
35445 | if (systemClip.isEmpty()) | |
35446 | return; | |
35447 | if (systemTransform.type() <= QTransform::TxTranslate) | |
35448 | systemClip.translate(qRound(systemTransform.dx()), qRound(systemTransform.dy())); | |
35449 | else | |
35450 | systemClip = systemTransform.map(systemClip); | |
35451 | if (hasSystemViewport) { | |
35452 | systemClip &= systemViewport; | |
35453 | if (systemClip.isEmpty()) { | |
35454 | systemClip = QRect(systemViewport.boundingRect().topLeft(), QSize(1, 1)); | |
35455 | } | |
35456 | } | |
35457 | } | |
35458 | inline void setSystemTransform(const QTransform &xform) | |
35459 | { | |
35460 | systemTransform = xform; | |
35461 | if ((hasSystemTransform = !xform.isIdentity())) | |
35462 | transformSystemClip(); | |
35463 | systemStateChanged(); | |
35464 | } | |
35465 | inline void setSystemViewport(const QRegion ®ion) | |
35466 | { | |
35467 | systemViewport = region; | |
35468 | hasSystemViewport = !systemViewport.isEmpty(); | |
35469 | } | |
35470 | virtual void systemStateChanged() { } | |
35471 | void drawBoxTextItem(const QPointF &p, const QTextItemInt &ti); | |
35472 | private: | |
35473 | QRect systemRect; | |
35474 | }; | |
35475 | class QAlphaPaintEnginePrivate; | |
35476 | class QAlphaPaintEngine : public QPaintEngine | |
35477 | { | |
35478 | inline QAlphaPaintEnginePrivate* d_func() { return reinterpret_cast<QAlphaPaintEnginePrivate *>(d_ptr); } inline const QAlphaPaintEnginePrivate* d_func() const { return reinterpret_cast<const QAlphaPaintEnginePrivate *>(d_ptr); } friend class QAlphaPaintEnginePrivate; | |
35479 | public: | |
35480 | ~QAlphaPaintEngine(); | |
35481 | virtual bool begin(QPaintDevice *pdev); | |
35482 | virtual bool end(); | |
35483 | virtual void updateState(const QPaintEngineState &state); | |
35484 | virtual void drawPath(const QPainterPath &path); | |
35485 | virtual void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode); | |
35486 | virtual void drawPixmap(const QRectF &r, const QPixmap &pm, const QRectF &sr); | |
35487 | virtual void drawImage(const QRectF &r, const QImage &image, const QRectF &sr); | |
35488 | virtual void drawTextItem(const QPointF &p, const QTextItem &textItem); | |
35489 | virtual void drawTiledPixmap(const QRectF &r, const QPixmap &pixmap, const QPointF &s); | |
35490 | protected: | |
35491 | QAlphaPaintEngine(QAlphaPaintEnginePrivate &data, PaintEngineFeatures devcaps = 0); | |
35492 | QRegion alphaClipping() const; | |
35493 | bool continueCall() const; | |
35494 | void flushAndInit(bool init = true); | |
35495 | void cleanUp(); | |
35496 | }; | |
35497 | class QAlphaPaintEnginePrivate : public QPaintEnginePrivate | |
35498 | { | |
35499 | inline QAlphaPaintEngine* q_func() { return static_cast<QAlphaPaintEngine *>(q_ptr); } inline const QAlphaPaintEngine* q_func() const { return static_cast<const QAlphaPaintEngine *>(q_ptr); } friend class QAlphaPaintEngine; | |
35500 | public: | |
35501 | QAlphaPaintEnginePrivate(); | |
35502 | ~QAlphaPaintEnginePrivate(); | |
35503 | int m_pass; | |
35504 | QPicture *m_pic; | |
35505 | QPaintEngine *m_picengine; | |
35506 | QPainter *m_picpainter; | |
35507 | QPaintEngine::PaintEngineFeatures m_savedcaps; | |
35508 | QPaintDevice *m_pdev; | |
35509 | QRegion m_alphargn; | |
35510 | QRegion m_cliprgn; | |
35511 | bool m_hasalpha; | |
35512 | bool m_alphaPen; | |
35513 | bool m_alphaBrush; | |
35514 | bool m_alphaOpacity; | |
35515 | bool m_advancedPen; | |
35516 | bool m_advancedBrush; | |
35517 | bool m_complexTransform; | |
35518 | bool m_emulateProjectiveTransforms; | |
35519 | bool m_continueCall; | |
35520 | QTransform m_transform; | |
35521 | QPen m_pen; | |
35522 | void addAlphaRect(const QRectF &rect); | |
35523 | QRectF addPenWidth(const QPainterPath &path); | |
35524 | void drawAlphaImage(const QRectF &rect); | |
35525 | QRect toRect(const QRectF &rect) const; | |
35526 | bool fullyContained(const QRectF &rect) const; | |
35527 | void resetState(QPainter *p); | |
35528 | }; | |
35529 | typedef QtValidLicenseForGuiModule QtGuiModule; | |
35530 | class __attribute__((visibility("default"))) QPrintEngine | |
35531 | { | |
35532 | public: | |
35533 | virtual ~QPrintEngine() {} | |
35534 | enum PrintEnginePropertyKey { | |
35535 | PPK_CollateCopies, | |
35536 | PPK_ColorMode, | |
35537 | PPK_Creator, | |
35538 | PPK_DocumentName, | |
35539 | PPK_FullPage, | |
35540 | PPK_NumberOfCopies, | |
35541 | PPK_Orientation, | |
35542 | PPK_OutputFileName, | |
35543 | PPK_PageOrder, | |
35544 | PPK_PageRect, | |
35545 | PPK_PageSize, | |
35546 | PPK_PaperRect, | |
35547 | PPK_PaperSource, | |
35548 | PPK_PrinterName, | |
35549 | PPK_PrinterProgram, | |
35550 | PPK_Resolution, | |
35551 | PPK_SelectionOption, | |
35552 | PPK_SupportedResolutions, | |
35553 | PPK_WindowsPageSize, | |
35554 | PPK_FontEmbedding, | |
35555 | PPK_SuppressSystemPrintStatus, | |
35556 | PPK_Duplex, | |
35557 | PPK_PaperSources, | |
35558 | PPK_CustomPaperSize, | |
35559 | PPK_PageMargins, | |
35560 | PPK_PaperSize = PPK_PageSize, | |
35561 | PPK_CustomBase = 0xff00 | |
35562 | }; | |
35563 | virtual void setProperty(PrintEnginePropertyKey key, const QVariant &value) = 0; | |
35564 | virtual QVariant property(PrintEnginePropertyKey key) const = 0; | |
35565 | virtual bool newPage() = 0; | |
35566 | virtual bool abort() = 0; | |
35567 | virtual int metric(QPaintDevice::PaintDeviceMetric) const = 0; | |
35568 | virtual QPrinter::PrinterState printerState() const = 0; | |
35569 | }; | |
35570 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
35571 | class QObject; | |
35572 | class QBufferPrivate; | |
35573 | class __attribute__((visibility("default"))) QBuffer : public QIODevice | |
35574 | { | |
35575 | public: template <typename T> inline void qt_check_for_QOBJECT_macro(const T &_q_argument) const { int i = qYouForgotTheQ_OBJECT_Macro(this, &_q_argument); i = i; } static const QMetaObject staticMetaObject; virtual const QMetaObject *metaObject() const; virtual void *qt_metacast(const char *); static inline QString tr(const char *s, const char *c = 0) { return staticMetaObject.tr(s, c); } static inline QString trUtf8(const char *s, const char *c = 0) { return staticMetaObject.trUtf8(s, c); } static inline QString tr(const char *s, const char *c, int n) { return staticMetaObject.tr(s, c, n); } static inline QString trUtf8(const char *s, const char *c, int n) { return staticMetaObject.trUtf8(s, c, n); } virtual int qt_metacall(QMetaObject::Call, int, void **); private: | |
35576 | public: | |
35577 | explicit QBuffer(QObject *parent = 0); | |
35578 | QBuffer(QByteArray *buf, QObject *parent = 0); | |
35579 | ~QBuffer(); | |
35580 | QByteArray &buffer(); | |
35581 | const QByteArray &buffer() const; | |
35582 | void setBuffer(QByteArray *a); | |
35583 | void setData(const QByteArray &data); | |
35584 | inline void setData(const char *data, int len); | |
35585 | const QByteArray &data() const; | |
35586 | bool open(OpenMode openMode); | |
35587 | void close(); | |
35588 | qint64 size() const; | |
35589 | qint64 pos() const; | |
35590 | bool seek(qint64 off); | |
35591 | bool atEnd() const; | |
35592 | bool canReadLine() const; | |
35593 | protected: | |
35594 | void connectNotify(const char*); | |
35595 | void disconnectNotify(const char*); | |
35596 | qint64 readData(char *data, qint64 maxlen); | |
35597 | qint64 writeData(const char *data, qint64 len); | |
35598 | private: | |
35599 | inline QBufferPrivate* d_func() { return reinterpret_cast<QBufferPrivate *>(d_ptr); } inline const QBufferPrivate* d_func() const { return reinterpret_cast<const QBufferPrivate *>(d_ptr); } friend class QBufferPrivate; | |
35600 | QBuffer(const QBuffer &); QBuffer &operator=(const QBuffer &); | |
35601 | }; | |
35602 | inline void QBuffer::setData(const char *adata, int alen) | |
35603 | { setData(QByteArray(adata, alen)); } | |
35604 | const char *qt_real_to_string(qreal val, char *buf); | |
35605 | const char *qt_int_to_string(int val, char *buf); | |
35606 | namespace QPdf { | |
35607 | class ByteStream | |
35608 | { | |
35609 | public: | |
35610 | explicit ByteStream(bool fileBacking = false); | |
35611 | explicit ByteStream(QByteArray *ba, bool fileBacking = false); | |
35612 | ~ByteStream(); | |
35613 | ByteStream &operator <<(char chr); | |
35614 | ByteStream &operator <<(const char *str); | |
35615 | ByteStream &operator <<(const QByteArray &str); | |
35616 | ByteStream &operator <<(const ByteStream &src); | |
35617 | ByteStream &operator <<(qreal val); | |
35618 | ByteStream &operator <<(int val); | |
35619 | ByteStream &operator <<(const QPointF &p); | |
35620 | QIODevice *stream(); | |
35621 | void clear(); | |
35622 | static inline int maxMemorySize() { return 100000000; } | |
35623 | static inline int chunkSize() { return 10000000; } | |
35624 | protected: | |
35625 | void constructor_helper(QIODevice *dev); | |
35626 | void constructor_helper(QByteArray *ba); | |
35627 | private: | |
35628 | void prepareBuffer(); | |
35629 | private: | |
35630 | QIODevice *dev; | |
35631 | QByteArray ba; | |
35632 | bool fileBackingEnabled; | |
35633 | bool fileBackingActive; | |
35634 | bool handleDirty; | |
35635 | }; | |
35636 | enum PathFlags { | |
35637 | ClipPath, | |
35638 | FillPath, | |
35639 | StrokePath, | |
35640 | FillAndStrokePath | |
35641 | }; | |
35642 | QByteArray generatePath(const QPainterPath &path, const QTransform &matrix, PathFlags flags); | |
35643 | QByteArray generateMatrix(const QTransform &matrix); | |
35644 | QByteArray generateDashes(const QPen &pen); | |
35645 | QByteArray patternForBrush(const QBrush &b); | |
35646 | struct Stroker { | |
35647 | Stroker(); | |
35648 | void setPen(const QPen &pen); | |
35649 | void strokePath(const QPainterPath &path); | |
35650 | ByteStream *stream; | |
35651 | bool first; | |
35652 | QTransform matrix; | |
35653 | bool cosmeticPen; | |
35654 | private: | |
35655 | QStroker basicStroker; | |
35656 | QDashStroker dashStroker; | |
35657 | QStrokerOps *stroker; | |
35658 | }; | |
35659 | QByteArray ascii85Encode(const QByteArray &input); | |
35660 | const char *toHex(ushort u, char *buffer); | |
35661 | const char *toHex(uchar u, char *buffer); | |
35662 | struct PaperSize { | |
35663 | int width, height; | |
35664 | }; | |
35665 | PaperSize paperSize(QPrinter::PaperSize paperSize); | |
35666 | const char *paperSizeToString(QPrinter::PaperSize paperSize); | |
35667 | QByteArray stripSpecialCharacters(const QByteArray &string); | |
35668 | }; | |
35669 | class QPdfPage : public QPdf::ByteStream | |
35670 | { | |
35671 | public: | |
35672 | QPdfPage(); | |
35673 | QVector<uint> images; | |
35674 | QVector<uint> graphicStates; | |
35675 | QVector<uint> patterns; | |
35676 | QVector<uint> fonts; | |
35677 | QVector<uint> annotations; | |
35678 | void streamImage(int w, int h, int object); | |
35679 | QSize pageSize; | |
35680 | private: | |
35681 | }; | |
35682 | class QPdfBaseEnginePrivate; | |
35683 | class QPdfBaseEngine : public QAlphaPaintEngine, public QPrintEngine | |
35684 | { | |
35685 | inline QPdfBaseEnginePrivate* d_func() { return reinterpret_cast<QPdfBaseEnginePrivate *>(d_ptr); } inline const QPdfBaseEnginePrivate* d_func() const { return reinterpret_cast<const QPdfBaseEnginePrivate *>(d_ptr); } friend class QPdfBaseEnginePrivate; | |
35686 | public: | |
35687 | QPdfBaseEngine(QPdfBaseEnginePrivate &d, PaintEngineFeatures f); | |
35688 | ~QPdfBaseEngine() {} | |
35689 | bool begin(QPaintDevice *pdev); | |
35690 | bool end(); | |
35691 | void drawPoints(const QPointF *points, int pointCount); | |
35692 | void drawLines(const QLineF *lines, int lineCount); | |
35693 | void drawRects(const QRectF *rects, int rectCount); | |
35694 | void drawPolygon(const QPointF *points, int pointCount, PolygonDrawMode mode); | |
35695 | void drawPath (const QPainterPath & path); | |
35696 | void drawTextItem(const QPointF &p, const QTextItem &textItem); | |
35697 | void updateState(const QPaintEngineState &state); | |
35698 | int metric(QPaintDevice::PaintDeviceMetric metricType) const; | |
35699 | bool newPage(); | |
35700 | void setProperty(PrintEnginePropertyKey key, const QVariant &value); | |
35701 | QVariant property(PrintEnginePropertyKey key) const; | |
35702 | void setPen(); | |
35703 | virtual void setBrush() = 0; | |
35704 | void setupGraphicsState(QPaintEngine::DirtyFlags flags); | |
35705 | private: | |
35706 | void updateClipPath(const QPainterPath & path, Qt::ClipOperation op); | |
35707 | friend int qt_printerRealNumCopies(QPaintEngine *); | |
35708 | }; | |
35709 | class QPdfBaseEnginePrivate : public QAlphaPaintEnginePrivate | |
35710 | { | |
35711 | inline QPdfBaseEngine* q_func() { return static_cast<QPdfBaseEngine *>(q_ptr); } inline const QPdfBaseEngine* q_func() const { return static_cast<const QPdfBaseEngine *>(q_ptr); } friend class QPdfBaseEngine; | |
35712 | public: | |
35713 | QPdfBaseEnginePrivate(QPrinter::PrinterMode m); | |
35714 | ~QPdfBaseEnginePrivate(); | |
35715 | bool openPrintDevice(); | |
35716 | void closePrintDevice(); | |
35717 | virtual void drawTextItem(const QPointF &p, const QTextItemInt &ti); | |
35718 | inline uint requestObject() { return currentObject++; } | |
35719 | QRect paperRect() const; | |
35720 | QRect pageRect() const; | |
35721 | bool postscript; | |
35722 | int currentObject; | |
35723 | QPdfPage* currentPage; | |
35724 | QPdf::Stroker stroker; | |
35725 | QPointF brushOrigin; | |
35726 | QBrush brush; | |
35727 | QPen pen; | |
35728 | QList<QPainterPath> clips; | |
35729 | bool clipEnabled; | |
35730 | bool allClipped; | |
35731 | bool hasPen; | |
35732 | bool hasBrush; | |
35733 | bool simplePen; | |
35734 | qreal opacity; | |
35735 | bool useAlphaEngine; | |
35736 | QHash<QFontEngine::FaceId, QFontSubset *> fonts; | |
35737 | QPaintDevice *pdev; | |
35738 | QIODevice *outDevice; | |
35739 | int fd; | |
35740 | QString outputFileName; | |
35741 | QString printerName; | |
35742 | QString printProgram; | |
35743 | QString selectionOption; | |
35744 | QString title; | |
35745 | QString creator; | |
35746 | QPrinter::DuplexMode duplex; | |
35747 | bool collate; | |
35748 | bool fullPage; | |
35749 | bool embedFonts; | |
35750 | int copies; | |
35751 | int resolution; | |
35752 | QPrinter::PageOrder pageOrder; | |
35753 | QPrinter::Orientation orientation; | |
35754 | QPrinter::PaperSize paperSize; | |
35755 | QPrinter::ColorMode colorMode; | |
35756 | QPrinter::PaperSource paperSource; | |
35757 | QStringList cupsOptions; | |
35758 | QRect cupsPaperRect; | |
35759 | QRect cupsPageRect; | |
35760 | QString cupsStringPageSize; | |
35761 | QSizeF customPaperSize; | |
35762 | bool hasCustomPageMargins; | |
35763 | qreal leftMargin, topMargin, rightMargin, bottomMargin; | |
35764 | }; | |
35765 | extern "C" { | |
35766 | typedef double float_t; | |
35767 | typedef double double_t; | |
35768 | extern double acos (double __x) throw (); extern double __acos (double __x) throw (); | |
35769 | extern double asin (double __x) throw (); extern double __asin (double __x) throw (); | |
35770 | extern double atan (double __x) throw (); extern double __atan (double __x) throw (); | |
35771 | extern double atan2 (double __y, double __x) throw (); extern double __atan2 (double __y, double __x) throw (); | |
35772 | extern double cos (double __x) throw (); extern double __cos (double __x) throw (); | |
35773 | extern double sin (double __x) throw (); extern double __sin (double __x) throw (); | |
35774 | extern double tan (double __x) throw (); extern double __tan (double __x) throw (); | |
35775 | extern double cosh (double __x) throw (); extern double __cosh (double __x) throw (); | |
35776 | extern double sinh (double __x) throw (); extern double __sinh (double __x) throw (); | |
35777 | extern double tanh (double __x) throw (); extern double __tanh (double __x) throw (); | |
35778 | extern double acosh (double __x) throw (); extern double __acosh (double __x) throw (); | |
35779 | extern double asinh (double __x) throw (); extern double __asinh (double __x) throw (); | |
35780 | extern double atanh (double __x) throw (); extern double __atanh (double __x) throw (); | |
35781 | extern double exp (double __x) throw (); extern double __exp (double __x) throw (); | |
35782 | extern double frexp (double __x, int *__exponent) throw (); extern double __frexp (double __x, int *__exponent) throw (); | |
35783 | extern double ldexp (double __x, int __exponent) throw (); extern double __ldexp (double __x, int __exponent) throw (); | |
35784 | extern double log (double __x) throw (); extern double __log (double __x) throw (); | |
35785 | extern double log10 (double __x) throw (); extern double __log10 (double __x) throw (); | |
35786 | extern double modf (double __x, double *__iptr) throw (); extern double __modf (double __x, double *__iptr) throw (); | |
35787 | extern double expm1 (double __x) throw (); extern double __expm1 (double __x) throw (); | |
35788 | extern double log1p (double __x) throw (); extern double __log1p (double __x) throw (); | |
35789 | extern double logb (double __x) throw (); extern double __logb (double __x) throw (); | |
35790 | extern double exp2 (double __x) throw (); extern double __exp2 (double __x) throw (); | |
35791 | extern double log2 (double __x) throw (); extern double __log2 (double __x) throw (); | |
35792 | extern double pow (double __x, double __y) throw (); extern double __pow (double __x, double __y) throw (); | |
35793 | extern double sqrt (double __x) throw (); extern double __sqrt (double __x) throw (); | |
35794 | extern double hypot (double __x, double __y) throw (); extern double __hypot (double __x, double __y) throw (); | |
35795 | extern double cbrt (double __x) throw (); extern double __cbrt (double __x) throw (); | |
35796 | extern double ceil (double __x) throw () __attribute__ ((__const__)); extern double __ceil (double __x) throw () __attribute__ ((__const__)); | |
35797 | extern double fabs (double __x) throw () __attribute__ ((__const__)); extern double __fabs (double __x) throw () __attribute__ ((__const__)); | |
35798 | extern double floor (double __x) throw () __attribute__ ((__const__)); extern double __floor (double __x) throw () __attribute__ ((__const__)); | |
35799 | extern double fmod (double __x, double __y) throw (); extern double __fmod (double __x, double __y) throw (); | |
35800 | extern int __isinf (double __value) throw () __attribute__ ((__const__)); | |
35801 | extern int __finite (double __value) throw () __attribute__ ((__const__)); | |
35802 | extern int isinf (double __value) throw () __attribute__ ((__const__)); | |
35803 | extern int finite (double __value) throw () __attribute__ ((__const__)); | |
35804 | extern double drem (double __x, double __y) throw (); extern double __drem (double __x, double __y) throw (); | |
35805 | extern double significand (double __x) throw (); extern double __significand (double __x) throw (); | |
35806 | extern double copysign (double __x, double __y) throw () __attribute__ ((__const__)); extern double __copysign (double __x, double __y) throw () __attribute__ ((__const__)); | |
35807 | extern double nan (__const char *__tagb) throw () __attribute__ ((__const__)); extern double __nan (__const char *__tagb) throw () __attribute__ ((__const__)); | |
35808 | extern int __isnan (double __value) throw () __attribute__ ((__const__)); | |
35809 | extern int isnan (double __value) throw () __attribute__ ((__const__)); | |
35810 | extern double j0 (double) throw (); extern double __j0 (double) throw (); | |
35811 | extern double j1 (double) throw (); extern double __j1 (double) throw (); | |
35812 | extern double jn (int, double) throw (); extern double __jn (int, double) throw (); | |
35813 | extern double y0 (double) throw (); extern double __y0 (double) throw (); | |
35814 | extern double y1 (double) throw (); extern double __y1 (double) throw (); | |
35815 | extern double yn (int, double) throw (); extern double __yn (int, double) throw (); | |
35816 | extern double erf (double) throw (); extern double __erf (double) throw (); | |
35817 | extern double erfc (double) throw (); extern double __erfc (double) throw (); | |
35818 | extern double lgamma (double) throw (); extern double __lgamma (double) throw (); | |
35819 | extern double tgamma (double) throw (); extern double __tgamma (double) throw (); | |
35820 | extern double gamma (double) throw (); extern double __gamma (double) throw (); | |
35821 | extern double lgamma_r (double, int *__signgamp) throw (); extern double __lgamma_r (double, int *__signgamp) throw (); | |
35822 | extern double rint (double __x) throw (); extern double __rint (double __x) throw (); | |
35823 | extern double nextafter (double __x, double __y) throw () __attribute__ ((__const__)); extern double __nextafter (double __x, double __y) throw () __attribute__ ((__const__)); | |
35824 | extern double nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); extern double __nexttoward (double __x, long double __y) throw () __attribute__ ((__const__)); | |
35825 | extern double remainder (double __x, double __y) throw (); extern double __remainder (double __x, double __y) throw (); | |
35826 | extern double scalbn (double __x, int __n) throw (); extern double __scalbn (double __x, int __n) throw (); | |
35827 | extern int ilogb (double __x) throw (); extern int __ilogb (double __x) throw (); | |
35828 | extern double scalbln (double __x, long int __n) throw (); extern double __scalbln (double __x, long int __n) throw (); | |
35829 | extern double nearbyint (double __x) throw (); extern double __nearbyint (double __x) throw (); | |
35830 | extern double round (double __x) throw () __attribute__ ((__const__)); extern double __round (double __x) throw () __attribute__ ((__const__)); | |
35831 | extern double trunc (double __x) throw () __attribute__ ((__const__)); extern double __trunc (double __x) throw () __attribute__ ((__const__)); | |
35832 | extern double remquo (double __x, double __y, int *__quo) throw (); extern double __remquo (double __x, double __y, int *__quo) throw (); | |
35833 | extern long int lrint (double __x) throw (); extern long int __lrint (double __x) throw (); | |
35834 | extern long long int llrint (double __x) throw (); extern long long int __llrint (double __x) throw (); | |
35835 | extern long int lround (double __x) throw (); extern long int __lround (double __x) throw (); | |
35836 | extern long long int llround (double __x) throw (); extern long long int __llround (double __x) throw (); | |
35837 | extern double fdim (double __x, double __y) throw (); extern double __fdim (double __x, double __y) throw (); | |
35838 | extern double fmax (double __x, double __y) throw (); extern double __fmax (double __x, double __y) throw (); | |
35839 | extern double fmin (double __x, double __y) throw (); extern double __fmin (double __x, double __y) throw (); | |
35840 | extern int __fpclassify (double __value) throw () | |
35841 | __attribute__ ((__const__)); | |
35842 | extern int __signbit (double __value) throw () | |
35843 | __attribute__ ((__const__)); | |
35844 | extern double fma (double __x, double __y, double __z) throw (); extern double __fma (double __x, double __y, double __z) throw (); | |
35845 | extern double scalb (double __x, double __n) throw (); extern double __scalb (double __x, double __n) throw (); | |
35846 | extern float acosf (float __x) throw (); extern float __acosf (float __x) throw (); | |
35847 | extern float asinf (float __x) throw (); extern float __asinf (float __x) throw (); | |
35848 | extern float atanf (float __x) throw (); extern float __atanf (float __x) throw (); | |
35849 | extern float atan2f (float __y, float __x) throw (); extern float __atan2f (float __y, float __x) throw (); | |
35850 | extern float cosf (float __x) throw (); extern float __cosf (float __x) throw (); | |
35851 | extern float sinf (float __x) throw (); extern float __sinf (float __x) throw (); | |
35852 | extern float tanf (float __x) throw (); extern float __tanf (float __x) throw (); | |
35853 | extern float coshf (float __x) throw (); extern float __coshf (float __x) throw (); | |
35854 | extern float sinhf (float __x) throw (); extern float __sinhf (float __x) throw (); | |
35855 | extern float tanhf (float __x) throw (); extern float __tanhf (float __x) throw (); | |
35856 | extern float acoshf (float __x) throw (); extern float __acoshf (float __x) throw (); | |
35857 | extern float asinhf (float __x) throw (); extern float __asinhf (float __x) throw (); | |
35858 | extern float atanhf (float __x) throw (); extern float __atanhf (float __x) throw (); | |
35859 | extern float expf (float __x) throw (); extern float __expf (float __x) throw (); | |
35860 | extern float frexpf (float __x, int *__exponent) throw (); extern float __frexpf (float __x, int *__exponent) throw (); | |
35861 | extern float ldexpf (float __x, int __exponent) throw (); extern float __ldexpf (float __x, int __exponent) throw (); | |
35862 | extern float logf (float __x) throw (); extern float __logf (float __x) throw (); | |
35863 | extern float log10f (float __x) throw (); extern float __log10f (float __x) throw (); | |
35864 | extern float modff (float __x, float *__iptr) throw (); extern float __modff (float __x, float *__iptr) throw (); | |
35865 | extern float expm1f (float __x) throw (); extern float __expm1f (float __x) throw (); | |
35866 | extern float log1pf (float __x) throw (); extern float __log1pf (float __x) throw (); | |
35867 | extern float logbf (float __x) throw (); extern float __logbf (float __x) throw (); | |
35868 | extern float exp2f (float __x) throw (); extern float __exp2f (float __x) throw (); | |
35869 | extern float log2f (float __x) throw (); extern float __log2f (float __x) throw (); | |
35870 | extern float powf (float __x, float __y) throw (); extern float __powf (float __x, float __y) throw (); | |
35871 | extern float sqrtf (float __x) throw (); extern float __sqrtf (float __x) throw (); | |
35872 | extern float hypotf (float __x, float __y) throw (); extern float __hypotf (float __x, float __y) throw (); | |
35873 | extern float cbrtf (float __x) throw (); extern float __cbrtf (float __x) throw (); | |
35874 | extern float ceilf (float __x) throw () __attribute__ ((__const__)); extern float __ceilf (float __x) throw () __attribute__ ((__const__)); | |
35875 | extern float fabsf (float __x) throw () __attribute__ ((__const__)); extern float __fabsf (float __x) throw () __attribute__ ((__const__)); | |
35876 | extern float floorf (float __x) throw () __attribute__ ((__const__)); extern float __floorf (float __x) throw () __attribute__ ((__const__)); | |
35877 | extern float fmodf (float __x, float __y) throw (); extern float __fmodf (float __x, float __y) throw (); | |
35878 | extern int __isinff (float __value) throw () __attribute__ ((__const__)); | |
35879 | extern int __finitef (float __value) throw () __attribute__ ((__const__)); | |
35880 | extern int isinff (float __value) throw () __attribute__ ((__const__)); | |
35881 | extern int finitef (float __value) throw () __attribute__ ((__const__)); | |
35882 | extern float dremf (float __x, float __y) throw (); extern float __dremf (float __x, float __y) throw (); | |
35883 | extern float significandf (float __x) throw (); extern float __significandf (float __x) throw (); | |
35884 | extern float copysignf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __copysignf (float __x, float __y) throw () __attribute__ ((__const__)); | |
35885 | extern float nanf (__const char *__tagb) throw () __attribute__ ((__const__)); extern float __nanf (__const char *__tagb) throw () __attribute__ ((__const__)); | |
35886 | extern int __isnanf (float __value) throw () __attribute__ ((__const__)); | |
35887 | extern int isnanf (float __value) throw () __attribute__ ((__const__)); | |
35888 | extern float j0f (float) throw (); extern float __j0f (float) throw (); | |
35889 | extern float j1f (float) throw (); extern float __j1f (float) throw (); | |
35890 | extern float jnf (int, float) throw (); extern float __jnf (int, float) throw (); | |
35891 | extern float y0f (float) throw (); extern float __y0f (float) throw (); | |
35892 | extern float y1f (float) throw (); extern float __y1f (float) throw (); | |
35893 | extern float ynf (int, float) throw (); extern float __ynf (int, float) throw (); | |
35894 | extern float erff (float) throw (); extern float __erff (float) throw (); | |
35895 | extern float erfcf (float) throw (); extern float __erfcf (float) throw (); | |
35896 | extern float lgammaf (float) throw (); extern float __lgammaf (float) throw (); | |
35897 | extern float tgammaf (float) throw (); extern float __tgammaf (float) throw (); | |
35898 | extern float gammaf (float) throw (); extern float __gammaf (float) throw (); | |
35899 | extern float lgammaf_r (float, int *__signgamp) throw (); extern float __lgammaf_r (float, int *__signgamp) throw (); | |
35900 | extern float rintf (float __x) throw (); extern float __rintf (float __x) throw (); | |
35901 | extern float nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); extern float __nextafterf (float __x, float __y) throw () __attribute__ ((__const__)); | |
35902 | extern float nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); extern float __nexttowardf (float __x, long double __y) throw () __attribute__ ((__const__)); | |
35903 | extern float remainderf (float __x, float __y) throw (); extern float __remainderf (float __x, float __y) throw (); | |
35904 | extern float scalbnf (float __x, int __n) throw (); extern float __scalbnf (float __x, int __n) throw (); | |
35905 | extern int ilogbf (float __x) throw (); extern int __ilogbf (float __x) throw (); | |
35906 | extern float scalblnf (float __x, long int __n) throw (); extern float __scalblnf (float __x, long int __n) throw (); | |
35907 | extern float nearbyintf (float __x) throw (); extern float __nearbyintf (float __x) throw (); | |
35908 | extern float roundf (float __x) throw () __attribute__ ((__const__)); extern float __roundf (float __x) throw () __attribute__ ((__const__)); | |
35909 | extern float truncf (float __x) throw () __attribute__ ((__const__)); extern float __truncf (float __x) throw () __attribute__ ((__const__)); | |
35910 | extern float remquof (float __x, float __y, int *__quo) throw (); extern float __remquof (float __x, float __y, int *__quo) throw (); | |
35911 | extern long int lrintf (float __x) throw (); extern long int __lrintf (float __x) throw (); | |
35912 | extern long long int llrintf (float __x) throw (); extern long long int __llrintf (float __x) throw (); | |
35913 | extern long int lroundf (float __x) throw (); extern long int __lroundf (float __x) throw (); | |
35914 | extern long long int llroundf (float __x) throw (); extern long long int __llroundf (float __x) throw (); | |
35915 | extern float fdimf (float __x, float __y) throw (); extern float __fdimf (float __x, float __y) throw (); | |
35916 | extern float fmaxf (float __x, float __y) throw (); extern float __fmaxf (float __x, float __y) throw (); | |
35917 | extern float fminf (float __x, float __y) throw (); extern float __fminf (float __x, float __y) throw (); | |
35918 | extern int __fpclassifyf (float __value) throw () | |
35919 | __attribute__ ((__const__)); | |
35920 | extern int __signbitf (float __value) throw () | |
35921 | __attribute__ ((__const__)); | |
35922 | extern float fmaf (float __x, float __y, float __z) throw (); extern float __fmaf (float __x, float __y, float __z) throw (); | |
35923 | extern float scalbf (float __x, float __n) throw (); extern float __scalbf (float __x, float __n) throw (); | |
35924 | extern int signgam; | |
35925 | enum | |
35926 | { | |
35927 | FP_NAN, | |
35928 | FP_INFINITE, | |
35929 | FP_ZERO, | |
35930 | FP_SUBNORMAL, | |
35931 | FP_NORMAL | |
35932 | }; | |
35933 | typedef enum | |
35934 | { | |
35935 | _IEEE_ = -1, | |
35936 | _SVID_, | |
35937 | _XOPEN_, | |
35938 | _POSIX_, | |
35939 | _ISOC_ | |
35940 | } _LIB_VERSION_TYPE; | |
35941 | extern _LIB_VERSION_TYPE _LIB_VERSION; | |
35942 | struct __exception | |
35943 | { | |
35944 | int type; | |
35945 | char *name; | |
35946 | double arg1; | |
35947 | double arg2; | |
35948 | double retval; | |
35949 | }; | |
35950 | extern int matherr (struct __exception *__exc) throw (); | |
35951 | } | |
35952 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
35953 | inline int qCeil(qreal v) | |
35954 | { | |
35955 | if (sizeof(qreal) == sizeof(float)) | |
35956 | return int(ceilf(v)); | |
35957 | else | |
35958 | return int(ceil(v)); | |
35959 | } | |
35960 | inline int qFloor(qreal v) | |
35961 | { | |
35962 | if (sizeof(qreal) == sizeof(float)) | |
35963 | return int(floorf(v)); | |
35964 | else | |
35965 | return int(floor(v)); | |
35966 | } | |
35967 | inline qreal qSin(qreal v) | |
35968 | { | |
35969 | if (sizeof(qreal) == sizeof(float)) | |
35970 | return sinf(v); | |
35971 | else | |
35972 | return sin(v); | |
35973 | } | |
35974 | inline qreal qCos(qreal v) | |
35975 | { | |
35976 | if (sizeof(qreal) == sizeof(float)) | |
35977 | return cosf(v); | |
35978 | else | |
35979 | return cos(v); | |
35980 | } | |
35981 | inline qreal qAcos(qreal v) | |
35982 | { | |
35983 | if (sizeof(qreal) == sizeof(float)) | |
35984 | return acosf(v); | |
35985 | else | |
35986 | return acos(v); | |
35987 | } | |
35988 | inline qreal qSqrt(qreal v) | |
35989 | { | |
35990 | if (sizeof(qreal) == sizeof(float)) | |
35991 | return sqrtf(v); | |
35992 | else | |
35993 | return sqrt(v); | |
35994 | } | |
35995 | inline qreal qLn(qreal v) | |
35996 | { | |
35997 | if (sizeof(qreal) == sizeof(float)) | |
35998 | return logf(v); | |
35999 | else | |
36000 | return log(v); | |
36001 | } | |
36002 | inline qreal qPow(qreal x, qreal y) | |
36003 | { | |
36004 | if (sizeof(qreal) == sizeof(float)) | |
36005 | return powf(x, y); | |
36006 | else | |
36007 | return pow(x, y); | |
36008 | } | |
36009 | typedef QtValidLicenseForCoreModule QtCoreModule; | |
36010 | inline void qbswap_helper(const uchar *src, uchar *dest, int size) | |
36011 | { | |
36012 | for (int i = 0; i < size ; ++i) dest[i] = src[size - 1 - i]; | |
36013 | } | |
36014 | template <typename T> inline void qbswap(const T src, uchar *dest) | |
36015 | { | |
36016 | qbswap_helper(reinterpret_cast<const uchar *>(&src), dest, sizeof(T)); | |
36017 | } | |
36018 | template <typename T> inline void qToUnaligned(const T src, uchar *dest) | |
36019 | { | |
36020 | qMemCopy(dest, &src, sizeof(T)); | |
36021 | } | |
36022 | template <typename T> inline T qFromLittleEndian(const uchar *src); | |
36023 | template <> inline quint64 qFromLittleEndian<quint64>(const uchar *src) | |
36024 | { | |
36025 | return 0 | |
36026 | | src[0] | |
36027 | | src[1] * static_cast<unsigned long long>(0x0000000000000100ULL) | |
36028 | | src[2] * static_cast<unsigned long long>(0x0000000000010000ULL) | |
36029 | | src[3] * static_cast<unsigned long long>(0x0000000001000000ULL) | |
36030 | | src[4] * static_cast<unsigned long long>(0x0000000100000000ULL) | |
36031 | | src[5] * static_cast<unsigned long long>(0x0000010000000000ULL) | |
36032 | | src[6] * static_cast<unsigned long long>(0x0001000000000000ULL) | |
36033 | | src[7] * static_cast<unsigned long long>(0x0100000000000000ULL); | |
36034 | } | |
36035 | template <> inline quint32 qFromLittleEndian<quint32>(const uchar *src) | |
36036 | { | |
36037 | return 0 | |
36038 | | src[0] | |
36039 | | src[1] * quint32(0x00000100) | |
36040 | | src[2] * quint32(0x00010000) | |
36041 | | src[3] * quint32(0x01000000); | |
36042 | } | |
36043 | template <> inline quint16 qFromLittleEndian<quint16>(const uchar *src) | |
36044 | { | |
36045 | return 0 | |
36046 | | src[0] | |
36047 | | src[1] * 0x0100; | |
36048 | } | |
36049 | template <> inline qint64 qFromLittleEndian<qint64>(const uchar *src) | |
36050 | { return static_cast<qint64>(qFromLittleEndian<quint64>(src)); } | |
36051 | template <> inline qint32 qFromLittleEndian<qint32>(const uchar *src) | |
36052 | { return static_cast<qint32>(qFromLittleEndian<quint32>(src)); } | |
36053 | template <> inline qint16 qFromLittleEndian<qint16>(const uchar *src) | |
36054 | { return static_cast<qint16>(qFromLittleEndian<quint16>(src)); } | |
36055 | template <class T> inline T qFromBigEndian(const uchar *src); | |
36056 | template<> | |
36057 | inline quint64 qFromBigEndian<quint64>(const uchar *src) | |
36058 | { | |
36059 | return 0 | |
36060 | | src[7] | |
36061 | | src[6] * static_cast<unsigned long long>(0x0000000000000100ULL) | |
36062 | | src[5] * static_cast<unsigned long long>(0x0000000000010000ULL) | |
36063 | | src[4] * static_cast<unsigned long long>(0x0000000001000000ULL) | |
36064 | | src[3] * static_cast<unsigned long long>(0x0000000100000000ULL) | |
36065 | | src[2] * static_cast<unsigned long long>(0x0000010000000000ULL) | |
36066 | | src[1] * static_cast<unsigned long long>(0x0001000000000000ULL) | |
36067 | | src[0] * static_cast<unsigned long long>(0x0100000000000000ULL); | |
36068 | } | |
36069 | template<> | |
36070 | inline quint32 qFromBigEndian<quint32>(const uchar *src) | |
36071 | { | |
36072 | return 0 | |
36073 | | src[3] | |
36074 | | src[2] * quint32(0x00000100) | |
36075 | | src[1] * quint32(0x00010000) | |
36076 | | src[0] * quint32(0x01000000); | |
36077 | } | |
36078 | template<> | |
36079 | inline quint16 qFromBigEndian<quint16>(const uchar *src) | |
36080 | { | |
36081 | return 0 | |
36082 | | src[1] | |
36083 | | src[0] * quint16(0x0100); | |
36084 | } | |
36085 | template <> inline qint64 qFromBigEndian<qint64>(const uchar *src) | |
36086 | { return static_cast<qint64>(qFromBigEndian<quint64>(src)); } | |
36087 | template <> inline qint32 qFromBigEndian<qint32>(const uchar *src) | |
36088 | { return static_cast<qint32>(qFromBigEndian<quint32>(src)); } | |
36089 | template <> inline qint16 qFromBigEndian<qint16>(const uchar *src) | |
36090 | { return static_cast<qint16>(qFromBigEndian<quint16>(src)); } | |
36091 | template <typename T> T qbswap(T source); | |
36092 | template <> inline quint64 qbswap<quint64>(quint64 source) | |
36093 | { | |
36094 | return 0 | |
36095 | | ((source & static_cast<unsigned long long>(0x00000000000000ffULL)) << 56) | |
36096 | | ((source & static_cast<unsigned long long>(0x000000000000ff00ULL)) << 40) | |
36097 | | ((source & static_cast<unsigned long long>(0x0000000000ff0000ULL)) << 24) | |
36098 | | ((source & static_cast<unsigned long long>(0x00000000ff000000ULL)) << 8) | |
36099 | | ((source & static_cast<unsigned long long>(0x000000ff00000000ULL)) >> 8) | |
36100 | | ((source & static_cast<unsigned long long>(0x0000ff0000000000ULL)) >> 24) | |
36101 | | ((source & static_cast<unsigned long long>(0x00ff000000000000ULL)) >> 40) | |
36102 | | ((source & static_cast<unsigned long long>(0xff00000000000000ULL)) >> 56); | |
36103 | } | |
36104 | template <> inline quint32 qbswap<quint32>(quint32 source) | |
36105 | { | |
36106 | return 0 | |
36107 | | ((source & 0x000000ff) << 24) | |
36108 | | ((source & 0x0000ff00) << 8) | |
36109 | | ((source & 0x00ff0000) >> 8) | |
36110 | | ((source & 0xff000000) >> 24); | |
36111 | } | |
36112 | template <> inline quint16 qbswap<quint16>(quint16 source) | |
36113 | { | |
36114 | return 0 | |
36115 | | ((source & 0x00ff) << 8) | |
36116 | | ((source & 0xff00) >> 8); | |
36117 | } | |
36118 | template <> inline qint64 qbswap<qint64>(qint64 source) | |
36119 | { | |
36120 | return qbswap<quint64>(quint64(source)); | |
36121 | } | |
36122 | template <> inline qint32 qbswap<qint32>(qint32 source) | |
36123 | { | |
36124 | return qbswap<quint32>(quint32(source)); | |
36125 | } | |
36126 | template <> inline qint16 qbswap<qint16>(qint16 source) | |
36127 | { | |
36128 | return qbswap<quint16>(quint16(source)); | |
36129 | } | |
36130 | template <typename T> inline T qToBigEndian(T source) | |
36131 | { return qbswap<T>(source); } | |
36132 | template <typename T> inline T qFromBigEndian(T source) | |
36133 | { return qbswap<T>(source); } | |
36134 | template <typename T> inline T qToLittleEndian(T source) | |
36135 | { return source; } | |
36136 | template <typename T> inline T qFromLittleEndian(T source) | |
36137 | { return source; } | |
36138 | template <typename T> inline void qToBigEndian(T src, uchar *dest) | |
36139 | { qbswap<T>(src, dest); } | |
36140 | template <typename T> inline void qToLittleEndian(T src, uchar *dest) | |
36141 | { qToUnaligned<T>(src, dest); } | |
36142 | static inline bool qtransform_equals_no_translate(const QTransform &a, const QTransform &b) | |
36143 | { | |
36144 | if (a.type() <= QTransform::TxTranslate && b.type() <= QTransform::TxTranslate) { | |
36145 | return true; | |
36146 | } else { | |
36147 | qt_noop(); | |
36148 | qt_noop(); | |
36149 | return a.m11() == b.m11() | |
36150 | && a.m12() == b.m12() | |
36151 | && a.m21() == b.m21() | |
36152 | && a.m22() == b.m22(); | |
36153 | } | |
36154 | } | |
36155 | QFontEngineGlyphCache::~QFontEngineGlyphCache() | |
36156 | { | |
36157 | } | |
36158 | static HB_Bool hb_stringToGlyphs(HB_Font font, const HB_UChar16 *string, hb_uint32 length, HB_Glyph *glyphs, hb_uint32 *numGlyphs, HB_Bool rightToLeft) | |
36159 | { | |
36160 | QFontEngine *fe = (QFontEngine *)font->userData; | |
36161 | QVarLengthGlyphLayoutArray qglyphs(*numGlyphs); | |
36162 | QTextEngine::ShaperFlags shaperFlags(QTextEngine::GlyphIndicesOnly); | |
36163 | if (rightToLeft) | |
36164 | shaperFlags |= QTextEngine::RightToLeft; | |
36165 | int nGlyphs = *numGlyphs; | |
36166 | bool result = fe->stringToCMap(reinterpret_cast<const QChar *>(string), length, &qglyphs, &nGlyphs, shaperFlags); | |
36167 | *numGlyphs = nGlyphs; | |
36168 | if (!result) | |
36169 | return false; | |
36170 | for (hb_uint32 i = 0; i < *numGlyphs; ++i) | |
36171 | glyphs[i] = qglyphs.glyphs[i]; | |
36172 | return true; | |
36173 | } | |
36174 | static void hb_getAdvances(HB_Font font, const HB_Glyph *glyphs, hb_uint32 numGlyphs, HB_Fixed *advances, int flags) | |
36175 | { | |
36176 | QFontEngine *fe = (QFontEngine *)font->userData; | |
36177 | QVarLengthGlyphLayoutArray qglyphs(numGlyphs); | |
36178 | for (hb_uint32 i = 0; i < numGlyphs; ++i) | |
36179 | qglyphs.glyphs[i] = glyphs[i]; | |
36180 | fe->recalcAdvances(&qglyphs, flags & HB_ShaperFlag_UseDesignMetrics ? QFlags<QTextEngine::ShaperFlag>(QTextEngine::DesignMetrics) : QFlags<QTextEngine::ShaperFlag>(0)); | |
36181 | for (hb_uint32 i = 0; i < numGlyphs; ++i) | |
36182 | advances[i] = qglyphs.advances_x[i].value(); | |
36183 | } | |
36184 | static HB_Bool hb_canRender(HB_Font font, const HB_UChar16 *string, hb_uint32 length) | |
36185 | { | |
36186 | QFontEngine *fe = (QFontEngine *)font->userData; | |
36187 | return fe->canRender(reinterpret_cast<const QChar *>(string), length); | |
36188 | } | |
36189 | static void hb_getGlyphMetrics(HB_Font font, HB_Glyph glyph, HB_GlyphMetrics *metrics) | |
36190 | { | |
36191 | QFontEngine *fe = (QFontEngine *)font->userData; | |
36192 | glyph_metrics_t m = fe->boundingBox(glyph); | |
36193 | metrics->x = m.x.value(); | |
36194 | metrics->y = m.y.value(); | |
36195 | metrics->width = m.width.value(); | |
36196 | metrics->height = m.height.value(); | |
36197 | metrics->xOffset = m.xoff.value(); | |
36198 | metrics->yOffset = m.yoff.value(); | |
36199 | } | |
36200 | static HB_Fixed hb_getFontMetric(HB_Font font, HB_FontMetric metric) | |
36201 | { | |
36202 | if (metric == HB_FontAscent) { | |
36203 | QFontEngine *fe = (QFontEngine *)font->userData; | |
36204 | return fe->ascent().value(); | |
36205 | } | |
36206 | return 0; | |
36207 | } | |
36208 | HB_Error QFontEngine::getPointInOutline(HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints) | |
36209 | { | |
36210 | (void)glyph; | |
36211 | (void)flags; | |
36212 | (void)point; | |
36213 | (void)xpos; | |
36214 | (void)ypos; | |
36215 | (void)nPoints; | |
36216 | return HB_Err_Not_Covered; | |
36217 | } | |
36218 | static HB_Error hb_getPointInOutline(HB_Font font, HB_Glyph glyph, int flags, hb_uint32 point, HB_Fixed *xpos, HB_Fixed *ypos, hb_uint32 *nPoints) | |
36219 | { | |
36220 | QFontEngine *fe = (QFontEngine *)font->userData; | |
36221 | return fe->getPointInOutline(glyph, flags, point, xpos, ypos, nPoints); | |
36222 | } | |
36223 | static const HB_FontClass hb_fontClass = { | |
36224 | hb_stringToGlyphs, hb_getAdvances, hb_canRender, hb_getPointInOutline, | |
36225 | hb_getGlyphMetrics, hb_getFontMetric | |
36226 | }; | |
36227 | static HB_Error hb_getSFntTable(void *font, HB_Tag tableTag, HB_Byte *buffer, HB_UInt *length) | |
36228 | { | |
36229 | QFontEngine *fe = (QFontEngine *)font; | |
36230 | if (!fe->getSfntTableData(tableTag, buffer, length)) | |
36231 | return HB_Err_Invalid_Argument; | |
36232 | return HB_Err_Ok; | |
36233 | } | |
36234 | QFontEngine::QFontEngine() | |
36235 | : QObject() | |
36236 | { | |
36237 | ref = 0; | |
36238 | cache_count = 0; | |
36239 | fsType = 0; | |
36240 | symbol = false; | |
36241 | memset(&hbFont, 0, sizeof(hbFont)); | |
36242 | hbFont.klass = &hb_fontClass; | |
36243 | hbFont.userData = this; | |
36244 | hbFace = 0; | |
36245 | glyphFormat = -1; | |
36246 | } | |
36247 | QFontEngine::~QFontEngine() | |
36248 | { | |
36249 | for (GlyphPointerHash::iterator it = m_glyphPointerHash.begin(), end = m_glyphPointerHash.end(); | |
36250 | it != end; ++it) { | |
36251 | for (QList<QFontEngineGlyphCache*>::iterator it2 = it.value().begin(), end2 = it.value().end(); | |
36252 | it2 != end2; ++it2) | |
36253 | delete *it2; | |
36254 | } | |
36255 | m_glyphPointerHash.clear(); | |
36256 | for (GlyphIntHash::iterator it = m_glyphIntHash.begin(), end = m_glyphIntHash.end(); | |
36257 | it != end; ++it) { | |
36258 | for (QList<QFontEngineGlyphCache*>::iterator it2 = it.value().begin(), end2 = it.value().end(); | |
36259 | it2 != end2; ++it2) | |
36260 | delete *it2; | |
36261 | } | |
36262 | m_glyphIntHash.clear(); | |
36263 | qHBFreeFace(hbFace); | |
36264 | } | |
36265 | QFixed QFontEngine::lineThickness() const | |
36266 | { | |
36267 | int score = fontDef.weight * fontDef.pixelSize; | |
36268 | int lw = score / 700; | |
36269 | if (lw < 2 && score >= 1050) lw = 2; | |
36270 | if (lw == 0) lw = 1; | |
36271 | return lw; | |
36272 | } | |
36273 | QFixed QFontEngine::underlinePosition() const | |
36274 | { | |
36275 | return ((lineThickness() * 2) + 3) / 6; | |
36276 | } | |
36277 | HB_Font QFontEngine::harfbuzzFont() const | |
36278 | { | |
36279 | if (!hbFont.x_ppem) { | |
36280 | QFixed emSquare = emSquareSize(); | |
36281 | hbFont.x_ppem = fontDef.pixelSize; | |
36282 | hbFont.y_ppem = fontDef.pixelSize * fontDef.stretch / 100; | |
36283 | hbFont.x_scale = (QFixed(hbFont.x_ppem * (1 << 16)) / emSquare).value(); | |
36284 | hbFont.y_scale = (QFixed(hbFont.y_ppem * (1 << 16)) / emSquare).value(); | |
36285 | } | |
36286 | return &hbFont; | |
36287 | } | |
36288 | HB_Face QFontEngine::harfbuzzFace() const | |
36289 | { | |
36290 | if (!hbFace) | |
36291 | hbFace = qHBNewFace(const_cast<QFontEngine *>(this), hb_getSFntTable); | |
36292 | return hbFace; | |
36293 | } | |
36294 | glyph_metrics_t QFontEngine::boundingBox(glyph_t glyph, const QTransform &matrix) | |
36295 | { | |
36296 | glyph_metrics_t metrics = boundingBox(glyph); | |
36297 | if (matrix.type() > QTransform::TxTranslate) { | |
36298 | return metrics.transformed(matrix); | |
36299 | } | |
36300 | return metrics; | |
36301 | } | |
36302 | QFixed QFontEngine::xHeight() const | |
36303 | { | |
36304 | QGlyphLayoutArray<8> glyphs; | |
36305 | int nglyphs = 7; | |
36306 | QChar x((ushort)'x'); | |
36307 | stringToCMap(&x, 1, &glyphs, &nglyphs, QTextEngine::GlyphIndicesOnly); | |
36308 | glyph_metrics_t bb = const_cast<QFontEngine *>(this)->boundingBox(glyphs.glyphs[0]); | |
36309 | return bb.height; | |
36310 | } | |
36311 | QFixed QFontEngine::averageCharWidth() const | |
36312 | { | |
36313 | QGlyphLayoutArray<8> glyphs; | |
36314 | int nglyphs = 7; | |
36315 | QChar x((ushort)'x'); | |
36316 | stringToCMap(&x, 1, &glyphs, &nglyphs, QTextEngine::GlyphIndicesOnly); | |
36317 | glyph_metrics_t bb = const_cast<QFontEngine *>(this)->boundingBox(glyphs.glyphs[0]); | |
36318 | return bb.xoff; | |
36319 | } | |
36320 | void QFontEngine::getGlyphPositions(const QGlyphLayout &glyphs, const QTransform &matrix, QTextItem::RenderFlags flags, | |
36321 | QVarLengthArray<glyph_t> &glyphs_out, QVarLengthArray<QFixedPoint> &positions) | |
36322 | { | |
36323 | QFixed xpos; | |
36324 | QFixed ypos; | |
36325 | const bool transform = matrix.m11() != 1. | |
36326 | || matrix.m12() != 0. | |
36327 | || matrix.m21() != 0. | |
36328 | || matrix.m22() != 1.; | |
36329 | if (!transform) { | |
36330 | xpos = QFixed::fromReal(matrix.dx()); | |
36331 | ypos = QFixed::fromReal(matrix.dy()); | |
36332 | } | |
36333 | int current = 0; | |
36334 | if (flags & QTextItem::RightToLeft) { | |
36335 | int i = glyphs.numGlyphs; | |
36336 | int totalKashidas = 0; | |
36337 | while(i--) { | |
36338 | xpos += glyphs.advances_x[i] + QFixed::fromFixed(glyphs.justifications[i].space_18d6); | |
36339 | ypos += glyphs.advances_y[i]; | |
36340 | totalKashidas += glyphs.justifications[i].nKashidas; | |
36341 | } | |
36342 | positions.resize(glyphs.numGlyphs+totalKashidas); | |
36343 | glyphs_out.resize(glyphs.numGlyphs+totalKashidas); | |
36344 | i = 0; | |
36345 | while(i < glyphs.numGlyphs) { | |
36346 | if (glyphs.attributes[i].dontPrint) { | |
36347 | ++i; | |
36348 | continue; | |
36349 | } | |
36350 | xpos -= glyphs.advances_x[i]; | |
36351 | ypos -= glyphs.advances_y[i]; | |
36352 | QFixed gpos_x = xpos + glyphs.offsets[i].x; | |
36353 | QFixed gpos_y = ypos + glyphs.offsets[i].y; | |
36354 | if (transform) { | |
36355 | QPointF gpos(gpos_x.toReal(), gpos_y.toReal()); | |
36356 | gpos = gpos * matrix; | |
36357 | gpos_x = QFixed::fromReal(gpos.x()); | |
36358 | gpos_y = QFixed::fromReal(gpos.y()); | |
36359 | } | |
36360 | positions[current].x = gpos_x; | |
36361 | positions[current].y = gpos_y; | |
36362 | glyphs_out[current] = glyphs.glyphs[i]; | |
36363 | ++current; | |
36364 | if (glyphs.justifications[i].nKashidas) { | |
36365 | QChar ch(0x640); | |
36366 | QGlyphLayoutArray<8> g; | |
36367 | int nglyphs = 7; | |
36368 | stringToCMap(&ch, 1, &g, &nglyphs, 0); | |
36369 | for (uint k = 0; k < glyphs.justifications[i].nKashidas; ++k) { | |
36370 | xpos -= g.advances_x[0]; | |
36371 | ypos -= g.advances_y[0]; | |
36372 | QFixed gpos_x = xpos + glyphs.offsets[i].x; | |
36373 | QFixed gpos_y = ypos + glyphs.offsets[i].y; | |
36374 | if (transform) { | |
36375 | QPointF gpos(gpos_x.toReal(), gpos_y.toReal()); | |
36376 | gpos = gpos * matrix; | |
36377 | gpos_x = QFixed::fromReal(gpos.x()); | |
36378 | gpos_y = QFixed::fromReal(gpos.y()); | |
36379 | } | |
36380 | positions[current].x = gpos_x; | |
36381 | positions[current].y = gpos_y; | |
36382 | glyphs_out[current] = g.glyphs[0]; | |
36383 | ++current; | |
36384 | } | |
36385 | } else { | |
36386 | xpos -= QFixed::fromFixed(glyphs.justifications[i].space_18d6); | |
36387 | } | |
36388 | ++i; | |
36389 | } | |
36390 | } else { | |
36391 | positions.resize(glyphs.numGlyphs); | |
36392 | glyphs_out.resize(glyphs.numGlyphs); | |
36393 | int i = 0; | |
36394 | if (!transform) { | |
36395 | while (i < glyphs.numGlyphs) { | |
36396 | if (!glyphs.attributes[i].dontPrint) { | |
36397 | positions[current].x = xpos + glyphs.offsets[i].x; | |
36398 | positions[current].y = ypos + glyphs.offsets[i].y; | |
36399 | glyphs_out[current] = glyphs.glyphs[i]; | |
36400 | xpos += glyphs.advances_x[i] + QFixed::fromFixed(glyphs.justifications[i].space_18d6); | |
36401 | ypos += glyphs.advances_y[i]; | |
36402 | ++current; | |
36403 | } | |
36404 | ++i; | |
36405 | } | |
36406 | } else { | |
36407 | positions.resize(glyphs.numGlyphs); | |
36408 | glyphs_out.resize(glyphs.numGlyphs); | |
36409 | int i = 0; | |
36410 | while (i < glyphs.numGlyphs) { | |
36411 | if (!glyphs.attributes[i].dontPrint) { | |
36412 | QFixed gpos_x = xpos + glyphs.offsets[i].x; | |
36413 | QFixed gpos_y = ypos + glyphs.offsets[i].y; | |
36414 | QPointF gpos(gpos_x.toReal(), gpos_y.toReal()); | |
36415 | gpos = gpos * matrix; | |
36416 | positions[current].x = QFixed::fromReal(gpos.x()); | |
36417 | positions[current].y = QFixed::fromReal(gpos.y()); | |
36418 | glyphs_out[current] = glyphs.glyphs[i]; | |
36419 | xpos += glyphs.advances_x[i] + QFixed::fromFixed(glyphs.justifications[i].space_18d6); | |
36420 | ypos += glyphs.advances_y[i]; | |
36421 | ++current; | |
36422 | } | |
36423 | ++i; | |
36424 | } | |
36425 | } | |
36426 | } | |
36427 | positions.resize(current); | |
36428 | glyphs_out.resize(current); | |
36429 | qt_noop(); | |
36430 | } | |
36431 | glyph_metrics_t QFontEngine::tightBoundingBox(const QGlyphLayout &glyphs) | |
36432 | { | |
36433 | glyph_metrics_t overall; | |
36434 | QFixed ymax = 0; | |
36435 | QFixed xmax = 0; | |
36436 | for (int i = 0; i < glyphs.numGlyphs; i++) { | |
36437 | glyph_metrics_t bb = boundingBox(glyphs.glyphs[i]); | |
36438 | QFixed x = overall.xoff + glyphs.offsets[i].x + bb.x; | |
36439 | QFixed y = overall.yoff + glyphs.offsets[i].y + bb.y; | |
36440 | overall.x = qMin(overall.x, x); | |
36441 | overall.y = qMin(overall.y, y); | |
36442 | xmax = qMax(xmax, x + bb.width); | |
36443 | ymax = qMax(ymax, y + bb.height); | |
36444 | overall.xoff += bb.xoff; | |
36445 | overall.yoff += bb.yoff; | |
36446 | } | |
36447 | overall.height = qMax(overall.height, ymax - overall.y); | |
36448 | overall.width = xmax - overall.x; | |
36449 | return overall; | |
36450 | } | |
36451 | void QFontEngine::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, | |
36452 | QTextItem::RenderFlags flags) | |
36453 | { | |
36454 | if (!glyphs.numGlyphs) | |
36455 | return; | |
36456 | QVarLengthArray<QFixedPoint> positions; | |
36457 | QVarLengthArray<glyph_t> positioned_glyphs; | |
36458 | QTransform matrix; | |
36459 | matrix.translate(x, y); | |
36460 | getGlyphPositions(glyphs, matrix, flags, positioned_glyphs, positions); | |
36461 | addGlyphsToPath(positioned_glyphs.data(), positions.data(), positioned_glyphs.size(), path, flags); | |
36462 | } | |
36463 | enum { EdgeRight = 0x1, | |
36464 | EdgeDown = 0x2, | |
36465 | EdgeLeft = 0x4, | |
36466 | EdgeUp = 0x8 | |
36467 | }; | |
36468 | static void collectSingleContour(qreal x0, qreal y0, uint *grid, int x, int y, int w, int h, QPainterPath *path) | |
36469 | { | |
36470 | (void)h;; | |
36471 | path->moveTo(x + x0, y + y0); | |
36472 | while (grid[(y)*(w+1) + (x)]) { | |
36473 | if (grid[(y)*(w+1) + (x)] & EdgeRight) { | |
36474 | while (grid[(y)*(w+1) + (x)] & EdgeRight) { | |
36475 | grid[(y)*(w+1) + (x)] &= ~EdgeRight; | |
36476 | ++x; | |
36477 | } | |
36478 | qt_noop(); | |
36479 | path->lineTo(x + x0, y + y0); | |
36480 | continue; | |
36481 | } | |
36482 | if (grid[(y)*(w+1) + (x)] & EdgeDown) { | |
36483 | while (grid[(y)*(w+1) + (x)] & EdgeDown) { | |
36484 | grid[(y)*(w+1) + (x)] &= ~EdgeDown; | |
36485 | ++y; | |
36486 | } | |
36487 | qt_noop(); | |
36488 | path->lineTo(x + x0, y + y0); | |
36489 | continue; | |
36490 | } | |
36491 | if (grid[(y)*(w+1) + (x)] & EdgeLeft) { | |
36492 | while (grid[(y)*(w+1) + (x)] & EdgeLeft) { | |
36493 | grid[(y)*(w+1) + (x)] &= ~EdgeLeft; | |
36494 | --x; | |
36495 | } | |
36496 | qt_noop(); | |
36497 | path->lineTo(x + x0, y + y0); | |
36498 | continue; | |
36499 | } | |
36500 | if (grid[(y)*(w+1) + (x)] & EdgeUp) { | |
36501 | while (grid[(y)*(w+1) + (x)] & EdgeUp) { | |
36502 | grid[(y)*(w+1) + (x)] &= ~EdgeUp; | |
36503 | --y; | |
36504 | } | |
36505 | qt_noop(); | |
36506 | path->lineTo(x + x0, y + y0); | |
36507 | continue; | |
36508 | } | |
36509 | } | |
36510 | path->closeSubpath(); | |
36511 | } | |
36512 | void qt_addBitmapToPath(qreal x0, qreal y0, const uchar *image_data, int bpl, int w, int h, QPainterPath *path) | |
36513 | { | |
36514 | uint *grid = new uint[(w+1)*(h+1)]; | |
36515 | for (int y = 0; y <= h; ++y) { | |
36516 | for (int x = 0; x <= w; ++x) { | |
36517 | bool topLeft = (x == 0)|(y == 0) ? false : (*(image_data + (y - 1)*bpl + ((x - 1) >> 3)) & (0x80 >> ((x - 1) & 7))); | |
36518 | bool topRight = (x == w)|(y == 0) ? false : (*(image_data + (y - 1)*bpl + ((x) >> 3)) & (0x80 >> ((x) & 7))); | |
36519 | bool bottomLeft = (x == 0)|(y == h) ? false : (*(image_data + (y)*bpl + ((x - 1) >> 3)) & (0x80 >> ((x - 1) & 7))); | |
36520 | bool bottomRight = (x == w)|(y == h) ? false : (*(image_data + (y)*bpl + ((x) >> 3)) & (0x80 >> ((x) & 7))); | |
36521 | grid[(y)*(w+1) + (x)] = 0; | |
36522 | if ((!topRight) & bottomRight) | |
36523 | grid[(y)*(w+1) + (x)] |= EdgeRight; | |
36524 | if ((!bottomRight) & bottomLeft) | |
36525 | grid[(y)*(w+1) + (x)] |= EdgeDown; | |
36526 | if ((!bottomLeft) & topLeft) | |
36527 | grid[(y)*(w+1) + (x)] |= EdgeLeft; | |
36528 | if ((!topLeft) & topRight) | |
36529 | grid[(y)*(w+1) + (x)] |= EdgeUp; | |
36530 | } | |
36531 | } | |
36532 | for (int y = 0; y < h; ++y) { | |
36533 | for (int x = 0; x < w; ++x) { | |
36534 | if (!grid[(y)*(w+1) + (x)]) | |
36535 | continue; | |
36536 | collectSingleContour(x0, y0, grid, x, y, w, h, path); | |
36537 | } | |
36538 | } | |
36539 | delete [] grid; | |
36540 | } | |
36541 | void QFontEngine::addBitmapFontToPath(qreal x, qreal y, const QGlyphLayout &glyphs, | |
36542 | QPainterPath *path, QTextItem::RenderFlags flags) | |
36543 | { | |
36544 | (void)flags;; | |
36545 | QFixed advanceX = QFixed::fromReal(x); | |
36546 | QFixed advanceY = QFixed::fromReal(y); | |
36547 | for (int i=0; i < glyphs.numGlyphs; ++i) { | |
36548 | glyph_metrics_t metrics = boundingBox(glyphs.glyphs[i]); | |
36549 | if (metrics.width.value() == 0 || metrics.height.value() == 0) { | |
36550 | advanceX += glyphs.advances_x[i]; | |
36551 | advanceY += glyphs.advances_y[i]; | |
36552 | continue; | |
36553 | } | |
36554 | const QImage alphaMask = alphaMapForGlyph(glyphs.glyphs[i]); | |
36555 | const int w = alphaMask.width(); | |
36556 | const int h = alphaMask.height(); | |
36557 | const int srcBpl = alphaMask.bytesPerLine(); | |
36558 | QImage bitmap; | |
36559 | if (alphaMask.depth() == 1) { | |
36560 | bitmap = alphaMask; | |
36561 | } else { | |
36562 | bitmap = QImage(w, h, QImage::Format_Mono); | |
36563 | const uchar *imageData = alphaMask.bits(); | |
36564 | const int destBpl = bitmap.bytesPerLine(); | |
36565 | uchar *bitmapData = bitmap.bits(); | |
36566 | for (int yi = 0; yi < h; ++yi) { | |
36567 | const uchar *src = imageData + yi*srcBpl; | |
36568 | uchar *dst = bitmapData + yi*destBpl; | |
36569 | for (int xi = 0; xi < w; ++xi) { | |
36570 | const int byte = xi / 8; | |
36571 | const int bit = xi % 8; | |
36572 | if (bit == 0) | |
36573 | dst[byte] = 0; | |
36574 | if (src[xi]) | |
36575 | dst[byte] |= 128 >> bit; | |
36576 | } | |
36577 | } | |
36578 | } | |
36579 | const uchar *bitmap_data = bitmap.bits(); | |
36580 | QFixedPoint offset = glyphs.offsets[i]; | |
36581 | advanceX += offset.x; | |
36582 | advanceY += offset.y; | |
36583 | qt_addBitmapToPath((advanceX + metrics.x).toReal(), (advanceY + metrics.y).toReal(), bitmap_data, bitmap.bytesPerLine(), w, h, path); | |
36584 | advanceX += glyphs.advances_x[i]; | |
36585 | advanceY += glyphs.advances_y[i]; | |
36586 | } | |
36587 | } | |
36588 | void QFontEngine::addGlyphsToPath(glyph_t *glyphs, QFixedPoint *positions, int nGlyphs, | |
36589 | QPainterPath *path, QTextItem::RenderFlags flags) | |
36590 | { | |
36591 | qreal x = positions[0].x.toReal(); | |
36592 | qreal y = positions[0].y.toReal(); | |
36593 | QVarLengthGlyphLayoutArray g(nGlyphs); | |
36594 | for (int i = 0; i < nGlyphs; ++i) { | |
36595 | g.glyphs[i] = glyphs[i]; | |
36596 | if (i < nGlyphs - 1) { | |
36597 | g.advances_x[i] = positions[i+1].x - positions[i].x; | |
36598 | g.advances_y[i] = positions[i+1].y - positions[i].y; | |
36599 | } else { | |
36600 | g.advances_x[i] = QFixed::fromReal(maxCharWidth()); | |
36601 | g.advances_y[i] = 0; | |
36602 | } | |
36603 | } | |
36604 | addBitmapFontToPath(x, y, g, path, flags); | |
36605 | } | |
36606 | QImage QFontEngine::alphaMapForGlyph(glyph_t glyph, const QTransform &t) | |
36607 | { | |
36608 | QImage i = alphaMapForGlyph(glyph); | |
36609 | if (t.type() > QTransform::TxTranslate) | |
36610 | i = i.transformed(t); | |
36611 | qt_noop(); | |
36612 | return i; | |
36613 | } | |
36614 | QImage QFontEngine::alphaRGBMapForGlyph(glyph_t glyph, int , const QTransform &t) | |
36615 | { | |
36616 | QImage alphaMask = alphaMapForGlyph(glyph, t); | |
36617 | QImage rgbMask(alphaMask.width(), alphaMask.height(), QImage::Format_RGB32); | |
36618 | for (int y=0; y<alphaMask.height(); ++y) { | |
36619 | uint *dst = (uint *) rgbMask.scanLine(y); | |
36620 | uchar *src = (uchar *) alphaMask.scanLine(y); | |
36621 | for (int x=0; x<alphaMask.width(); ++x) | |
36622 | dst[x] = qRgb(src[x], src[x], src[x]); | |
36623 | } | |
36624 | return rgbMask; | |
36625 | } | |
36626 | void QFontEngine::removeGlyphFromCache(glyph_t) | |
36627 | { | |
36628 | } | |
36629 | QFontEngine::Properties QFontEngine::properties() const | |
36630 | { | |
36631 | Properties p; | |
36632 | QByteArray psname = QPdf::stripSpecialCharacters(fontDef.family.toUtf8()); | |
36633 | psname += '-'; | |
36634 | psname += QByteArray::number(fontDef.style); | |
36635 | psname += '-'; | |
36636 | psname += QByteArray::number(fontDef.weight); | |
36637 | p.postscriptName = psname; | |
36638 | p.ascent = ascent(); | |
36639 | p.descent = descent(); | |
36640 | p.leading = leading(); | |
36641 | p.emSquare = p.ascent; | |
36642 | p.boundingBox = QRectF(0, -p.ascent.toReal(), maxCharWidth(), (p.ascent + p.descent).toReal()); | |
36643 | p.italicAngle = 0; | |
36644 | p.capHeight = p.ascent; | |
36645 | p.lineWidth = lineThickness(); | |
36646 | return p; | |
36647 | } | |
36648 | void QFontEngine::getUnscaledGlyph(glyph_t glyph, QPainterPath *path, glyph_metrics_t *metrics) | |
36649 | { | |
36650 | *metrics = boundingBox(glyph); | |
36651 | QFixedPoint p; | |
36652 | p.x = 0; | |
36653 | p.y = 0; | |
36654 | addGlyphsToPath(&glyph, &p, 1, path, QFlag(0)); | |
36655 | } | |
36656 | QByteArray QFontEngine::getSfntTable(uint tag) const | |
36657 | { | |
36658 | QByteArray table; | |
36659 | uint len = 0; | |
36660 | if (!getSfntTableData(tag, 0, &len)) | |
36661 | return table; | |
36662 | if (!len) | |
36663 | return table; | |
36664 | table.resize(len); | |
36665 | if (!getSfntTableData(tag, reinterpret_cast<uchar *>(table.data()), &len)) | |
36666 | return QByteArray(); | |
36667 | return table; | |
36668 | } | |
36669 | void QFontEngine::expireGlyphCache() | |
36670 | { | |
36671 | if (m_glyphCacheQueue.count() > 10) { | |
36672 | QFontEngineGlyphCache *old = m_glyphCacheQueue.takeFirst(); | |
36673 | for (GlyphPointerHash::iterator i = m_glyphPointerHash.begin(); i != m_glyphPointerHash.end(); ++i) { | |
36674 | QList<QFontEngineGlyphCache *> list = i.value(); | |
36675 | if (list.removeAll(old)) { | |
36676 | if (list.isEmpty()) | |
36677 | m_glyphPointerHash.remove(i.key()); | |
36678 | else | |
36679 | m_glyphPointerHash.insert(i.key(), list); | |
36680 | break; | |
36681 | } | |
36682 | } | |
36683 | for (GlyphIntHash::iterator i = m_glyphIntHash.begin(); i != m_glyphIntHash.end(); ++i) { | |
36684 | QList<QFontEngineGlyphCache *> list = i.value(); | |
36685 | if (list.removeAll(old)) { | |
36686 | if (list.isEmpty()) | |
36687 | m_glyphIntHash.remove(i.key()); | |
36688 | else | |
36689 | m_glyphIntHash.insert(i.key(), list); | |
36690 | break; | |
36691 | } | |
36692 | } | |
36693 | delete old; | |
36694 | } | |
36695 | } | |
36696 | void QFontEngine::setGlyphCache(void *key, QFontEngineGlyphCache *data) | |
36697 | { | |
36698 | qt_noop(); | |
36699 | QList<QFontEngineGlyphCache*> items = m_glyphPointerHash.value(key); | |
36700 | for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) { | |
36701 | QFontEngineGlyphCache *c = *it; | |
36702 | if (qtransform_equals_no_translate(c->m_transform, data->m_transform)) { | |
36703 | if (c == data) | |
36704 | return; | |
36705 | items.removeAll(c); | |
36706 | delete c; | |
36707 | break; | |
36708 | } | |
36709 | } | |
36710 | items.append(data); | |
36711 | m_glyphPointerHash.insert(key, items); | |
36712 | m_glyphCacheQueue.append(data); | |
36713 | expireGlyphCache(); | |
36714 | } | |
36715 | void QFontEngine::setGlyphCache(QFontEngineGlyphCache::Type key, QFontEngineGlyphCache *data) | |
36716 | { | |
36717 | qt_noop(); | |
36718 | QList<QFontEngineGlyphCache*> items = m_glyphIntHash.value(key); | |
36719 | for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) { | |
36720 | QFontEngineGlyphCache *c = *it; | |
36721 | if (qtransform_equals_no_translate(c->m_transform, data->m_transform)) { | |
36722 | if (c == data) | |
36723 | return; | |
36724 | items.removeAll(c); | |
36725 | delete c; | |
36726 | break; | |
36727 | } | |
36728 | } | |
36729 | items.append(data); | |
36730 | m_glyphIntHash.insert(key, items); | |
36731 | m_glyphCacheQueue.append(data); | |
36732 | expireGlyphCache(); | |
36733 | } | |
36734 | QFontEngineGlyphCache *QFontEngine::glyphCache(void *key, const QTransform &transform) const | |
36735 | { | |
36736 | QList<QFontEngineGlyphCache*> items = m_glyphPointerHash.value(key); | |
36737 | for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) { | |
36738 | QFontEngineGlyphCache *c = *it; | |
36739 | if (qtransform_equals_no_translate(c->m_transform, transform)) { | |
36740 | m_glyphCacheQueue.removeAll(c); | |
36741 | m_glyphCacheQueue.append(c); | |
36742 | return c; | |
36743 | } | |
36744 | } | |
36745 | return 0; | |
36746 | } | |
36747 | QFontEngineGlyphCache *QFontEngine::glyphCache(QFontEngineGlyphCache::Type key, const QTransform &transform) const | |
36748 | { | |
36749 | QList<QFontEngineGlyphCache*> items = m_glyphIntHash.value(key); | |
36750 | for (QList<QFontEngineGlyphCache*>::iterator it = items.begin(), end = items.end(); it != end; ++it) { | |
36751 | QFontEngineGlyphCache *c = *it; | |
36752 | if (qtransform_equals_no_translate(c->m_transform, transform)) { | |
36753 | m_glyphCacheQueue.removeAll(c); | |
36754 | m_glyphCacheQueue.append(c); | |
36755 | return c; | |
36756 | } | |
36757 | } | |
36758 | return 0; | |
36759 | } | |
36760 | static inline QFixed kerning(int left, int right, const QFontEngine::KernPair *pairs, int numPairs) | |
36761 | { | |
36762 | uint left_right = (left << 16) + right; | |
36763 | left = 0, right = numPairs - 1; | |
36764 | while (left <= right) { | |
36765 | int middle = left + ( ( right - left ) >> 1 ); | |
36766 | if(pairs[middle].left_right == left_right) | |
36767 | return pairs[middle].adjust; | |
36768 | if (pairs[middle].left_right < left_right) | |
36769 | left = middle + 1; | |
36770 | else | |
36771 | right = middle - 1; | |
36772 | } | |
36773 | return 0; | |
36774 | } | |
36775 | void QFontEngine::doKerning(QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const | |
36776 | { | |
36777 | int numPairs = kerning_pairs.size(); | |
36778 | if(!numPairs) | |
36779 | return; | |
36780 | const KernPair *pairs = kerning_pairs.constData(); | |
36781 | if(flags & QTextEngine::DesignMetrics) { | |
36782 | for(int i = 0; i < glyphs->numGlyphs - 1; ++i) | |
36783 | glyphs->advances_x[i] += kerning(glyphs->glyphs[i], glyphs->glyphs[i+1] , pairs, numPairs); | |
36784 | } else { | |
36785 | for(int i = 0; i < glyphs->numGlyphs - 1; ++i) | |
36786 | glyphs->advances_x[i] += qRound(kerning(glyphs->glyphs[i], glyphs->glyphs[i+1] , pairs, numPairs)); | |
36787 | } | |
36788 | } | |
36789 | void QFontEngine::loadKerningPairs(QFixed scalingFactor) | |
36790 | { | |
36791 | kerning_pairs.clear(); | |
36792 | QByteArray tab = getSfntTable(( (((quint32)('k')) << 24) | (((quint32)('e')) << 16) | (((quint32)('r')) << 8) | ((quint32)('n')) )); | |
36793 | if (tab.isEmpty()) | |
36794 | return; | |
36795 | const uchar *table = reinterpret_cast<const uchar *>(tab.constData()); | |
36796 | unsigned short version = qFromBigEndian<quint16>(table); | |
36797 | if (version != 0) { | |
36798 | return; | |
36799 | } | |
36800 | unsigned short numTables = qFromBigEndian<quint16>(table + 2); | |
36801 | { | |
36802 | int offset = 4; | |
36803 | for(int i = 0; i < numTables; ++i) { | |
36804 | if (offset + 6 > tab.size()) { | |
36805 | goto end; | |
36806 | } | |
36807 | const uchar *header = table + offset; | |
36808 | ushort version = qFromBigEndian<quint16>(header); | |
36809 | ushort length = qFromBigEndian<quint16>(header+2); | |
36810 | ushort coverage = qFromBigEndian<quint16>(header+4); | |
36811 | if(version == 0 && coverage == 0x0001) { | |
36812 | if (offset + length > tab.size()) { | |
36813 | goto end; | |
36814 | } | |
36815 | const uchar *data = table + offset + 6; | |
36816 | ushort nPairs = qFromBigEndian<quint16>(data); | |
36817 | if(nPairs * 6 + 8 > length - 6) { | |
36818 | goto end; | |
36819 | } | |
36820 | int off = 8; | |
36821 | for(int i = 0; i < nPairs; ++i) { | |
36822 | QFontEngine::KernPair p; | |
36823 | p.left_right = (((uint)qFromBigEndian<quint16>(data+off)) << 16) + qFromBigEndian<quint16>(data+off+2); | |
36824 | p.adjust = QFixed(((int)(short)qFromBigEndian<quint16>(data+off+4))) / scalingFactor; | |
36825 | kerning_pairs.append(p); | |
36826 | off += 6; | |
36827 | } | |
36828 | } | |
36829 | offset += length; | |
36830 | } | |
36831 | } | |
36832 | end: | |
36833 | qSort(kerning_pairs); | |
36834 | } | |
36835 | int QFontEngine::glyphCount() const | |
36836 | { | |
36837 | QByteArray maxpTable = getSfntTable(( (((quint32)('m')) << 24) | (((quint32)('a')) << 16) | (((quint32)('x')) << 8) | ((quint32)('p')) )); | |
36838 | if (maxpTable.size() < 6) | |
36839 | return 0; | |
36840 | return qFromBigEndian<quint16>(reinterpret_cast<const uchar *>(maxpTable.constData() + 4)); | |
36841 | } | |
36842 | const uchar *QFontEngine::getCMap(const uchar *table, uint tableSize, bool *isSymbolFont, int *cmapSize) | |
36843 | { | |
36844 | const uchar *header = table; | |
36845 | if (tableSize < 4) | |
36846 | return 0; | |
36847 | const uchar *endPtr = table + tableSize; | |
36848 | if (qFromBigEndian<quint16>(header) != 0) | |
36849 | return 0; | |
36850 | unsigned short numTables = qFromBigEndian<quint16>(header + 2); | |
36851 | const uchar *maps = table + 4; | |
36852 | if (maps + 8 * numTables > endPtr) | |
36853 | return 0; | |
36854 | int tableToUse = -1; | |
36855 | int score = 0; | |
36856 | for (int n = 0; n < numTables; ++n) { | |
36857 | const quint16 platformId = qFromBigEndian<quint16>(maps + 8 * n); | |
36858 | const quint16 platformSpecificId = qFromBigEndian<quint16>(maps + 8 * n + 2); | |
36859 | switch (platformId) { | |
36860 | case 0: | |
36861 | if (score < 4 && | |
36862 | (platformSpecificId == 0 || | |
36863 | platformSpecificId == 2 || | |
36864 | platformSpecificId == 3)) { | |
36865 | tableToUse = n; | |
36866 | score = 4; | |
36867 | } else if (score < 3 && platformSpecificId == 1) { | |
36868 | tableToUse = n; | |
36869 | score = 3; | |
36870 | } | |
36871 | break; | |
36872 | case 1: | |
36873 | if (score < 2 && platformSpecificId == 0) { | |
36874 | tableToUse = n; | |
36875 | score = 2; | |
36876 | } | |
36877 | break; | |
36878 | case 3: | |
36879 | switch (platformSpecificId) { | |
36880 | case 0: | |
36881 | if (score < 1) { | |
36882 | tableToUse = n; | |
36883 | score = 1; | |
36884 | } | |
36885 | break; | |
36886 | case 1: | |
36887 | if (score < 5) { | |
36888 | tableToUse = n; | |
36889 | score = 5; | |
36890 | } | |
36891 | break; | |
36892 | case 0xa: | |
36893 | if (score < 6) { | |
36894 | tableToUse = n; | |
36895 | score = 6; | |
36896 | } | |
36897 | break; | |
36898 | default: | |
36899 | break; | |
36900 | } | |
36901 | default: | |
36902 | break; | |
36903 | } | |
36904 | } | |
36905 | if(tableToUse < 0) | |
36906 | return 0; | |
36907 | *isSymbolFont = (score == 1); | |
36908 | unsigned int unicode_table = qFromBigEndian<quint32>(maps + 8*tableToUse + 4); | |
36909 | if (!unicode_table || unicode_table + 8 > tableSize) | |
36910 | return 0; | |
36911 | header = table + unicode_table; | |
36912 | unsigned short format = qFromBigEndian<quint16>(header); | |
36913 | unsigned int length; | |
36914 | if(format < 8) | |
36915 | length = qFromBigEndian<quint16>(header + 2); | |
36916 | else | |
36917 | length = qFromBigEndian<quint32>(header + 4); | |
36918 | if (table + unicode_table + length > endPtr) | |
36919 | return 0; | |
36920 | *cmapSize = length; | |
36921 | return table + unicode_table; | |
36922 | } | |
36923 | quint32 QFontEngine::getTrueTypeGlyphIndex(const uchar *cmap, uint unicode) | |
36924 | { | |
36925 | unsigned short format = qFromBigEndian<quint16>(cmap); | |
36926 | if (format == 0) { | |
36927 | if (unicode < 256) | |
36928 | return (int) *(cmap+6+unicode); | |
36929 | } else if (format == 4) { | |
36930 | if(unicode >= 0xffff) | |
36931 | return 0; | |
36932 | quint16 segCountX2 = qFromBigEndian<quint16>(cmap + 6); | |
36933 | const unsigned char *ends = cmap + 14; | |
36934 | quint16 endIndex = 0; | |
36935 | int i = 0; | |
36936 | for (; i < segCountX2/2 && (endIndex = qFromBigEndian<quint16>(ends + 2*i)) < unicode; i++) {} | |
36937 | const unsigned char *idx = ends + segCountX2 + 2 + 2*i; | |
36938 | quint16 startIndex = qFromBigEndian<quint16>(idx); | |
36939 | if (startIndex > unicode) | |
36940 | return 0; | |
36941 | idx += segCountX2; | |
36942 | qint16 idDelta = (qint16)qFromBigEndian<quint16>(idx); | |
36943 | idx += segCountX2; | |
36944 | quint16 idRangeoffset_t = (quint16)qFromBigEndian<quint16>(idx); | |
36945 | quint16 glyphIndex; | |
36946 | if (idRangeoffset_t) { | |
36947 | quint16 id = qFromBigEndian<quint16>(idRangeoffset_t + 2*(unicode - startIndex) + idx); | |
36948 | if (id) | |
36949 | glyphIndex = (idDelta + id) % 0x10000; | |
36950 | else | |
36951 | glyphIndex = 0; | |
36952 | } else { | |
36953 | glyphIndex = (idDelta + unicode) % 0x10000; | |
36954 | } | |
36955 | return glyphIndex; | |
36956 | } else if (format == 6) { | |
36957 | quint16 tableSize = qFromBigEndian<quint16>(cmap + 2); | |
36958 | quint16 firstCode6 = qFromBigEndian<quint16>(cmap + 6); | |
36959 | if (unicode < firstCode6) | |
36960 | return 0; | |
36961 | quint16 entryCount6 = qFromBigEndian<quint16>(cmap + 8); | |
36962 | if (entryCount6 * 2 + 10 > tableSize) | |
36963 | return 0; | |
36964 | quint16 sentinel6 = firstCode6 + entryCount6; | |
36965 | if (unicode >= sentinel6) | |
36966 | return 0; | |
36967 | quint16 entryIndex6 = unicode - firstCode6; | |
36968 | return qFromBigEndian<quint16>(cmap + 10 + (entryIndex6 * 2)); | |
36969 | } else if (format == 12) { | |
36970 | quint32 nGroups = qFromBigEndian<quint32>(cmap + 12); | |
36971 | cmap += 16; | |
36972 | int left = 0, right = nGroups - 1; | |
36973 | while (left <= right) { | |
36974 | int middle = left + ( ( right - left ) >> 1 ); | |
36975 | quint32 startCharCode = qFromBigEndian<quint32>(cmap + 12*middle); | |
36976 | if(unicode < startCharCode) | |
36977 | right = middle - 1; | |
36978 | else { | |
36979 | quint32 endCharCode = qFromBigEndian<quint32>(cmap + 12*middle + 4); | |
36980 | if(unicode <= endCharCode) | |
36981 | return qFromBigEndian<quint32>(cmap + 12*middle + 8) + unicode - startCharCode; | |
36982 | left = middle + 1; | |
36983 | } | |
36984 | } | |
36985 | } else { | |
36986 | qDebug("cmap table of format %d not implemented", format); | |
36987 | } | |
36988 | return 0; | |
36989 | } | |
36990 | QFontEngineBox::QFontEngineBox(int size) | |
36991 | : _size(size) | |
36992 | { | |
36993 | cache_cost = sizeof(QFontEngineBox); | |
36994 | } | |
36995 | QFontEngineBox::~QFontEngineBox() | |
36996 | { | |
36997 | } | |
36998 | bool QFontEngineBox::stringToCMap(const QChar *, int len, QGlyphLayout *glyphs, int *nglyphs, QTextEngine::ShaperFlags) const | |
36999 | { | |
37000 | if (*nglyphs < len) { | |
37001 | *nglyphs = len; | |
37002 | return false; | |
37003 | } | |
37004 | for (int i = 0; i < len; i++) { | |
37005 | glyphs->glyphs[i] = 0; | |
37006 | glyphs->advances_x[i] = _size; | |
37007 | glyphs->advances_y[i] = 0; | |
37008 | } | |
37009 | *nglyphs = len; | |
37010 | glyphs->numGlyphs = len; | |
37011 | return true; | |
37012 | } | |
37013 | void QFontEngineBox::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags) const | |
37014 | { | |
37015 | for (int i = 0; i < glyphs->numGlyphs; i++) { | |
37016 | glyphs->advances_x[i] = _size; | |
37017 | glyphs->advances_y[i] = 0; | |
37018 | } | |
37019 | } | |
37020 | void QFontEngineBox::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, QPainterPath *path, QTextItem::RenderFlags flags) | |
37021 | { | |
37022 | if (!glyphs.numGlyphs) | |
37023 | return; | |
37024 | QVarLengthArray<QFixedPoint> positions; | |
37025 | QVarLengthArray<glyph_t> positioned_glyphs; | |
37026 | QTransform matrix; | |
37027 | matrix.translate(x, y - _size); | |
37028 | getGlyphPositions(glyphs, matrix, flags, positioned_glyphs, positions); | |
37029 | QSize s(_size - 3, _size - 3); | |
37030 | for (int k = 0; k < positions.size(); k++) | |
37031 | path->addRect(QRectF(positions[k].toPointF(), s)); | |
37032 | } | |
37033 | glyph_metrics_t QFontEngineBox::boundingBox(const QGlyphLayout &glyphs) | |
37034 | { | |
37035 | glyph_metrics_t overall; | |
37036 | overall.width = _size*glyphs.numGlyphs; | |
37037 | overall.height = _size; | |
37038 | overall.xoff = overall.width; | |
37039 | return overall; | |
37040 | } | |
37041 | void QFontEngineBox::draw(QPaintEngine *p, qreal x, qreal y, const QTextItemInt &ti) | |
37042 | { | |
37043 | if (!ti.glyphs.numGlyphs) | |
37044 | return; | |
37045 | QSize s(_size - 3, _size - 3); | |
37046 | QVarLengthArray<QFixedPoint> positions; | |
37047 | QVarLengthArray<glyph_t> glyphs; | |
37048 | QTransform matrix; | |
37049 | matrix.translate(x, y - _size); | |
37050 | ti.fontEngine->getGlyphPositions(ti.glyphs, matrix, ti.flags, glyphs, positions); | |
37051 | if (glyphs.size() == 0) | |
37052 | return; | |
37053 | QPainter *painter = p->painter(); | |
37054 | painter->save(); | |
37055 | painter->setBrush(Qt::NoBrush); | |
37056 | QPen pen = painter->pen(); | |
37057 | pen.setWidthF(lineThickness().toReal()); | |
37058 | painter->setPen(pen); | |
37059 | for (int k = 0; k < positions.size(); k++) | |
37060 | painter->drawRect(QRectF(positions[k].toPointF(), s)); | |
37061 | painter->restore(); | |
37062 | } | |
37063 | glyph_metrics_t QFontEngineBox::boundingBox(glyph_t) | |
37064 | { | |
37065 | return glyph_metrics_t(0, -_size, _size, _size, _size, 0); | |
37066 | } | |
37067 | QFixed QFontEngineBox::ascent() const | |
37068 | { | |
37069 | return _size; | |
37070 | } | |
37071 | QFixed QFontEngineBox::descent() const | |
37072 | { | |
37073 | return 0; | |
37074 | } | |
37075 | QFixed QFontEngineBox::leading() const | |
37076 | { | |
37077 | QFixed l = _size * QFixed::fromReal(qreal(0.15)); | |
37078 | return l.ceil(); | |
37079 | } | |
37080 | qreal QFontEngineBox::maxCharWidth() const | |
37081 | { | |
37082 | return _size; | |
37083 | } | |
37084 | const char *QFontEngineBox::name() const | |
37085 | { | |
37086 | return "null"; | |
37087 | } | |
37088 | bool QFontEngineBox::canRender(const QChar *, int) | |
37089 | { | |
37090 | return true; | |
37091 | } | |
37092 | QFontEngine::Type QFontEngineBox::type() const | |
37093 | { | |
37094 | return Box; | |
37095 | } | |
37096 | QImage QFontEngineBox::alphaMapForGlyph(glyph_t) | |
37097 | { | |
37098 | QImage image(_size, _size, QImage::Format_Indexed8); | |
37099 | QVector<QRgb> colors(256); | |
37100 | for (int i=0; i<256; ++i) | |
37101 | colors[i] = qRgba(0, 0, 0, i); | |
37102 | image.setColorTable(colors); | |
37103 | image.fill(0); | |
37104 | for (int i=2; i <= _size-3; ++i) { | |
37105 | image.setPixel(i, 2, 255); | |
37106 | image.setPixel(i, _size-3, 255); | |
37107 | image.setPixel(2, i, 255); | |
37108 | image.setPixel(_size-3, i, 255); | |
37109 | } | |
37110 | return image; | |
37111 | } | |
37112 | static inline uchar highByte(glyph_t glyph) | |
37113 | { return glyph >> 24; } | |
37114 | static inline glyph_t stripped(glyph_t glyph) | |
37115 | { return glyph & 0x00ffffff; } | |
37116 | QFontEngineMulti::QFontEngineMulti(int engineCount) | |
37117 | { | |
37118 | engines.fill(0, engineCount); | |
37119 | cache_cost = 0; | |
37120 | } | |
37121 | QFontEngineMulti::~QFontEngineMulti() | |
37122 | { | |
37123 | for (int i = 0; i < engines.size(); ++i) { | |
37124 | QFontEngine *fontEngine = engines.at(i); | |
37125 | if (fontEngine) { | |
37126 | fontEngine->ref.deref(); | |
37127 | if (fontEngine->cache_count == 0 && fontEngine->ref == 0) | |
37128 | delete fontEngine; | |
37129 | } | |
37130 | } | |
37131 | } | |
37132 | bool QFontEngineMulti::stringToCMap(const QChar *str, int len, | |
37133 | QGlyphLayout *glyphs, int *nglyphs, | |
37134 | QTextEngine::ShaperFlags flags) const | |
37135 | { | |
37136 | int ng = *nglyphs; | |
37137 | if (!engine(0)->stringToCMap(str, len, glyphs, &ng, flags)) | |
37138 | return false; | |
37139 | int glyph_pos = 0; | |
37140 | for (int i = 0; i < len; ++i) { | |
37141 | bool surrogate = (str[i].unicode() >= 0xd800 && str[i].unicode() < 0xdc00 && i < len-1 | |
37142 | && str[i+1].unicode() >= 0xdc00 && str[i+1].unicode() < 0xe000); | |
37143 | if (glyphs->glyphs[glyph_pos] == 0) { | |
37144 | QGlyphLayoutInstance tmp = glyphs->instance(glyph_pos); | |
37145 | for (int x = 1; x < engines.size(); ++x) { | |
37146 | QFontEngine *engine = engines.at(x); | |
37147 | if (!engine) { | |
37148 | const_cast<QFontEngineMulti *>(this)->loadEngine(x); | |
37149 | engine = engines.at(x); | |
37150 | } | |
37151 | qt_noop(); | |
37152 | if (engine->type() == Box) | |
37153 | continue; | |
37154 | glyphs->advances_x[glyph_pos] = glyphs->advances_y[glyph_pos] = 0; | |
37155 | glyphs->offsets[glyph_pos] = QFixedPoint(); | |
37156 | int num = 2; | |
37157 | QGlyphLayout offs = glyphs->mid(glyph_pos, num); | |
37158 | engine->stringToCMap(str + i, surrogate ? 2 : 1, &offs, &num, flags); | |
37159 | qt_noop(); | |
37160 | if (glyphs->glyphs[glyph_pos]) { | |
37161 | glyphs->glyphs[glyph_pos] |= (x << 24); | |
37162 | break; | |
37163 | } | |
37164 | } | |
37165 | if (!glyphs->glyphs[glyph_pos]) { | |
37166 | glyphs->setInstance(glyph_pos, tmp); | |
37167 | } | |
37168 | } | |
37169 | if (surrogate) | |
37170 | ++i; | |
37171 | ++glyph_pos; | |
37172 | } | |
37173 | *nglyphs = ng; | |
37174 | glyphs->numGlyphs = ng; | |
37175 | return true; | |
37176 | } | |
37177 | glyph_metrics_t QFontEngineMulti::boundingBox(const QGlyphLayout &glyphs) | |
37178 | { | |
37179 | if (glyphs.numGlyphs <= 0) | |
37180 | return glyph_metrics_t(); | |
37181 | glyph_metrics_t overall; | |
37182 | int which = highByte(glyphs.glyphs[0]); | |
37183 | int start = 0; | |
37184 | int end, i; | |
37185 | for (end = 0; end < glyphs.numGlyphs; ++end) { | |
37186 | const int e = highByte(glyphs.glyphs[end]); | |
37187 | if (e == which) | |
37188 | continue; | |
37189 | for (i = start; i < end; ++i) | |
37190 | glyphs.glyphs[i] = stripped(glyphs.glyphs[i]); | |
37191 | const glyph_metrics_t gm = engine(which)->boundingBox(glyphs.mid(start, end - start)); | |
37192 | overall.x = qMin(overall.x, gm.x); | |
37193 | overall.y = qMin(overall.y, gm.y); | |
37194 | overall.width = overall.xoff + gm.width; | |
37195 | overall.height = qMax(overall.height + overall.y, gm.height + gm.y) - | |
37196 | qMin(overall.y, gm.y); | |
37197 | overall.xoff += gm.xoff; | |
37198 | overall.yoff += gm.yoff; | |
37199 | const int hi = which << 24; | |
37200 | for (i = start; i < end; ++i) | |
37201 | glyphs.glyphs[i] = hi | glyphs.glyphs[i]; | |
37202 | start = end; | |
37203 | which = e; | |
37204 | } | |
37205 | for (i = start; i < end; ++i) | |
37206 | glyphs.glyphs[i] = stripped(glyphs.glyphs[i]); | |
37207 | const glyph_metrics_t gm = engine(which)->boundingBox(glyphs.mid(start, end - start)); | |
37208 | overall.x = qMin(overall.x, gm.x); | |
37209 | overall.y = qMin(overall.y, gm.y); | |
37210 | overall.width = overall.xoff + gm.width; | |
37211 | overall.height = qMax(overall.height + overall.y, gm.height + gm.y) - | |
37212 | qMin(overall.y, gm.y); | |
37213 | overall.xoff += gm.xoff; | |
37214 | overall.yoff += gm.yoff; | |
37215 | const int hi = which << 24; | |
37216 | for (i = start; i < end; ++i) | |
37217 | glyphs.glyphs[i] = hi | glyphs.glyphs[i]; | |
37218 | return overall; | |
37219 | } | |
37220 | void QFontEngineMulti::addOutlineToPath(qreal x, qreal y, const QGlyphLayout &glyphs, | |
37221 | QPainterPath *path, QTextItem::RenderFlags flags) | |
37222 | { | |
37223 | if (glyphs.numGlyphs <= 0) | |
37224 | return; | |
37225 | int which = highByte(glyphs.glyphs[0]); | |
37226 | int start = 0; | |
37227 | int end, i; | |
37228 | if (flags & QTextItem::RightToLeft) { | |
37229 | for (int gl = 0; gl < glyphs.numGlyphs; gl++) { | |
37230 | x += glyphs.advances_x[gl].toReal(); | |
37231 | y += glyphs.advances_y[gl].toReal(); | |
37232 | } | |
37233 | } | |
37234 | for (end = 0; end < glyphs.numGlyphs; ++end) { | |
37235 | const int e = highByte(glyphs.glyphs[end]); | |
37236 | if (e == which) | |
37237 | continue; | |
37238 | if (flags & QTextItem::RightToLeft) { | |
37239 | for (i = start; i < end; ++i) { | |
37240 | x -= glyphs.advances_x[i].toReal(); | |
37241 | y -= glyphs.advances_y[i].toReal(); | |
37242 | } | |
37243 | } | |
37244 | for (i = start; i < end; ++i) | |
37245 | glyphs.glyphs[i] = stripped(glyphs.glyphs[i]); | |
37246 | engine(which)->addOutlineToPath(x, y, glyphs.mid(start, end - start), path, flags); | |
37247 | const int hi = which << 24; | |
37248 | for (i = start; i < end; ++i) | |
37249 | glyphs.glyphs[i] = hi | glyphs.glyphs[i]; | |
37250 | if (!(flags & QTextItem::RightToLeft)) { | |
37251 | for (i = start; i < end; ++i) { | |
37252 | x += glyphs.advances_x[i].toReal(); | |
37253 | y += glyphs.advances_y[i].toReal(); | |
37254 | } | |
37255 | } | |
37256 | start = end; | |
37257 | which = e; | |
37258 | } | |
37259 | if (flags & QTextItem::RightToLeft) { | |
37260 | for (i = start; i < end; ++i) { | |
37261 | x -= glyphs.advances_x[i].toReal(); | |
37262 | y -= glyphs.advances_y[i].toReal(); | |
37263 | } | |
37264 | } | |
37265 | for (i = start; i < end; ++i) | |
37266 | glyphs.glyphs[i] = stripped(glyphs.glyphs[i]); | |
37267 | engine(which)->addOutlineToPath(x, y, glyphs.mid(start, end - start), path, flags); | |
37268 | const int hi = which << 24; | |
37269 | for (i = start; i < end; ++i) | |
37270 | glyphs.glyphs[i] = hi | glyphs.glyphs[i]; | |
37271 | } | |
37272 | void QFontEngineMulti::recalcAdvances(QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const | |
37273 | { | |
37274 | if (glyphs->numGlyphs <= 0) | |
37275 | return; | |
37276 | int which = highByte(glyphs->glyphs[0]); | |
37277 | int start = 0; | |
37278 | int end, i; | |
37279 | for (end = 0; end < glyphs->numGlyphs; ++end) { | |
37280 | const int e = highByte(glyphs->glyphs[end]); | |
37281 | if (e == which) | |
37282 | continue; | |
37283 | for (i = start; i < end; ++i) | |
37284 | glyphs->glyphs[i] = stripped(glyphs->glyphs[i]); | |
37285 | QGlyphLayout offs = glyphs->mid(start, end - start); | |
37286 | engine(which)->recalcAdvances(&offs, flags); | |
37287 | const int hi = which << 24; | |
37288 | for (i = start; i < end; ++i) | |
37289 | glyphs->glyphs[i] = hi | glyphs->glyphs[i]; | |
37290 | start = end; | |
37291 | which = e; | |
37292 | } | |
37293 | for (i = start; i < end; ++i) | |
37294 | glyphs->glyphs[i] = stripped(glyphs->glyphs[i]); | |
37295 | QGlyphLayout offs = glyphs->mid(start, end - start); | |
37296 | engine(which)->recalcAdvances(&offs, flags); | |
37297 | const int hi = which << 24; | |
37298 | for (i = start; i < end; ++i) | |
37299 | glyphs->glyphs[i] = hi | glyphs->glyphs[i]; | |
37300 | } | |
37301 | void QFontEngineMulti::doKerning(QGlyphLayout *glyphs, QTextEngine::ShaperFlags flags) const | |
37302 | { | |
37303 | if (glyphs->numGlyphs <= 0) | |
37304 | return; | |
37305 | int which = highByte(glyphs->glyphs[0]); | |
37306 | int start = 0; | |
37307 | int end, i; | |
37308 | for (end = 0; end < glyphs->numGlyphs; ++end) { | |
37309 | const int e = highByte(glyphs->glyphs[end]); | |
37310 | if (e == which) | |
37311 | continue; | |
37312 | for (i = start; i < end; ++i) | |
37313 | glyphs->glyphs[i] = stripped(glyphs->glyphs[i]); | |
37314 | QGlyphLayout offs = glyphs->mid(start, end - start); | |
37315 | engine(which)->doKerning(&offs, flags); | |
37316 | const int hi = which << 24; | |
37317 | for (i = start; i < end; ++i) | |
37318 | glyphs->glyphs[i] = hi | glyphs->glyphs[i]; | |
37319 | start = end; | |
37320 | which = e; | |
37321 | } | |
37322 | for (i = start; i < end; ++i) | |
37323 | glyphs->glyphs[i] = stripped(glyphs->glyphs[i]); | |
37324 | QGlyphLayout offs = glyphs->mid(start, end - start); | |
37325 | engine(which)->doKerning(&offs, flags); | |
37326 | const int hi = which << 24; | |
37327 | for (i = start; i < end; ++i) | |
37328 | glyphs->glyphs[i] = hi | glyphs->glyphs[i]; | |
37329 | } | |
37330 | glyph_metrics_t QFontEngineMulti::boundingBox(glyph_t glyph) | |
37331 | { | |
37332 | const int which = highByte(glyph); | |
37333 | qt_noop(); | |
37334 | return engine(which)->boundingBox(stripped(glyph)); | |
37335 | } | |
37336 | QFixed QFontEngineMulti::ascent() const | |
37337 | { return engine(0)->ascent(); } | |
37338 | QFixed QFontEngineMulti::descent() const | |
37339 | { return engine(0)->descent(); } | |
37340 | QFixed QFontEngineMulti::leading() const | |
37341 | { | |
37342 | return engine(0)->leading(); | |
37343 | } | |
37344 | QFixed QFontEngineMulti::xHeight() const | |
37345 | { | |
37346 | return engine(0)->xHeight(); | |
37347 | } | |
37348 | QFixed QFontEngineMulti::averageCharWidth() const | |
37349 | { | |
37350 | return engine(0)->averageCharWidth(); | |
37351 | } | |
37352 | QFixed QFontEngineMulti::lineThickness() const | |
37353 | { | |
37354 | return engine(0)->lineThickness(); | |
37355 | } | |
37356 | QFixed QFontEngineMulti::underlinePosition() const | |
37357 | { | |
37358 | return engine(0)->underlinePosition(); | |
37359 | } | |
37360 | qreal QFontEngineMulti::maxCharWidth() const | |
37361 | { | |
37362 | return engine(0)->maxCharWidth(); | |
37363 | } | |
37364 | qreal QFontEngineMulti::minLeftBearing() const | |
37365 | { | |
37366 | return engine(0)->minLeftBearing(); | |
37367 | } | |
37368 | qreal QFontEngineMulti::minRightBearing() const | |
37369 | { | |
37370 | return engine(0)->minRightBearing(); | |
37371 | } | |
37372 | bool QFontEngineMulti::canRender(const QChar *string, int len) | |
37373 | { | |
37374 | if (engine(0)->canRender(string, len)) | |
37375 | return true; | |
37376 | QVarLengthGlyphLayoutArray glyphs(len); | |
37377 | int nglyphs = len; | |
37378 | if (stringToCMap(string, len, &glyphs, &nglyphs, QTextEngine::GlyphIndicesOnly) == false) { | |
37379 | glyphs.resize(nglyphs); | |
37380 | stringToCMap(string, len, &glyphs, &nglyphs, QTextEngine::GlyphIndicesOnly); | |
37381 | } | |
37382 | bool allExist = true; | |
37383 | for (int i = 0; i < nglyphs; i++) { | |
37384 | if (!glyphs.glyphs[i]) { | |
37385 | allExist = false; | |
37386 | break; | |
37387 | } | |
37388 | } | |
37389 | return allExist; | |
37390 | } | |
37391 | QFontEngine *QFontEngineMulti::engine(int at) const | |
37392 | { | |
37393 | qt_noop(); | |
37394 | return engines.at(at); | |
37395 | } | |
37396 | QImage QFontEngineMulti::alphaMapForGlyph(glyph_t) | |
37397 | { | |
37398 | qt_noop(); | |
37399 | return QImage(); | |
37400 | } |