##// END OF EJS Templates
GIT_REPOSITORIES » LPP » PythonQt
RSS

Clone from https://github.com/Orochimarufan/PythonQt.git

generate extra wrappers for virtual slots to allow correct deriving via Python and to avoid recursion...
florianlink -
r175:7bc6abba6c12
parent child
Show More
Show file before | Show file after | Hide comments
@@ -1,946 +1,946
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
4 4 ** All rights reserved.
5 5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 6 **
7 7 ** This file is part of the Qt Script Generator project on Qt Labs.
8 8 **
9 9 ** $QT_BEGIN_LICENSE:LGPL$
10 10 ** No Commercial Usage
11 11 ** This file contains pre-release code and may not be distributed.
12 12 ** You may use this file in accordance with the terms and conditions
13 13 ** contained in the Technology Preview License Agreement accompanying
14 14 ** this package.
15 15 **
16 16 ** GNU Lesser General Public License Usage
17 17 ** Alternatively, this file may be used under the terms of the GNU Lesser
18 18 ** General Public License version 2.1 as published by the Free Software
19 19 ** Foundation and appearing in the file LICENSE.LGPL included in the
20 20 ** packaging of this file. Please review the following information to
21 21 ** ensure the GNU Lesser General Public License version 2.1 requirements
22 22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23 23 **
24 24 ** In addition, as a special exception, Nokia gives you certain additional
25 25 ** rights. These rights are described in the Nokia Qt LGPL Exception
26 26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27 27 **
28 28 ** If you have questions regarding the use of this file, please contact
29 29 ** Nokia at qt-info@nokia.com.
30 30 **
31 31 **
32 32 **
33 33 **
34 34 **
35 35 **
36 36 **
37 37 **
38 38 ** $QT_END_LICENSE$
39 39 **
40 40 ****************************************************************************/
41 41
42 42 #ifndef ABSTRACTMETALANG_H
43 43 #define ABSTRACTMETALANG_H
44 44
45 45 #include "codemodel.h"
46 46
47 47 #include "typesystem.h"
48 48
49 49 #include <QSet>
50 50 #include <QStringList>
51 51 #include <QTextStream>
52 52
53 53
54 54 class AbstractMeta;
55 55 class AbstractMetaClass;
56 56 class AbstractMetaField;
57 57 class AbstractMetaFunction;
58 58 class AbstractMetaType;
59 59 class AbstractMetaVariable;
60 60 class AbstractMetaArgument;
61 61 class AbstractMetaEnumValue;
62 62 class AbstractMetaEnum;
63 63 class QPropertySpec;
64 64
65 65 typedef QList<AbstractMetaField *> AbstractMetaFieldList;
66 66 typedef QList<AbstractMetaArgument *> AbstractMetaArgumentList;
67 67 typedef QList<AbstractMetaFunction *> AbstractMetaFunctionList;
68 68 class AbstractMetaClassList : public QList<AbstractMetaClass *>
69 69 {
70 70 public:
71 71 AbstractMetaClass *findClass(const QString &name) const;
72 72 AbstractMetaEnumValue *findEnumValue(const QString &string) const;
73 73 AbstractMetaEnum *findEnum(const EnumTypeEntry *entry) const;
74 74
75 75 };
76 76
77 77
78 78
79 79 class AbstractMetaAttributes
80 80 {
81 81 public:
82 82 AbstractMetaAttributes() : m_attributes(0) { };
83 83
84 84 enum Attribute {
85 85 None = 0x00000000,
86 86
87 87 Private = 0x00000001,
88 88 Protected = 0x00000002,
89 89 Public = 0x00000004,
90 90 Friendly = 0x00000008,
91 91 Visibility = 0x0000000f,
92 92
93 93 Native = 0x00000010,
94 94 Abstract = 0x00000020,
95 95 Static = 0x00000040,
96 96
97 97 FinalInTargetLang = 0x00000080,
98 98 FinalInCpp = 0x00000100,
99 99 ForceShellImplementation = 0x00000200,
100 100
101 101 GetterFunction = 0x00000400,
102 102 SetterFunction = 0x00000800,
103 103
104 104 FinalOverload = 0x00001000,
105 105 InterfaceFunction = 0x00002000,
106 106
107 107 PropertyReader = 0x00004000,
108 108 PropertyWriter = 0x00008000,
109 109 PropertyResetter = 0x00010000,
110 110
111 111 Fake = 0x00020000,
112 112
113 113 Invokable = 0x00040000,
114 114
115 115 Final = FinalInTargetLang | FinalInCpp
116 116 };
117 117
118 118 uint attributes() const { return m_attributes; }
119 119 void setAttributes(uint attributes) { m_attributes = attributes; }
120 120
121 121 uint originalAttributes() const { return m_originalAttributes; }
122 122 void setOriginalAttributes(uint attributes) { m_originalAttributes = attributes; }
123 123
124 124 uint visibility() const { return m_attributes & Visibility; }
125 125 void setVisibility(uint visi) { m_attributes = (m_attributes & ~Visibility) | visi; }
126 126
127 127 void operator+=(Attribute attribute) { m_attributes |= attribute; }
128 128 void operator-=(Attribute attribute) { m_attributes &= ~attribute; }
129 129
130 130 bool isNative() const { return m_attributes & Native; }
131 131 bool isFinal() const { return (m_attributes & Final) == Final; }
132 132 bool isFinalInTargetLang() const { return m_attributes & FinalInTargetLang; }
133 133 bool isFinalInCpp() const { return m_attributes & FinalInCpp; }
134 134 bool isAbstract() const { return m_attributes & Abstract; }
135 135 bool isStatic() const { return m_attributes & Static; }
136 136 bool isForcedShellImplementation() const { return m_attributes & ForceShellImplementation; }
137 137 bool isInterfaceFunction() const { return m_attributes & InterfaceFunction; }
138 138 bool isFinalOverload() const { return m_attributes & FinalOverload; }
139 139 bool isInvokable() const { return m_attributes & Invokable; }
140 140
141 141 bool isPropertyReader() const { return m_attributes & PropertyReader; }
142 142 bool isPropertyWriter() const { return m_attributes & PropertyWriter; }
143 143 bool isPropertyResetter() const { return m_attributes & PropertyResetter; }
144 144
145 145 bool isPrivate() const { return m_attributes & Private; }
146 146 bool isProtected() const { return m_attributes & Protected; }
147 147 bool isPublic() const { return m_attributes & Public; }
148 148 bool isFriendly() const { return m_attributes & Friendly; }
149 149
150 150 bool wasPrivate() const { return m_originalAttributes & Private; }
151 151 bool wasProtected() const { return m_originalAttributes & Protected; }
152 152 bool wasPublic() const { return m_originalAttributes & Public; }
153 153 bool wasFriendly() const { return m_originalAttributes & Friendly; }
154 154
155 155 private:
156 156 uint m_attributes;
157 157 uint m_originalAttributes;
158 158 };
159 159
160 160
161 161 class AbstractMetaType
162 162 {
163 163 public:
164 164 enum TypeUsagePattern {
165 165 InvalidPattern,
166 166 PrimitivePattern,
167 167 FlagsPattern,
168 168 EnumPattern,
169 169 ValuePattern,
170 170 StringPattern,
171 171 CharPattern,
172 172 ObjectPattern,
173 173 QObjectPattern,
174 174 NativePointerPattern,
175 175 ContainerPattern,
176 176 VariantPattern,
177 177 JObjectWrapperPattern,
178 178 ArrayPattern,
179 179 ThreadPattern
180 180 };
181 181
182 182 AbstractMetaType() :
183 183 m_type_entry(0),
184 184 m_array_element_count(0),
185 185 m_array_element_type(0),
186 186 m_original_template_type(0),
187 187 m_pattern(InvalidPattern),
188 188 m_constant(false),
189 189 m_reference(false),
190 190 m_cpp_instantiation(true),
191 191 m_indirections(0),
192 192 m_reserved(0)
193 193 {
194 194 }
195 195
196 196 QString package() const { return m_type_entry->javaPackage(); }
197 197 QString name() const { return m_type_entry->targetLangName(); }
198 198 QString fullName() const { return m_type_entry->qualifiedTargetLangName(); }
199 199
200 200 void setTypeUsagePattern(TypeUsagePattern pattern) { m_pattern = pattern; }
201 201 TypeUsagePattern typeUsagePattern() const { return m_pattern; }
202 202
203 203 // true when use pattern is container
204 204 bool hasInstantiations() const { return !m_instantiations.isEmpty(); }
205 205 void addInstantiation(AbstractMetaType *inst) { m_instantiations << inst; }
206 206 void setInstantiations(const QList<AbstractMetaType *> &insts) { m_instantiations = insts; }
207 207 QList<AbstractMetaType *> instantiations() const { return m_instantiations; }
208 208 void setInstantiationInCpp(bool incpp) { m_cpp_instantiation = incpp; }
209 209 bool hasInstantiationInCpp() const { return hasInstantiations() && m_cpp_instantiation; }
210 210
211 211 QString minimalSignature() const;
212 212
213 213 // true when the type is a QtJambiObject subclass
214 214 bool hasNativeId() const;
215 215
216 216 // returns true if the typs is used as a non complex primitive, no & or *'s
217 217 bool isPrimitive() const { return m_pattern == PrimitivePattern; }
218 218
219 219 // returns true if the type is used as an enum
220 220 bool isEnum() const { return m_pattern == EnumPattern; }
221 221
222 222 // returns true if the type is used as a QObject *
223 223 bool isQObject() const { return m_pattern == QObjectPattern; }
224 224
225 225 // returns true if the type is used as an object, e.g. Xxx *
226 226 bool isObject() const { return m_pattern == ObjectPattern; }
227 227
228 228 // returns true if the type is used as an array, e.g. Xxx[42]
229 229 bool isArray() const { return m_pattern == ArrayPattern; }
230 230
231 231 // returns true if the type is used as a value type (X or const X &)
232 232 bool isValue() const { return m_pattern == ValuePattern; }
233 233
234 234 // returns true for more complex types...
235 235 bool isNativePointer() const { return m_pattern == NativePointerPattern; }
236 236
237 237 // returns true if the type was originally a QString or const QString & or equivalent for QLatin1String
238 238 bool isTargetLangString() const { return m_pattern == StringPattern; }
239 239
240 240 // returns true if the type was originally a QChar or const QChar &
241 241 bool isTargetLangChar() const { return m_pattern == CharPattern; }
242 242
243 243 // return true if the type was originally a QVariant or const QVariant &
244 244 bool isVariant() const { return m_pattern == VariantPattern; }
245 245
246 246 // return true if the type was originally a JObjectWrapper or const JObjectWrapper &
247 247 bool isJObjectWrapper() const { return m_pattern == JObjectWrapperPattern; }
248 248
249 249 // returns true if the type was used as a container
250 250 bool isContainer() const { return m_pattern == ContainerPattern; }
251 251
252 252 // returns true if the type was used as a flag
253 253 bool isFlags() const { return m_pattern == FlagsPattern; }
254 254
255 255 // returns true if the type was used as a thread
256 256 bool isThread() const { return m_pattern == ThreadPattern; }
257 257
258 258 bool isConstant() const { return m_constant; }
259 259 void setConstant(bool constant) { m_constant = constant; }
260 260
261 261 bool isReference() const { return m_reference; }
262 262 void setReference(bool ref) { m_reference = ref; }
263 263
264 264 // Returns true if the type is to be implemented using Java enums, e.g. not plain ints.
265 265 bool isTargetLangEnum() const { return isEnum() && !((EnumTypeEntry *) typeEntry())->forceInteger(); }
266 266 bool isIntegerEnum() const { return isEnum() && !isTargetLangEnum(); }
267 267
268 268 // Returns true if the type is to be implemented using Java QFlags, e.g. not plain ints.
269 269 bool isTargetLangFlags() const {
270 270 return isFlags() && !((FlagsTypeEntry *) typeEntry())->forceInteger(); }
271 271 bool isIntegerFlags() const { return isFlags() && !isTargetLangFlags(); }
272 272
273 273 int actualIndirections() const { return m_indirections + (isReference() ? 1 : 0); }
274 274 int indirections() const { return m_indirections; }
275 275 void setIndirections(int indirections) { m_indirections = indirections; }
276 276
277 277 void setArrayElementCount(int n) { m_array_element_count = n; }
278 278 int arrayElementCount() const { return m_array_element_count; }
279 279
280 280 AbstractMetaType *arrayElementType() const { return m_array_element_type; }
281 281 void setArrayElementType(AbstractMetaType *t) { m_array_element_type = t; }
282 282
283 283 QString cppSignature() const;
284 284
285 285 AbstractMetaType *copy() const;
286 286
287 287 const TypeEntry *typeEntry() const { return m_type_entry; }
288 288 void setTypeEntry(const TypeEntry *type) { m_type_entry = type; }
289 289
290 290 void setOriginalTypeDescription(const QString &otd) { m_original_type_description = otd; }
291 291 QString originalTypeDescription() const { return m_original_type_description; }
292 292
293 293 void setOriginalTemplateType(const AbstractMetaType *type) { m_original_template_type = type; }
294 294 const AbstractMetaType *originalTemplateType() const { return m_original_template_type; }
295 295
296 296 private:
297 297 const TypeEntry *m_type_entry;
298 298 QList <AbstractMetaType *> m_instantiations;
299 299 QString m_package;
300 300 QString m_original_type_description;
301 301
302 302 int m_array_element_count;
303 303 AbstractMetaType *m_array_element_type;
304 304 const AbstractMetaType *m_original_template_type;
305 305
306 306 TypeUsagePattern m_pattern;
307 307 uint m_constant : 1;
308 308 uint m_reference : 1;
309 309 uint m_cpp_instantiation : 1;
310 310 int m_indirections : 4;
311 311 uint m_reserved : 25; // unused
312 312 };
313 313
314 314 class AbstractMetaVariable
315 315 {
316 316 public:
317 317 AbstractMetaVariable() : m_type(0) { }
318 318
319 319 AbstractMetaType *type() const { return m_type; }
320 320 void setType(AbstractMetaType *type) { m_type = type; }
321 321
322 322 QString name() const { return m_name; }
323 323 void setName(const QString &name) { m_name = name; }
324 324
325 325 private:
326 326 QString m_name;
327 327 AbstractMetaType *m_type;
328 328 };
329 329
330 330
331 331
332 332 class AbstractMetaArgument : public AbstractMetaVariable
333 333 {
334 334 public:
335 335 AbstractMetaArgument() : m_argument_index(0) { };
336 336
337 337 QString defaultValueExpression() const { return m_expression; }
338 338 void setDefaultValueExpression(const QString &expr) { m_expression = expr; }
339 339
340 340 QString originalDefaultValueExpression() const { return m_original_expression; }
341 341 void setOriginalDefaultValueExpression(const QString &expr) { m_original_expression = expr; }
342 342
343 343 QString toString() const { return type()->name() + " " + AbstractMetaVariable::name() +
344 344 (m_expression.isEmpty() ? "" : " = " + m_expression); }
345 345
346 346 int argumentIndex() const { return m_argument_index; }
347 347 void setArgumentIndex(int argIndex) { m_argument_index = argIndex; }
348 348
349 349 QString argumentName() const;
350 350 QString indexedName() const;
351 351
352 352 AbstractMetaArgument *copy() const;
353 353
354 354 private:
355 355 // Just to force people to call argumentName() And indexedName();
356 356 QString name() const;
357 357
358 358 QString m_expression;
359 359 QString m_original_expression;
360 360 int m_argument_index;
361 361 };
362 362
363 363
364 364 class AbstractMetaField : public AbstractMetaVariable, public AbstractMetaAttributes
365 365 {
366 366 public:
367 367 AbstractMetaField();
368 368 ~AbstractMetaField();
369 369
370 370 const AbstractMetaClass *enclosingClass() const { return m_class; }
371 371 void setEnclosingClass(const AbstractMetaClass *cls) { m_class = cls; }
372 372
373 373 const AbstractMetaFunction *getter() const;
374 374 const AbstractMetaFunction *setter() const;
375 375
376 376 FieldModificationList modifications() const;
377 377
378 378 AbstractMetaField *copy() const;
379 379
380 380 private:
381 381 mutable AbstractMetaFunction *m_getter;
382 382 mutable AbstractMetaFunction *m_setter;
383 383 const AbstractMetaClass *m_class;
384 384 };
385 385
386 386
387 387 class AbstractMetaFunction : public AbstractMetaAttributes
388 388 {
389 389 public:
390 390 enum FunctionType {
391 391 ConstructorFunction,
392 392 DestructorFunction,
393 393 NormalFunction,
394 394 SignalFunction,
395 395 EmptyFunction,
396 396 SlotFunction,
397 397 GlobalScopeFunction
398 398 };
399 399
400 400 enum CompareResult {
401 401 EqualName = 0x00000001,
402 402 EqualArguments = 0x00000002,
403 403 EqualAttributes = 0x00000004,
404 404 EqualImplementor = 0x00000008,
405 405 EqualReturnType = 0x00000010,
406 406 EqualDefaultValueOverload = 0x00000020,
407 407 EqualModifiedName = 0x00000040,
408 408
409 409 NameLessThan = 0x00001000,
410 410
411 411 PrettySimilar = EqualName | EqualArguments,
412 412 Equal = 0x0000001f,
413 413 NotEqual = 0x00001000
414 414 };
415 415
416 416 AbstractMetaFunction()
417 417 : m_function_type(NormalFunction),
418 418 m_type(0),
419 419 m_class(0),
420 420 m_implementing_class(0),
421 421 m_declaring_class(0),
422 422 m_interface_class(0),
423 423 m_property_spec(0),
424 424 m_constant(false),
425 425 m_invalid(false)
426 426 {
427 427 }
428 428
429 429 ~AbstractMetaFunction();
430 430
431 431 QString name() const { return m_name; }
432 432 void setName(const QString &name) { m_name = name; }
433 433
434 434 QString originalName() const { return m_original_name.isEmpty() ? name() : m_original_name; }
435 435 void setOriginalName(const QString &name) { m_original_name = name; }
436 436
437 437 QString modifiedName() const;
438 438
439 439 QString minimalSignature() const;
440 440 QStringList possibleIntrospectionCompatibleSignatures() const;
441 441
442 442 QString marshalledName() const;
443 443
444 444 // true if one or more of the arguments are of QtJambiObject subclasses
445 445 bool argumentsHaveNativeId() const
446 446 {
447 447 foreach (const AbstractMetaArgument *arg, m_arguments) {
448 448 if (arg->type()->hasNativeId())
449 449 return true;
450 450 }
451 451
452 452 return false;
453 453 }
454 454
455 455 bool isModifiedRemoved(int types = TypeSystem::All) const;
456 456
457 457 AbstractMetaType *type() const { return m_type; }
458 458 void setType(AbstractMetaType *type) { m_type = type; }
459 459
460 460 // The class that has this function as a member.
461 461 const AbstractMetaClass *ownerClass() const { return m_class; }
462 462 void setOwnerClass(const AbstractMetaClass *cls) { m_class = cls; }
463 463
464 464 // The first class in a hierarchy that declares the function
465 465 const AbstractMetaClass *declaringClass() const { return m_declaring_class; }
466 466 void setDeclaringClass(const AbstractMetaClass *cls) { m_declaring_class = cls; }
467 467
468 468 // The class that actually implements this function
469 469 const AbstractMetaClass *implementingClass() const { return m_implementing_class; }
470 470 void setImplementingClass(const AbstractMetaClass *cls) { m_implementing_class = cls; }
471 471
472 472 bool needsCallThrough() const;
473 473
474 474 AbstractMetaArgumentList arguments() const { return m_arguments; }
475 475 void setArguments(const AbstractMetaArgumentList &arguments) { m_arguments = arguments; }
476 476 void addArgument(AbstractMetaArgument *argument) { m_arguments << argument; }
477 477 int actualMinimumArgumentCount() const;
478 478
479 479 void setInvalid(bool on) { m_invalid = on; }
480 480 bool isInvalid() const { return m_invalid; }
481 481 bool isDeprecated() const;
482 482 bool isDestructor() const { return functionType() == DestructorFunction; }
483 483 bool isConstructor() const { return functionType() == ConstructorFunction; }
484 484 bool isNormal() const { return functionType() == NormalFunction || isSlot() || isInGlobalScope(); }
485 485 bool isInGlobalScope() const { return functionType() == GlobalScopeFunction; }
486 486 bool isSignal() const { return functionType() == SignalFunction; }
487 487 bool isSlot() const { return functionType() == SlotFunction; }
488 488 bool isEmptyFunction() const { return functionType() == EmptyFunction; }
489 489 FunctionType functionType() const { return m_function_type; }
490 490 void setFunctionType(FunctionType type) { m_function_type = type; }
491 491
492 bool isVirtual() { return !(isFinal() || isSignal() || isStatic()); }
492 bool isVirtual() const { return !(isFinal() || isSignal() || isStatic()); }
493 493
494 494 QStringList introspectionCompatibleSignatures(const QStringList &resolvedArguments = QStringList()) const;
495 495 QString signature() const;
496 496 QString targetLangSignature(bool minimal = false) const;
497 497 bool shouldReturnThisObject() const { return QLatin1String("this") == argumentReplaced(0); }
498 498 bool shouldIgnoreReturnValue() const { return QLatin1String("void") == argumentReplaced(0); }
499 499
500 500 bool isConstant() const { return m_constant; }
501 501 void setConstant(bool constant) { m_constant = constant; }
502 502
503 503 QString toString() const { return m_name; }
504 504
505 505 uint compareTo(const AbstractMetaFunction *other) const;
506 506
507 507 bool operator <(const AbstractMetaFunction &a) const;
508 508
509 509 AbstractMetaFunction *copy() const;
510 510
511 511 QString replacedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
512 512 bool removedDefaultExpression(const AbstractMetaClass *cls, int idx) const;
513 513 QString conversionRule(TypeSystem::Language language, int idx) const;
514 514 QList<ReferenceCount> referenceCounts(const AbstractMetaClass *cls, int idx = -2) const;
515 515
516 516 bool nullPointersDisabled(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
517 517 QString nullPointerDefaultValue(const AbstractMetaClass *cls = 0, int argument_idx = 0) const;
518 518
519 519 bool resetObjectAfterUse(int argument_idx) const;
520 520
521 521 // Returns whether garbage collection is disabled for the argument in any context
522 522 bool disabledGarbageCollection(const AbstractMetaClass *cls, int key) const;
523 523
524 524 // Returns the ownership rules for the given argument in the given context
525 525 TypeSystem::Ownership ownership(const AbstractMetaClass *cls, TypeSystem::Language language, int idx) const;
526 526
527 527 bool isVirtualSlot() const;
528 528
529 529 QString typeReplaced(int argument_index) const;
530 530 bool isRemovedFromAllLanguages(const AbstractMetaClass *) const;
531 531 bool isRemovedFrom(const AbstractMetaClass *, TypeSystem::Language language) const;
532 532 bool argumentRemoved(int) const;
533 533
534 534 QString argumentReplaced(int key) const;
535 535 bool needsSuppressUncheckedWarning() const;
536 536
537 537 bool hasModifications(const AbstractMetaClass *implementor) const;
538 538 FunctionModificationList modifications(const AbstractMetaClass *implementor) const;
539 539
540 540 // If this function stems from an interface, this returns the
541 541 // interface that declares it.
542 542 const AbstractMetaClass *interfaceClass() const { return m_interface_class; }
543 543 void setInterfaceClass(const AbstractMetaClass *cl) { m_interface_class = cl; }
544 544
545 545 void setPropertySpec(QPropertySpec *spec) { m_property_spec = spec; }
546 546 QPropertySpec *propertySpec() const { return m_property_spec; }
547 547
548 548 private:
549 549 QString m_name;
550 550 QString m_original_name;
551 551 mutable QString m_cached_minimal_signature;
552 552 mutable QString m_cached_modified_name;
553 553
554 554 FunctionType m_function_type;
555 555 AbstractMetaType *m_type;
556 556 const AbstractMetaClass *m_class;
557 557 const AbstractMetaClass *m_implementing_class;
558 558 const AbstractMetaClass *m_declaring_class;
559 559 const AbstractMetaClass *m_interface_class;
560 560 QPropertySpec *m_property_spec;
561 561 AbstractMetaArgumentList m_arguments;
562 562 uint m_constant : 1;
563 563 uint m_invalid : 1;
564 564 };
565 565
566 566
567 567 class AbstractMetaEnumValue
568 568 {
569 569 public:
570 570 AbstractMetaEnumValue()
571 571 : m_value_set(false), m_value(0)
572 572 {
573 573 }
574 574
575 575 int value() const { return m_value; }
576 576 void setValue(int value) { m_value_set = true; m_value = value; }
577 577
578 578 QString stringValue() const { return m_string_value; }
579 579 void setStringValue(const QString &v) { m_string_value = v; }
580 580
581 581 QString name() const { return m_name; }
582 582 void setName(const QString &name) { m_name = name; }
583 583
584 584 bool isValueSet() const { return m_value_set; }
585 585
586 586 private:
587 587 QString m_name;
588 588 QString m_string_value;
589 589
590 590 bool m_value_set;
591 591 int m_value;
592 592 };
593 593
594 594
595 595 class AbstractMetaEnumValueList : public QList<AbstractMetaEnumValue *>
596 596 {
597 597 public:
598 598 AbstractMetaEnumValue *find(const QString &name) const;
599 599 };
600 600
601 601 class AbstractMetaEnum : public AbstractMetaAttributes
602 602 {
603 603 public:
604 604 AbstractMetaEnum() : m_type_entry(0), m_class(0), m_has_qenums_declaration(false) {}
605 605
606 606 AbstractMetaEnumValueList values() const { return m_enum_values; }
607 607 void addEnumValue(AbstractMetaEnumValue *enumValue) { m_enum_values << enumValue; }
608 608
609 609 QString name() const { return m_type_entry->targetLangName(); }
610 610 QString qualifier() const { return m_type_entry->javaQualifier(); }
611 611 QString package() const { return m_type_entry->javaPackage(); }
612 612 QString fullName() const { return package() + "." + qualifier() + "." + name(); }
613 613
614 614 // Has the enum been declared inside a Q_ENUMS() macro in its enclosing class?
615 615 void setHasQEnumsDeclaration(bool on) { m_has_qenums_declaration = on; }
616 616 bool hasQEnumsDeclaration() const { return m_has_qenums_declaration; }
617 617
618 618 EnumTypeEntry *typeEntry() const { return m_type_entry; }
619 619 void setTypeEntry(EnumTypeEntry *entry) { m_type_entry = entry; }
620 620
621 621 AbstractMetaClass *enclosingClass() const { return m_class; }
622 622 void setEnclosingClass(AbstractMetaClass *c) { m_class = c; }
623 623
624 624 private:
625 625 AbstractMetaEnumValueList m_enum_values;
626 626 EnumTypeEntry *m_type_entry;
627 627 AbstractMetaClass *m_class;
628 628
629 629 uint m_has_qenums_declaration : 1;
630 630 uint m_reserved : 31;
631 631 };
632 632
633 633 typedef QList<AbstractMetaEnum *> AbstractMetaEnumList;
634 634
635 635 class AbstractMetaClass : public AbstractMetaAttributes
636 636 {
637 637 public:
638 638 enum FunctionQueryOption {
639 639 Constructors = 0x000001, // Only constructors
640 640 //Destructors = 0x000002, // Only destructors. Not included in class.
641 641 VirtualFunctions = 0x000004, // Only virtual functions (virtual in both TargetLang and C++)
642 642 FinalInTargetLangFunctions = 0x000008, // Only functions that are non-virtual in TargetLang
643 643 FinalInCppFunctions = 0x000010, // Only functions that are non-virtual in C++
644 644 ClassImplements = 0x000020, // Only functions implemented by the current class
645 645 Inconsistent = 0x000040, // Only inconsistent functions (inconsistent virtualness in TargetLang/C++)
646 646 StaticFunctions = 0x000080, // Only static functions
647 647 Signals = 0x000100, // Only signals
648 648 NormalFunctions = 0x000200, // Only functions that aren't signals
649 649 Visible = 0x000400, // Only public and protected functions
650 650 ForcedShellFunctions = 0x000800, // Only functions that are overridden to be implemented in the shell class
651 651 WasPublic = 0x001000, // Only functions that were originally public
652 652 WasProtected = 0x002000, // Only functions that were originally protected
653 653 NonStaticFunctions = 0x004000, // No static functions
654 654 Empty = 0x008000, // Empty overrides of abstract functions
655 655 Invisible = 0x010000, // Only private functions
656 656 VirtualInCppFunctions = 0x020000, // Only functions that are virtual in C++
657 657 NonEmptyFunctions = 0x040000, // Only functions with JNI implementations
658 658 VirtualInTargetLangFunctions = 0x080000, // Only functions which are virtual in TargetLang
659 659 AbstractFunctions = 0x100000, // Only abstract functions
660 660 WasVisible = 0x200000, // Only functions that were public or protected in the original code
661 661 NotRemovedFromTargetLang = 0x400000, // Only functions that have not been removed from TargetLang
662 662 NotRemovedFromShell = 0x800000, // Only functions that have not been removed from the shell class
663 663 VirtualSlots = 0x1000000 // Only functions that are set as virtual slots in the type system
664 664 };
665 665
666 666 AbstractMetaClass()
667 667 : m_namespace(false),
668 668 m_qobject(false),
669 669 m_has_virtuals(false),
670 670 m_has_nonpublic(false),
671 671 m_has_virtual_slots(false),
672 672 m_has_nonprivateconstructor(false),
673 673 m_functions_fixed(false),
674 674 m_has_public_destructor(true),
675 675 m_force_shell_class(false),
676 676 m_has_hash_function(false),
677 677 m_has_equals_operator(false),
678 678 m_has_clone_operator(false),
679 679 m_is_type_alias(false),
680 680 m_enclosing_class(0),
681 681 m_base_class(0),
682 682 m_template_base_class(0),
683 683 m_extracted_interface(0),
684 684 m_primary_interface_implementor(0),
685 685 m_type_entry(0),
686 686 m_qDebug_stream_function(0)
687 687 {
688 688 }
689 689
690 690 virtual ~AbstractMetaClass();
691 691
692 692 AbstractMetaClass *extractInterface();
693 693 void fixFunctions();
694 694
695 695 AbstractMetaFunctionList functions() const { return m_functions; }
696 696 void setFunctions(const AbstractMetaFunctionList &functions);
697 697 void addFunction(AbstractMetaFunction *function);
698 698 bool hasFunction(const AbstractMetaFunction *f) const;
699 699 bool hasFunction(const QString &str) const;
700 700 bool hasSignal(const AbstractMetaFunction *f) const;
701 701
702 702 bool hasConstructors() const;
703 703
704 704 void addDefaultConstructor();
705 705
706 706 bool hasNonPrivateConstructor() const { return m_has_nonprivateconstructor; }
707 707 void setHasNonPrivateConstructor(bool on) { m_has_nonprivateconstructor = on; }
708 708 bool hasPublicDestructor() const { return m_has_public_destructor; }
709 709 void setHasPublicDestructor(bool on) { m_has_public_destructor = on; }
710 710
711 711 AbstractMetaFunctionList queryFunctionsByName(const QString &name) const;
712 712 AbstractMetaFunctionList queryFunctions(uint query) const;
713 713 inline AbstractMetaFunctionList allVirtualFunctions() const;
714 714 inline AbstractMetaFunctionList allFinalFunctions() const;
715 715 AbstractMetaFunctionList functionsInTargetLang() const;
716 716 AbstractMetaFunctionList functionsInShellClass() const;
717 717 inline AbstractMetaFunctionList cppInconsistentFunctions() const;
718 718 inline AbstractMetaFunctionList cppSignalFunctions() const;
719 719 AbstractMetaFunctionList publicOverrideFunctions() const;
720 720 AbstractMetaFunctionList virtualOverrideFunctions() const;
721 721 AbstractMetaFunctionList virtualFunctions() const;
722 722 AbstractMetaFunctionList nonVirtualShellFunctions() const;
723 723
724 724 AbstractMetaFieldList fields() const { return m_fields; }
725 725 void setFields(const AbstractMetaFieldList &fields) { m_fields = fields; }
726 726 void addField(AbstractMetaField *field) { m_fields << field; }
727 727
728 728 AbstractMetaEnumList enums() const { return m_enums; }
729 729 void setEnums(const AbstractMetaEnumList &enums) { m_enums = enums; }
730 730 void addEnum(AbstractMetaEnum *e) { m_enums << e; }
731 731
732 732 AbstractMetaEnum *findEnum(const QString &enumName);
733 733 AbstractMetaEnum *findEnumForValue(const QString &enumName);
734 734 AbstractMetaEnumValue *findEnumValue(const QString &enumName, AbstractMetaEnum *meta_enum);
735 735
736 736 AbstractMetaClassList interfaces() const { return m_interfaces; }
737 737 void addInterface(AbstractMetaClass *interface);
738 738 void setInterfaces(const AbstractMetaClassList &interface);
739 739
740 740 QString fullName() const { return package() + "." + name(); }
741 741 QString name() const;
742 742
743 743 QString baseClassName() const { return m_base_class ? m_base_class->name() : QString(); }
744 744
745 745 AbstractMetaClass *baseClass() const { return m_base_class; }
746 746 void setBaseClass(AbstractMetaClass *base_class) { m_base_class = base_class; }
747 747
748 748 const AbstractMetaClass *enclosingClass() const { return m_enclosing_class; }
749 749 void setEnclosingClass(AbstractMetaClass *cl) { m_enclosing_class = cl; }
750 750
751 751 QString package() const { return m_type_entry->javaPackage(); }
752 752 bool isInterface() const { return m_type_entry->isInterface(); }
753 753 bool isNamespace() const { return m_type_entry->isNamespace(); }
754 754 bool isQObject() const { return m_type_entry->isQObject(); }
755 755 bool isQtNamespace() const { return isNamespace() && name() == "Qt"; }
756 756 QString qualifiedCppName() const { return m_type_entry->qualifiedCppName(); }
757 757
758 758 bool hasInconsistentFunctions() const;
759 759 bool hasSignals() const;
760 760 bool inheritsFrom(const AbstractMetaClass *other) const;
761 761
762 762 void setForceShellClass(bool on) { m_force_shell_class = on; }
763 763 bool generateShellClass() const;
764 764
765 765 bool hasVirtualSlots() const { return m_has_virtual_slots; }
766 766 bool hasVirtualFunctions() const { return !isFinal() && m_has_virtuals; }
767 767 bool hasProtectedFunctions() const;
768 768
769 769 QList<TypeEntry *> templateArguments() const { return m_template_args; }
770 770 void setTemplateArguments(const QList<TypeEntry *> &args) { m_template_args = args; }
771 771
772 772 bool hasFieldAccessors() const;
773 773
774 774 // only valid during metajavabuilder's run
775 775 QStringList baseClassNames() const { return m_base_class_names; }
776 776 void setBaseClassNames(const QStringList &names) { m_base_class_names = names; }
777 777
778 778 AbstractMetaClass *primaryInterfaceImplementor() const { return m_primary_interface_implementor; }
779 779 void setPrimaryInterfaceImplementor(AbstractMetaClass *cl) { m_primary_interface_implementor = cl; }
780 780
781 781 const ComplexTypeEntry *typeEntry() const { return m_type_entry; }
782 782 ComplexTypeEntry *typeEntry() { return m_type_entry; }
783 783 void setTypeEntry(ComplexTypeEntry *type) { m_type_entry = type; }
784 784
785 785 void setHasHashFunction(bool on) { m_has_hash_function = on; }
786 786 bool hasHashFunction() const { return m_has_hash_function; }
787 787
788 788 void setToStringCapability(FunctionModelItem fun) { m_qDebug_stream_function= fun; }
789 789 FunctionModelItem hasToStringCapability() const { return m_qDebug_stream_function; }
790 790
791 791 virtual bool hasDefaultToStringFunction() const;
792 792
793 793 void setHasEqualsOperator(bool on) { m_has_equals_operator = on; }
794 794 bool hasEqualsOperator() const { return m_has_equals_operator; }
795 795
796 796 void setHasCloneOperator(bool on) { m_has_clone_operator = on; }
797 797 bool hasCloneOperator() const { return m_has_clone_operator; }
798 798
799 799 bool hasDefaultIsNull() const;
800 800
801 801 void addPropertySpec(QPropertySpec *spec) { m_property_specs << spec; }
802 802 QList<QPropertySpec *> propertySpecs() const { return m_property_specs; }
803 803
804 804 QPropertySpec *propertySpecForRead(const QString &name) const;
805 805 QPropertySpec *propertySpecForWrite(const QString &name) const;
806 806 QPropertySpec *propertySpecForReset(const QString &name) const;
807 807
808 808 QList<ReferenceCount> referenceCounts() const;
809 809
810 810 void setEqualsFunctions(const AbstractMetaFunctionList &lst) { m_equals_functions = lst; }
811 811 AbstractMetaFunctionList equalsFunctions() const { return m_equals_functions; }
812 812
813 813 void setNotEqualsFunctions(const AbstractMetaFunctionList &lst) { m_nequals_functions = lst; }
814 814 AbstractMetaFunctionList notEqualsFunctions() const { return m_nequals_functions; }
815 815
816 816 void setLessThanFunctions(const AbstractMetaFunctionList &lst) { m_less_than_functions = lst; }
817 817 AbstractMetaFunctionList lessThanFunctions() const { return m_less_than_functions; }
818 818
819 819 void setGreaterThanFunctions(const AbstractMetaFunctionList &lst) { m_greater_than_functions = lst; }
820 820 AbstractMetaFunctionList greaterThanFunctions() const { return m_greater_than_functions; }
821 821
822 822 void setLessThanEqFunctions(const AbstractMetaFunctionList &lst) { m_less_than_eq_functions = lst; }
823 823 AbstractMetaFunctionList lessThanEqFunctions() const { return m_less_than_eq_functions; }
824 824
825 825 void setGreaterThanEqFunctions(const AbstractMetaFunctionList &lst) { m_greater_than_eq_functions = lst; }
826 826 AbstractMetaFunctionList greaterThanEqFunctions() const { return m_greater_than_eq_functions; }
827 827
828 828 void sortFunctions();
829 829
830 830 const AbstractMetaClass *templateBaseClass() const { return m_template_base_class; }
831 831 void setTemplateBaseClass(const AbstractMetaClass *cls) { m_template_base_class = cls; }
832 832
833 833 void setTypeAlias(bool typeAlias) { m_is_type_alias = typeAlias; }
834 834 bool isTypeAlias() const { return m_is_type_alias; }
835 835
836 836 bool operator <(const AbstractMetaClass &a) const {
837 837 return qualifiedCppName() < a.qualifiedCppName();
838 838 }
839 839
840 840 private:
841 841 uint m_namespace : 1;
842 842 uint m_qobject : 1;
843 843 uint m_has_virtuals : 1;
844 844 uint m_has_nonpublic : 1;
845 845 uint m_has_virtual_slots : 1;
846 846 uint m_has_nonprivateconstructor : 1;
847 847 uint m_functions_fixed : 1;
848 848 uint m_has_public_destructor : 1;
849 849 uint m_force_shell_class : 1;
850 850 uint m_has_hash_function : 1;
851 851 uint m_has_equals_operator : 1;
852 852 uint m_has_clone_operator :1;
853 853 uint m_is_type_alias : 1;
854 854 uint m_reserved : 19;
855 855
856 856 const AbstractMetaClass *m_enclosing_class;
857 857 AbstractMetaClass *m_base_class;
858 858 const AbstractMetaClass *m_template_base_class;
859 859 AbstractMetaFunctionList m_functions;
860 860 AbstractMetaFieldList m_fields;
861 861 AbstractMetaEnumList m_enums;
862 862 AbstractMetaClassList m_interfaces;
863 863 AbstractMetaClass *m_extracted_interface;
864 864 AbstractMetaClass *m_primary_interface_implementor;
865 865 QList<QPropertySpec *> m_property_specs;
866 866 AbstractMetaFunctionList m_equals_functions;
867 867 AbstractMetaFunctionList m_nequals_functions;
868 868
869 869 AbstractMetaFunctionList m_less_than_functions;
870 870 AbstractMetaFunctionList m_greater_than_functions;
871 871 AbstractMetaFunctionList m_less_than_eq_functions;
872 872 AbstractMetaFunctionList m_greater_than_eq_functions;
873 873
874 874 QStringList m_base_class_names;
875 875 QList<TypeEntry *> m_template_args;
876 876 ComplexTypeEntry *m_type_entry;
877 877 FunctionModelItem m_qDebug_stream_function;
878 878 };
879 879
880 880 class QPropertySpec {
881 881 public:
882 882 QPropertySpec(const TypeEntry *type)
883 883 : m_type(type),
884 884 m_index(-1)
885 885 {
886 886 }
887 887
888 888 const TypeEntry *type() const { return m_type; }
889 889
890 890 QString name() const { return m_name; }
891 891 void setName(const QString &name) { m_name = name; }
892 892
893 893 QString read() const { return m_read; }
894 894 void setRead(const QString &read) { m_read = read; }
895 895
896 896 QString write() const { return m_write; }
897 897 void setWrite(const QString &write) { m_write = write; }
898 898
899 899 QString designable() const { return m_designable; }
900 900 void setDesignable(const QString &designable) { m_designable = designable; }
901 901
902 902 QString reset() const { return m_reset; }
903 903 void setReset(const QString &reset) { m_reset = reset; }
904 904
905 905 int index() const { return m_index; }
906 906 void setIndex(int index) { m_index = index; }
907 907
908 908 private:
909 909 QString m_name;
910 910 QString m_read;
911 911 QString m_write;
912 912 QString m_designable;
913 913 QString m_reset;
914 914 const TypeEntry *m_type;
915 915 int m_index;
916 916 };
917 917
918 918 inline AbstractMetaFunctionList AbstractMetaClass::allVirtualFunctions() const
919 919 {
920 920 return queryFunctions(VirtualFunctions
921 921 | NotRemovedFromTargetLang);
922 922 }
923 923
924 924 inline AbstractMetaFunctionList AbstractMetaClass::allFinalFunctions() const
925 925 {
926 926 return queryFunctions(FinalInTargetLangFunctions
927 927 | FinalInCppFunctions
928 928 | NotRemovedFromTargetLang);
929 929 }
930 930
931 931 inline AbstractMetaFunctionList AbstractMetaClass::cppInconsistentFunctions() const
932 932 {
933 933 return queryFunctions(Inconsistent
934 934 | NormalFunctions
935 935 | Visible
936 936 | NotRemovedFromTargetLang);
937 937 }
938 938
939 939 inline AbstractMetaFunctionList AbstractMetaClass::cppSignalFunctions() const
940 940 {
941 941 return queryFunctions(Signals
942 942 | Visible
943 943 | NotRemovedFromTargetLang);
944 944 }
945 945
946 946 #endif // ABSTRACTMETALANG_H
Show file before | Show file after | Hide comments
@@ -1,312 +1,312
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
4 4 ** All rights reserved.
5 5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 6 **
7 7 ** This file is part of the Qt Script Generator project on Qt Labs.
8 8 **
9 9 ** $QT_BEGIN_LICENSE:LGPL$
10 10 ** No Commercial Usage
11 11 ** This file contains pre-release code and may not be distributed.
12 12 ** You may use this file in accordance with the terms and conditions
13 13 ** contained in the Technology Preview License Agreement accompanying
14 14 ** this package.
15 15 **
16 16 ** GNU Lesser General Public License Usage
17 17 ** Alternatively, this file may be used under the terms of the GNU Lesser
18 18 ** General Public License version 2.1 as published by the Free Software
19 19 ** Foundation and appearing in the file LICENSE.LGPL included in the
20 20 ** packaging of this file. Please review the following information to
21 21 ** ensure the GNU Lesser General Public License version 2.1 requirements
22 22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23 23 **
24 24 ** In addition, as a special exception, Nokia gives you certain additional
25 25 ** rights. These rights are described in the Nokia Qt LGPL Exception
26 26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27 27 **
28 28 ** If you have questions regarding the use of this file, please contact
29 29 ** Nokia at qt-info@nokia.com.
30 30 **
31 31 **
32 32 **
33 33 **
34 34 **
35 35 **
36 36 **
37 37 **
38 38 ** $QT_END_LICENSE$
39 39 **
40 40 ****************************************************************************/
41 41
42 42 #include "shellheadergenerator.h"
43 43 #include "fileout.h"
44 44
45 45 #include <QtCore/QDir>
46 46
47 47 #include <qdebug.h>
48 48
49 49 QString ShellHeaderGenerator::fileNameForClass(const AbstractMetaClass *meta_class) const
50 50 {
51 51 return QString("PythonQtWrapper_%1.h").arg(meta_class->name());
52 52 }
53 53
54 54
55 55 void ShellHeaderGenerator::writeFieldAccessors(QTextStream &s, const AbstractMetaField *field)
56 56 {
57 57 const AbstractMetaFunction *setter = field->setter();
58 58 const AbstractMetaFunction *getter = field->getter();
59 59
60 60 // static fields are not supported (yet?)
61 61 if (setter->isStatic()) return;
62 62
63 63 // Uuid data4 did not work (TODO: move to typesystem...(
64 64 if (field->enclosingClass()->name()=="QUuid" && setter->name()=="data4") return;
65 65 if (field->enclosingClass()->name()=="QIPv6Address") return;
66 66
67 67 if (!field->type()->isConstant()) {
68 68 writeFunctionSignature(s, setter, 0, QString(),
69 69 Option(ConvertReferenceToPtr | FirstArgIsWrappedObject| IncludeDefaultExpression | ShowStatic | UnderscoreSpaces));
70 70 s << "{ theWrappedObject->" << field->name() << " = " << setter->arguments()[0]->argumentName() << "; }\n";
71 71 }
72 72
73 73 writeFunctionSignature(s, getter, 0, QString(),
74 74 Option(ConvertReferenceToPtr | FirstArgIsWrappedObject| IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
75 75 s << "{ return theWrappedObject->" << field->name() << "; }\n";
76 76 }
77 77
78 78 void ShellHeaderGenerator::write(QTextStream &s, const AbstractMetaClass *meta_class)
79 79 {
80 80 QString builtIn = ShellGenerator::isBuiltIn(meta_class->name())?"_builtin":"";
81 81 QString pro_file_name = meta_class->package().replace(".", "_") + builtIn + "/" + meta_class->package().replace(".", "_") + builtIn + ".pri";
82 82 priGenerator->addHeader(pro_file_name, fileNameForClass(meta_class));
83 83 setupGenerator->addClass(meta_class->package().replace(".", "_") + builtIn, meta_class);
84 84
85 85 QString include_block = "PYTHONQTWRAPPER_" + meta_class->name().toUpper() + "_H";
86 86
87 87 s << "#ifndef " << include_block << endl
88 88 << "#define " << include_block << endl << endl;
89 89
90 90 Include inc = meta_class->typeEntry()->include();
91 91 ShellGenerator::writeInclude(s, inc);
92 92
93 93 s << "#include <QObject>" << endl << endl;
94 94 s << "#include <PythonQt.h>" << endl << endl;
95 95
96 96 IncludeList list = meta_class->typeEntry()->extraIncludes();
97 97 qSort(list.begin(), list.end());
98 98 foreach (const Include &inc, list) {
99 99 ShellGenerator::writeInclude(s, inc);
100 100 }
101 101 s << endl;
102 102
103 103 AbstractMetaFunctionList ctors = meta_class->queryFunctions(AbstractMetaClass::Constructors
104 104 | AbstractMetaClass::WasVisible
105 105 | AbstractMetaClass::NotRemovedFromTargetLang);
106 106
107 107 // Shell-------------------------------------------------------------------
108 108 if (meta_class->generateShellClass()) {
109 109
110 110 AbstractMetaFunctionList virtualsForShell = getVirtualFunctionsForShell(meta_class);
111 111
112 112 s << "class " << shellClassName(meta_class)
113 113 << " : public " << meta_class->qualifiedCppName() << endl << "{" << endl;
114 114 s << "public:" << endl;
115 115 foreach(AbstractMetaFunction* fun, ctors) {
116 116 s << " ";
117 117 writeFunctionSignature(s, fun, 0,"PythonQtShell_",
118 118 Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
119 119 s << ":" << meta_class->qualifiedCppName() << "(";
120 120 QString scriptFunctionName = fun->originalName();
121 121 AbstractMetaArgumentList args = fun->arguments();
122 122 for (int i = 0; i < args.size(); ++i) {
123 123 if (i > 0)
124 124 s << ", ";
125 125 s << args.at(i)->argumentName();
126 126 }
127 127 s << "),_wrapper(NULL) {};" << endl;
128 128 }
129 129 s << endl;
130 130
131 131 foreach(AbstractMetaFunction* fun, virtualsForShell) {
132 132 s << "virtual ";
133 133 writeFunctionSignature(s, fun, 0, QString(),
134 134 Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
135 135 s << ";" << endl;
136 136 }
137 137 s << endl;
138 138 s << " PythonQtInstanceWrapper* _wrapper; " << endl;
139 139
140 140 s << "};" << endl << endl;
141 141 }
142 142
143 143 // Promoter-------------------------------------------------------------------
144 144 AbstractMetaFunctionList promoteFunctions = getProtectedFunctionsThatNeedPromotion(meta_class);
145 145 if (!promoteFunctions.isEmpty()) {
146 146 s << "class " << promoterClassName(meta_class)
147 147 << " : public " << meta_class->qualifiedCppName() << endl << "{ public:" << endl;
148 148
149 149 foreach(AbstractMetaFunction* fun, promoteFunctions) {
150 150 s << "inline ";
151 151 writeFunctionSignature(s, fun, 0, "promoted_",
152 152 Option(IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
153 153 s << " { ";
154 154 QString scriptFunctionName = fun->originalName();
155 155 AbstractMetaArgumentList args = fun->arguments();
156 156 if (fun->type())
157 157 s << "return ";
158 158 s << meta_class->qualifiedCppName() << "::";
159 159 s << fun->originalName() << "(";
160 160 for (int i = 0; i < args.size(); ++i) {
161 161 if (i > 0)
162 162 s << ", ";
163 163 s << args.at(i)->argumentName();
164 164 }
165 165 s << "); }" << endl;
166 166 }
167 167
168 168 s << "};" << endl << endl;
169 169 }
170 170
171 171 // Wrapper-------------------------------------------------------------------
172 172
173 173 s << "class " << wrapperClassName(meta_class)
174 174 << " : public QObject" << endl
175 175 << "{ Q_OBJECT" << endl;
176 176
177 177 s << "public:" << endl;
178 178
179 179 AbstractMetaEnumList enums1 = meta_class->enums();
180 180 AbstractMetaEnumList enums;
181 181 QList<FlagsTypeEntry*> flags;
182 182 foreach(AbstractMetaEnum* enum1, enums1) {
183 183 // catch gadgets and enums that are not exported on QObjects...
184 184 if (enum1->wasPublic() && (!meta_class->isQObject() || !enum1->hasQEnumsDeclaration())) {
185 185 enums << enum1;
186 186 if (enum1->typeEntry()->flags()) {
187 187 flags << enum1->typeEntry()->flags();
188 188 }
189 189 }
190 190 }
191 191 if (enums.count()) {
192 192 s << "Q_ENUMS(";
193 193 foreach(AbstractMetaEnum* enum1, enums) {
194 194 s << enum1->name() << " ";
195 195 }
196 196 s << ")" << endl;
197 197
198 198 if (flags.count()) {
199 199 s << "Q_FLAGS(";
200 200 foreach(FlagsTypeEntry* flag1, flags) {
201 201 QString origName = flag1->originalName();
202 202 int idx = origName.lastIndexOf("::");
203 203 if (idx!= -1) {
204 204 origName = origName.mid(idx+2);
205 205 }
206 206 s << origName << " ";
207 207 }
208 208 s << ")" << endl;
209 209 }
210 210
211 211 foreach(AbstractMetaEnum* enum1, enums) {
212 212 s << "enum " << enum1->name() << "{" << endl;
213 213 bool first = true;
214 214 foreach(AbstractMetaEnumValue* value, enum1->values()) {
215 215 if (first) { first = false; }
216 216 else { s << ", "; }
217 217 s << " " << value->name() << " = " << meta_class->qualifiedCppName() << "::" << value->name();
218 218 }
219 219 s << "};" << endl;
220 220 }
221 221 if (flags.count()) {
222 222 foreach(AbstractMetaEnum* enum1, enums) {
223 223 if (enum1->typeEntry()->flags()) {
224 224 QString origName = enum1->typeEntry()->flags()->originalName();
225 225 int idx = origName.lastIndexOf("::");
226 226 if (idx!= -1) {
227 227 origName = origName.mid(idx+2);
228 228 }
229 229 s << "Q_DECLARE_FLAGS("<< origName << ", " << enum1->name() <<")"<<endl;
230 230 }
231 231 }
232 232 }
233 233 }
234 234 s << "public slots:" << endl;
235 235 if (meta_class->generateShellClass() || !meta_class->isAbstract()) {
236 236
237 237 bool copyConstructorSeen = false;
238 238 bool defaultConstructorSeen = false;
239 239 foreach (const AbstractMetaFunction *fun, ctors) {
240 240 if (!fun->isPublic() || fun->isAbstract()) { continue; }
241 241 s << meta_class->qualifiedCppName() << "* ";
242 242 writeFunctionSignature(s, fun, 0, "new_",
243 243 Option(IncludeDefaultExpression | OriginalName | ShowStatic));
244 244 s << ";" << endl;
245 245 if (fun->arguments().size()==1 && meta_class->qualifiedCppName() == fun->arguments().at(0)->type()->typeEntry()->qualifiedCppName()) {
246 246 copyConstructorSeen = true;
247 247 }
248 248 if (fun->arguments().size()==0) {
249 249 defaultConstructorSeen = true;
250 250 }
251 251 }
252 252
253 253 if (meta_class->typeEntry()->isValue()
254 254 && !copyConstructorSeen && defaultConstructorSeen) {
255 255 QString className = meta_class->generateShellClass()?shellClassName(meta_class):meta_class->qualifiedCppName();
256 256 s << meta_class->qualifiedCppName() << "* new_" << meta_class->name() << "(const " << meta_class->qualifiedCppName() << "& other) {" << endl;
257 257 s << className << "* a = new " << className << "();" << endl;
258 258 s << "*((" << meta_class->qualifiedCppName() << "*)a) = other;" << endl;
259 259 s << "return a; }" << endl;
260 260 }
261 261 }
262 262 if (meta_class->hasPublicDestructor() && !meta_class->isNamespace()) {
263 263 s << "void delete_" << meta_class->name() << "(" << meta_class->qualifiedCppName() << "* obj) { delete obj; } ";
264 264 s << endl;
265 265 }
266 266 if (meta_class->name()=="QTreeWidgetItem") {
267 267 s << "bool py_hasOwner(QTreeWidgetItem* theWrappedObject) { return theWrappedObject->treeWidget()!=NULL || theWrappedObject->parent()!=NULL; }" << endl;
268 268 } else if (meta_class->name()=="QGraphicsItem") {
269 269 s << "bool py_hasOwner(QGraphicsItem* theWrappedObject) { return theWrappedObject->scene()!=NULL || theWrappedObject->parentItem()!=NULL; }" << endl;
270 270 }
271 271
272 272 AbstractMetaFunctionList functions = getFunctionsToWrap(meta_class);
273 273
274 274 foreach (const AbstractMetaFunction *function, functions) {
275 if (!function->isSlot()) {
275 if (!function->isSlot() || function->isVirtual()) {
276 276 s << " ";
277 277 writeFunctionSignature(s, function, 0, QString(),
278 278 Option(ConvertReferenceToPtr | FirstArgIsWrappedObject| IncludeDefaultExpression | OriginalName | ShowStatic | UnderscoreSpaces));
279 279 s << ";" << endl;
280 280 }
281 281 }
282 282 if (meta_class->hasDefaultToStringFunction() || meta_class->hasToStringCapability()) {
283 283 s << " QString py_toString(" << meta_class->qualifiedCppName() << "*);" << endl;
284 284 }
285 285 if (meta_class->hasDefaultIsNull()) {
286 286 s << " bool __nonzero__(" << meta_class->qualifiedCppName() << "* obj) { return !obj->isNull(); }" << endl;
287 287 }
288 288
289 289 // Field accessors
290 290 foreach (const AbstractMetaField *field, meta_class->fields()) {
291 291 if (field->isPublic()) {
292 292 writeFieldAccessors(s, field);
293 293 }
294 294 }
295 295
296 296 writeInjectedCode(s, meta_class);
297 297
298 298
299 299 s << "};" << endl << endl
300 300 << "#endif // " << include_block << endl;
301 301
302 302 }
303 303
304 304 void ShellHeaderGenerator::writeInjectedCode(QTextStream &s, const AbstractMetaClass *meta_class)
305 305 {
306 306 CodeSnipList code_snips = meta_class->typeEntry()->codeSnips();
307 307 foreach (const CodeSnip &cs, code_snips) {
308 308 if (cs.language == TypeSystem::PyWrapperDeclaration) {
309 309 s << cs.code() << endl;
310 310 }
311 311 }
312 312 }
Show file before | Show file after | Hide comments
@@ -1,316 +1,318
1 1 /****************************************************************************
2 2 **
3 3 ** Copyright (C) 2008-2009 Nokia Corporation and/or its subsidiary(-ies).
4 4 ** All rights reserved.
5 5 ** Contact: Nokia Corporation (qt-info@nokia.com)
6 6 **
7 7 ** This file is part of the Qt Script Generator project on Qt Labs.
8 8 **
9 9 ** $QT_BEGIN_LICENSE:LGPL$
10 10 ** No Commercial Usage
11 11 ** This file contains pre-release code and may not be distributed.
12 12 ** You may use this file in accordance with the terms and conditions
13 13 ** contained in the Technology Preview License Agreement accompanying
14 14 ** this package.
15 15 **
16 16 ** GNU Lesser General Public License Usage
17 17 ** Alternatively, this file may be used under the terms of the GNU Lesser
18 18 ** General Public License version 2.1 as published by the Free Software
19 19 ** Foundation and appearing in the file LICENSE.LGPL included in the
20 20 ** packaging of this file. Please review the following information to
21 21 ** ensure the GNU Lesser General Public License version 2.1 requirements
22 22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
23 23 **
24 24 ** In addition, as a special exception, Nokia gives you certain additional
25 25 ** rights. These rights are described in the Nokia Qt LGPL Exception
26 26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
27 27 **
28 28 ** If you have questions regarding the use of this file, please contact
29 29 ** Nokia at qt-info@nokia.com.
30 30 **
31 31 **
32 32 **
33 33 **
34 34 **
35 35 **
36 36 **
37 37 **
38 38 ** $QT_END_LICENSE$
39 39 **
40 40 ****************************************************************************/
41 41
42 42 #include "shellimplgenerator.h"
43 43 #include "reporthandler.h"
44 44 #include "fileout.h"
45 45 #include <iostream>
46 46
47 47 extern void declareFunctionMetaTypes(QTextStream &stream,
48 48 const AbstractMetaFunctionList &functions,
49 49 QSet<QString> &registeredTypeNames);
50 50
51 51 QString ShellImplGenerator::fileNameForClass(const AbstractMetaClass *meta_class) const
52 52 {
53 53 return QString("PythonQtWrapper_%1.cpp").arg(meta_class->name());
54 54 }
55 55
56 56 static bool include_less_than(const Include &a, const Include &b)
57 57 {
58 58 return a.name < b.name;
59 59 }
60 60
61 61 static void writeHelperCode(QTextStream &s, const AbstractMetaClass *)
62 62 {
63 63 }
64 64
65 65
66 66
67 67 void ShellImplGenerator::write(QTextStream &s, const AbstractMetaClass *meta_class)
68 68 {
69 69 QString builtIn = ShellGenerator::isBuiltIn(meta_class->name())?"_builtin":"";
70 70 QString pro_file_name = meta_class->package().replace(".", "_") + builtIn + "/" + meta_class->package().replace(".", "_") + builtIn + ".pri";
71 71 priGenerator->addSource(pro_file_name, fileNameForClass(meta_class));
72 72
73 73 s << "#include \"PythonQtWrapper_" << meta_class->name() << ".h\"" << endl << endl;
74 74
75 75 s << "#include <PythonQtSignalReceiver.h>" << endl;
76 76 s << "#include <PythonQtMethodInfo.h>" << endl;
77 77 s << "#include <PythonQtConversion.h>" << endl;
78 78
79 79 //if (!meta_class->generateShellClass())
80 80 // return;
81 81
82 82 IncludeList list = meta_class->typeEntry()->extraIncludes();
83 83 qSort(list.begin(), list.end());
84 84 foreach (const Include &inc, list) {
85 85 ShellGenerator::writeInclude(s, inc);
86 86 }
87 87 s << endl;
88 88
89 89 writeHelperCode(s, meta_class);
90 90
91 91 // find constructors
92 92 AbstractMetaFunctionList ctors;
93 93 ctors = meta_class->queryFunctions(AbstractMetaClass::Constructors
94 94 | AbstractMetaClass::WasVisible
95 95 | AbstractMetaClass::NotRemovedFromTargetLang);
96 96 // find member functions
97 97 AbstractMetaFunctionList functions = getFunctionsToWrap(meta_class);
98 98
99 99 // write metatype declarations
100 100 {
101 101 // QSet<QString> registeredTypeNames = m_qmetatype_declared_typenames;
102 102 // declareFunctionMetaTypes(s, functions, registeredTypeNames);
103 103 // s << endl;
104 104 }
105 105
106 106 if (meta_class->generateShellClass()) {
107 107 AbstractMetaFunctionList virtualsForShell = getVirtualFunctionsForShell(meta_class);
108 108 foreach (const AbstractMetaFunction *fun, virtualsForShell) {
109 109 bool hasReturnValue = (fun->type());
110 110 writeFunctionSignature(s, fun, meta_class, QString(),
111 111 Option(OriginalName | ShowStatic | UnderscoreSpaces),
112 112 "PythonQtShell_");
113 113 s << endl << "{" << endl;
114 114
115 115 Option typeOptions = Option(OriginalName | UnderscoreSpaces | SkipName);
116 116 AbstractMetaArgumentList args = fun->arguments();
117 117
118 118 s << "if (_wrapper) {" << endl;
119 119 s << " PyObject* obj = PyObject_GetAttrString((PyObject*)_wrapper, \"" << fun->name() << "\");" << endl;
120 120 s << " PyErr_Clear();" << endl;
121 121 s << " if (obj && !PythonQtSlotFunction_Check(obj)) {" << endl;
122 122 s << " static const char* argumentList[] ={\"";
123 123 if (hasReturnValue) {
124 124 // write the arguments, return type first
125 125 writeTypeInfo(s, fun->type(), typeOptions);
126 126 }
127 127 s << "\"";
128 128 for (int i = 0; i < args.size(); ++i) {
129 129 s << " , \"";
130 130 writeTypeInfo(s, args.at(i)->type(), typeOptions);
131 131 s << "\"";
132 132 }
133 133 s << "};" << endl;
134 134 s << " static const PythonQtMethodInfo* methodInfo = PythonQtMethodInfo::getCachedMethodInfoFromArgumentList(" << QString::number(args.size()+1) << ", argumentList);" << endl;
135 135
136 136 if (hasReturnValue) {
137 137 s << " ";
138 138 writeTypeInfo(s, fun->type(), typeOptions);
139 139 s << " returnValue;" << endl;
140 140 // TODO: POD init to default is missing...
141 141 }
142 142 s << " void* args[" << QString::number(args.size()+1) << "] = {NULL";
143 143 for (int i = 0; i < args.size(); ++i) {
144 144 s << ", (void*)&" << args.at(i)->argumentName();
145 145 }
146 146 s << "};" << endl;
147 147
148 148 s << " PyObject* result = PythonQtSignalTarget::call(obj, methodInfo, args, true);" << endl;
149 149 if (hasReturnValue) {
150 150 s << " if (result) {" << endl;
151 151 s << " args[0] = PythonQtConv::ConvertPythonToQt(methodInfo->parameters().at(0), result, false, NULL, &returnValue);" << endl;
152 152 s << " if (args[0]!=&returnValue) {" << endl;
153 153 s << " if (args[0]==NULL) {" << endl;
154 154 s << " PythonQt::priv()->handleVirtualOverloadReturnError(\"" << fun->name() << "\", methodInfo, result);" << endl;
155 155 s << " } else {" << endl;
156 156 s << " returnValue = *((";
157 157 writeTypeInfo(s, fun->type(), typeOptions);
158 158 s << "*)args[0]);" << endl;
159 159 s << " }" << endl;
160 160 s << " }" << endl;
161 161 s << " }" << endl;
162 162 }
163 163 s << " if (result) { Py_DECREF(result); } " << endl;
164 164 s << " Py_DECREF(obj);" << endl;
165 165 if (hasReturnValue) {
166 166 s << " return returnValue;" << endl;
167 167 } else {
168 168 s << " return;" << endl;
169 169 }
170 170 s << " }" << endl;
171 171 s << "}" << endl;
172 172
173 173 s << " ";
174 174 if (fun->isAbstract()) {
175 175 if (fun->type()) {
176 176 // return empty default object
177 177 s << "return ";
178 178 if (fun->type()->indirections()>0) {
179 179 s << "0;";
180 180 } else {
181 181 writeTypeInfo(s, fun->type(), typeOptions);
182 182 s << "();";
183 183 }
184 184 }
185 185 } else {
186 186 if (fun->type()) {
187 187 s << "return ";
188 188 }
189 189 s << meta_class->qualifiedCppName() << "::";
190 190 s << fun->originalName() << "(";
191 191 for (int i = 0; i < args.size(); ++i) {
192 192 if (i > 0)
193 193 s << ", ";
194 194 s << args.at(i)->argumentName();
195 195 }
196 196 s << ");";
197 197 }
198 198 s << endl << "}" << endl;
199 199 }
200 200 }
201 201
202 202 if (meta_class->generateShellClass() || !meta_class->isAbstract()) {
203 203
204 204 // write constructors
205 205 foreach (const AbstractMetaFunction *ctor, ctors) {
206 206 if (!ctor->isPublic() || ctor->isAbstract()) { continue; }
207 207
208 208 s << meta_class->qualifiedCppName() << "* ";
209 209 s << "PythonQtWrapper_" << meta_class->name() << "::";
210 210 writeFunctionSignature(s, ctor, 0, "new_", Option(OriginalName | ShowStatic));
211 211 s << endl;
212 212 s << "{ " << endl;
213 213 s << "return new " << (meta_class->generateShellClass()?shellClassName(meta_class):meta_class->qualifiedCppName()) << "(";
214 214 AbstractMetaArgumentList args = ctor->arguments();
215 215 for (int i = 0; i < args.size(); ++i) {
216 216 if (i > 0)
217 217 s << ", ";
218 218 s << args.at(i)->argumentName();
219 219 }
220 220 s << ");" << " }" << endl << endl;
221 221 }
222 222 }
223 223
224 224 QString wrappedObject = " (*theWrappedObject)";
225 225
226 226 // write member functions
227 227 for (int i = 0; i < functions.size(); ++i) {
228 228 AbstractMetaFunction *fun = functions.at(i);
229 if (fun->isSlot()) continue;
230
229 bool needsWrapping = (!fun->isSlot() || fun->isVirtual());
230 if (!needsWrapping) {
231 continue;
232 }
231 233 writeFunctionSignature(s, fun, meta_class, QString(),
232 234 Option(ConvertReferenceToPtr | FirstArgIsWrappedObject | OriginalName | ShowStatic | UnderscoreSpaces),
233 235 "PythonQtWrapper_");
234 236 s << endl << "{" << endl;
235 237 s << " ";
236 238 if (ShellGenerator::isSpecialStreamingOperator(fun)) {
237 239 s << fun->arguments().at(0)->argumentName();
238 240 if (fun->originalName().startsWith("operator>>")) {
239 241 s << " >> ";
240 242 } else {
241 243 s << " << ";
242 244 }
243 245 s << wrappedObject;
244 246 } else {
245 247 QString scriptFunctionName = fun->originalName();
246 248 AbstractMetaArgumentList args = fun->arguments();
247 249 // call the C++ implementation
248 250 if (fun->type()) {
249 251 s << "return ";
250 252 // call the C++ implementation
251 253 if (fun->type()->isReference()) {
252 254 s << "&";
253 255 }
254 256 }
255 257 s << "(";
256 258 if (scriptFunctionName.startsWith("operator>>")) {
257 259 s << wrappedObject << " >>" << args.at(0)->argumentName();
258 260 } else if (scriptFunctionName.startsWith("operator<<")) {
259 261 s << wrappedObject << " <<" << args.at(0)->argumentName();
260 262 } else if (scriptFunctionName.startsWith("operator[]")) {
261 263 s << wrappedObject << "[" << args.at(0)->argumentName() << "]";
262 264 } else if (scriptFunctionName.startsWith("operator") && args.size()==1) {
263 265 QString op = scriptFunctionName.mid(8);
264 266 s << wrappedObject << op << " " << args.at(0)->argumentName();
265 267 } else {
266 268 if (fun->isStatic()) {
267 269 s << meta_class->qualifiedCppName() << "::";
268 270 } else {
269 271 if (!fun->isPublic() || fun->isVirtual()) {
270 272 s << " ((" << promoterClassName(meta_class) << "*)theWrappedObject)->promoted_";
271 273 } else {
272 274 s << " theWrappedObject->";
273 275 }
274 276 }
275 277 s << fun->originalName() << "(";
276 278 for (int i = 0; i < args.size(); ++i) {
277 279 if (i > 0)
278 280 s << ", ";
279 281 s << args.at(i)->argumentName();
280 282 }
281 283 s << ")";
282 284 }
283 285 s << ")";
284 286 }
285 287 s << ";" << endl;
286 288
287 289 s << "}" << endl << endl;
288 290 }
289 291
290 292 if (meta_class->hasDefaultToStringFunction()) {
291 293 s << "QString PythonQtWrapper_" << meta_class->name() << "::py_toString(" << meta_class->qualifiedCppName() << "* obj) { return obj->toString(); }" << endl;
292 294 } else if (meta_class->hasToStringCapability()) {
293 295 FunctionModelItem fun = meta_class->hasToStringCapability();
294 296 int indirections = fun->arguments().at(1)->type().indirections();
295 297 QString deref = QLatin1String(indirections == 0 ? "*" : "");
296 298 s << "QString PythonQtWrapper_" << meta_class->name() << "::py_toString(" << meta_class->qualifiedCppName() << "* obj) {" << endl;
297 299 s << " QString result;" << endl;
298 300 s << " QDebug d(&result);" << endl;
299 301 s << " d << " << deref << "obj;" << endl;
300 302 s << " return result;" << endl;
301 303 s << "}" << endl << endl;
302 304 }
303 305
304 306 writeInjectedCode(s, meta_class);
305 307
306 308 }
307 309
308 310 void ShellImplGenerator::writeInjectedCode(QTextStream &s, const AbstractMetaClass *meta_class)
309 311 {
310 312 CodeSnipList code_snips = meta_class->typeEntry()->codeSnips();
311 313 foreach (const CodeSnip &cs, code_snips) {
312 314 if (cs.language == TypeSystem::PyWrapperCode) {
313 315 s << cs.code() << endl;
314 316 }
315 317 }
316 318 }
Show file before | Show file after | Hide comments
@@ -1,2498 +1,2497
1 1 <?xml version="1.0"?>
2 2 <typesystem package="com.trolltech.qt.core"><template name="core.prepare_removed_bool*_argument">
3 3 bool __ok;
4 4 bool *%out% = &amp;__ok;
5 5 </template><template name="core.convert_to_null_or_wrap">
6 6 QScriptValue %out%;
7 7 if (!__ok)
8 8 %out% = context-&gt;engine()-&gt;nullValue();
9 9 else
10 10 %out% = qScriptValueFromValue(context-&gt;engine(), %in%);
11 11 </template><template name="core.convert_to_null_or_primitive">
12 12 QScriptValue %out%;
13 13 if (!__ok)
14 14 %out% = context-&gt;engine()-&gt;nullValue();
15 15 else
16 16 %out% = QScriptValue(context-&gt;engine(), %in%);
17 17 </template><template name="core.convert_string_arg_to_char*">
18 18 QByteArray tmp_%out% = %in%.toString().toLatin1();
19 19 const char * %out% = tmp_%out%.constData();
20 20 </template><template name="core.convert_int_arg_and_check_range">
21 21 int %out% = %in%.toInt32();
22 22 if ((%out% &lt; 0) || (%this%-&gt;size() &lt; %out%)) {
23 23 return context-&gt;throwError(QScriptContext::RangeError,
24 24 QString::fromLatin1("%CLASS_NAME%::%FUNCTION_NAME%(): index out of range"));
25 25 }
26 26 </template><template name="core.convert_pointer_arg_and_check_null">
27 27 %TYPE% %out% = qscriptvalue_cast&lt;%TYPE%&gt;(%in%);
28 28 if (!%out%) {
29 29 return context-&gt;throwError(QScriptContext::TypeError,
30 30 QString::fromLatin1("%CLASS_NAME%::%FUNCTION_NAME%(): failed to convert argument to %TYPE%"));
31 31 }
32 32 </template><template name="core.convert_stringref_to_string">
33 33 QString %out% = %in%.toString();
34 34 </template><rejection class="QTextCodec::ConverterState"/><rejection class="QTextCodecFactoryInterface"/><rejection class="QAbstractEventDispatcher"/><rejection class="QAbstractFileEngine"/><rejection class="QAbstractFileEngineHandler"/><rejection class="QAbstractFileEngineIterator"/><rejection class="QFSFileEngine"/><rejection class="QSystemLocale"/><rejection class="QFutureWatcherBase"/><rejection class="QFutureSynchronizer"/><enum-type name="QXmlStreamReader::Error"/><enum-type name="QXmlStreamReader::TokenType"/>
35 35
36 36 <primitive-type name="qgl_GLsizeiptr"/>
37 37 <primitive-type name="qgl_GLintptr"/>
38 38 <primitive-type name="GLint"/>
39 39 <primitive-type name="GLuint"/>
40 40 <primitive-type name="GLenum"/>
41 41 <primitive-type name="GLclampf"/>
42 42 <primitive-type name="GLsizei"/>
43 43 <primitive-type name="GLfloat"/>
44 44 <primitive-type name="GLbitfield"/>
45 45 <primitive-type name="GLbyte"/>
46 46 <primitive-type name="GLshort"/>
47 47 <primitive-type name="GLubyte"/>
48 48 <primitive-type name="GLushort"/>
49 49 <primitive-type name="GLdouble"/>
50 50 <primitive-type name="GLclampd"/>
51 51 <primitive-type name="GLvoid"/>
52 52 <primitive-type name="GLboolean"/>
53 53
54 54 <primitive-type name="bool"/><primitive-type name="double"/><primitive-type name="qreal"/><primitive-type name="float"/><primitive-type name="qint64"/><primitive-type name="__int64"/><primitive-type name="unsigned __int64"/><primitive-type name="unsigned long long"/><primitive-type name="long long"/><primitive-type name="qlonglong"/><primitive-type name="qulonglong"/><primitive-type name="short"/><primitive-type name="short"/><primitive-type name="signed short"/><primitive-type name="ushort"/><primitive-type name="unsigned short"/><primitive-type name="char"/><primitive-type name="signed char"/><primitive-type name="uchar"/><primitive-type name="unsigned char"/><primitive-type name="int"/><primitive-type name="signed int"/><primitive-type name="uint"/><primitive-type name="ulong"/><primitive-type name="unsigned int"/><primitive-type name="signed long"/><primitive-type name="long"/><primitive-type name="unsigned long"/><primitive-type name="WId"/><primitive-type name="Qt::HANDLE"/><primitive-type name="QVariant::Type"/><primitive-type name="QByteRef"/><primitive-type name="QBitRef"/><primitive-type name="QBool"/><primitive-type name="jobject"/><primitive-type name="quintptr"/><suppress-warning text="WARNING(MetaJavaBuilder) :: signal 'finished' in class 'QProcess' is overloaded."/><suppress-warning text="WARNING(MetaJavaBuilder) :: missing required class for enums: QRegExp"/><suppress-warning text="WARNING(MetaJavaBuilder) :: enum 'QtValidLicenseForScriptToolsModule' does not have a type entry or is not an enum"/><suppress-warning text="WARNING(MetaJavaBuilder) :: Rejected enum has no alternative...: QDataStream::Qt_4_5"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unhandled enum value: Qt::MatchFlags(Qt::MatchStartsWith in Qt::MatchFlag"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unhandled enum value: Qt::MatchWrap) in Qt::MatchFlag"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unmatched enum Qt::MatchFlags(Qt::MatchStartsWith|Qt::MatchWrap) when parsing default value of 'match' in class 'QAbstractItemModel'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unsupported default value 'QLatin1String(defaultConnection)' of argument in function '*', class '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: Class '*' has equals operators but no qHash() function"/><suppress-warning text="WARNING(MetaJavaBuilder) :: type '*' is specified in typesystem, but not defined. This could potentially lead to compilation errors."/><suppress-warning text="WARNING(MetaJavaBuilder) :: namespace '*' for enum '*' is not declared"/><suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function '*', unmatched parameter type '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function '*', unmatched return type '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: signature '*' for function modification in '*' not found. Possible candidates: "/><suppress-warning text="WARNING(MetaJavaBuilder) :: namespace '*' does not have a type entry"/><suppress-warning text="WARNING(MetaJavaBuilder) :: unsupported default value '*' of argument in function '*', class '*'"/><suppress-warning text="WARNING(MetaJavaBuilder) :: Shadowing: * and *; Java code will not compile"/><suppress-warning text="WARNING(MetaJavaBuilder) :: enum '*' is specified in typesystem, but not declared"/>
55 55
56 56 <value-type name="QModelIndex"/>
57 57 <rejection class="*" function-name="d_func"/>
58 58 <rejection class="*" function-name="data_ptr"/>
59 59 <rejection class="*" function-name="detach"/>
60 60 <rejection class="*" function-name="isDetached"/>
61 61
62 62 <rejection class="*" field-name="d_ptr"/>
63 63 <rejection class="*" field-name="d"/>
64 64
65 65 <rejection class="" enum-name="QtValidLicenseForTestModule"/>
66 66
67 67
68 68 <rejection class="" enum-name="QtValidLicenseForDBusModule"/>
69 69 <rejection class="" enum-name="QtValidLicenseForSqlModule"/>
70 70 <rejection class="" enum-name="QtValidLicenseForOpenGLModule"/>
71 71 <rejection class="" enum-name="enum_1"/>
72 72 <rejection class="" enum-name="QtValidLicenseForXmlModule"/>
73 73 <rejection class="" enum-name="QtValidLicenseForXmlPatternsModule"/>
74 74 <rejection class="" enum-name="QtValidLicenseForActiveQtModule"/>
75 75 <rejection class="" enum-name="QtValidLicenseForCoreModule"/>
76 76 <rejection class="" enum-name="QtValidLicenseForQt3SupportLightModule"/>
77 77 <rejection class="" enum-name="QtValidLicenseForQt3SupportModule"/>
78 78 <rejection class="" enum-name="QtValidLicenseForNetworkModule"/>
79 79 <rejection class="" enum-name="QtValidLicenseForSvgModule"/>
80 80 <rejection class="" enum-name="QtValidLicenseForGuiModule"/>
81 81 <rejection class="" enum-name="QtValidLicenseForScriptModule"/>
82 82 <rejection class="" enum-name="QtValidLicenseForHelpModule"/>
83 83 <rejection class="" enum-name="QtValidLicenseForScriptToolsModule"/>
84 84 <rejection class="" enum-name="QtValidLicenseForMultimediaModule"/>
85 85 <rejection class="" enum-name="QtValidLicenseForOpenVGModule"/>
86 86 <rejection class="" enum-name="QtValidLicenseForDeclarativeModule"/>
87 87
88 88
89 89 <rejection class="QtConcurrent" enum-name="enum_1"/>
90 90 <rejection class="QtConcurrent" function-name="operator|"/>
91 91
92 92 <rejection class="Qt" enum-name="Modifier"/>
93 93
94 94 <rejection class="QSharedPointer"/>
95 95 <rejection class="QWeakPointer"/>
96 96 <rejection class="QFuture::const_iterator"/>
97 97 <rejection class="QFutureInterface"/>
98 98 <rejection class="QFutureInterfaceBase"/>
99 99 <rejection class="QtConcurrent::BlockSizeManager"/>
100 100 <rejection class="QtConcurrent::ConstMemberFunctionWrapper"/>
101 101 <rejection class="QtConcurrent::Exception"/>
102 102 <rejection class="QtConcurrent::FilterKernel"/>
103 103 <rejection class="QtConcurrent::FilteredEachKernel"/>
104 104 <rejection class="QtConcurrent::FilteredReducedKernel"/>
105 105 <rejection class="QtConcurrent::FunctionWrapper0"/>
106 106 <rejection class="QtConcurrent::FunctionWrapper1"/>
107 107 <rejection class="QtConcurrent::FunctionWrapper2"/>
108 108 <rejection class="QtConcurrent::IntermediateResults"/>
109 109 <rejection class="QtConcurrent::IterateKernel"/>
110 110 <rejection class="QtConcurrent::MapKernel"/>
111 111 <rejection class="QtConcurrent::MappedEachKernel"/>
112 112 <rejection class="QtConcurrent::MappedReducedKernel"/>
113 113 <rejection class="QtConcurrent::Median"/>
114 114 <rejection class="QtConcurrent::MemberFunctionWrapper"/>
115 115 <rejection class="QtConcurrent::MemberFunctionWrapper1"/>
116 116 <rejection class="QtConcurrent::qValueType"/>
117 117 <rejection class="QtConcurrent::ReduceKernel"/>
118 118 <rejection class="QtConcurrent::ResultItem"/>
119 119 <rejection class="QtConcurrent::ResultIterator"/>
120 120 <rejection class="QtConcurrent::ResultIteratorBase"/>
121 121 <rejection class="QtConcurrent::ResultReporter"/>
122 122 <rejection class="QtConcurrent::ResultStore"/>
123 123 <rejection class="QtConcurrent::ResultStoreBase"/>
124 124 <rejection class="QtConcurrent::RunFunctionTask"/>
125 125 <rejection class="QtConcurrent::RunFunctionTaskBase"/>
126 126 <rejection class="QtConcurrent::SelectSpecialization"/>
127 127 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall0"/>
128 128 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall1"/>
129 129 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall2"/>
130 130 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall3"/>
131 131 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall4"/>
132 132 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionCall5"/>
133 133 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall0"/>
134 134 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall1"/>
135 135 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall2"/>
136 136 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall3"/>
137 137 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall4"/>
138 138 <rejection class="QtConcurrent::SelectStoredConstMemberFunctionPointerCall5"/>
139 139 <rejection class="QtConcurrent::SelectStoredFunctorCall0"/>
140 140 <rejection class="QtConcurrent::SelectStoredFunctorCall1"/>
141 141 <rejection class="QtConcurrent::SelectStoredFunctorCall2"/>
142 142 <rejection class="QtConcurrent::SelectStoredFunctorCall3"/>
143 143 <rejection class="QtConcurrent::SelectStoredFunctorCall4"/>
144 144 <rejection class="QtConcurrent::SelectStoredFunctorCall5"/>
145 145 <rejection class="QtConcurrent::SelectStoredFunctorPointerCall0"/>
146 146 <rejection class="QtConcurrent::SelectStoredFunctorPointerCall1"/>
147 147 <rejection class="QtConcurrent::SelectStoredFunctorPointerCall2"/>
148 148 <rejection class="QtConcurrent::SelectStoredFunctorPointerCall3"/>
149 149 <rejection class="QtConcurrent::SelectStoredFunctorPointerCall4"/>
150 150 <rejection class="QtConcurrent::SelectStoredFunctorPointerCall5"/>
151 151 <rejection class="QtConcurrent::SelectStoredMemberFunctionCall0"/>
152 152 <rejection class="QtConcurrent::SelectStoredMemberFunctionCall1"/>
153 153 <rejection class="QtConcurrent::SelectStoredMemberFunctionCall2"/>
154 154 <rejection class="QtConcurrent::SelectStoredMemberFunctionCall3"/>
155 155 <rejection class="QtConcurrent::SelectStoredMemberFunctionCall4"/>
156 156 <rejection class="QtConcurrent::SelectStoredMemberFunctionCall5"/>
157 157 <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall0"/>
158 158 <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall1"/>
159 159 <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall2"/>
160 160 <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall3"/>
161 161 <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall4"/>
162 162 <rejection class="QtConcurrent::SelectStoredMemberFunctionPointerCall5"/>
163 163 <rejection class="QtConcurrent::SequenceHolder1"/>
164 164 <rejection class="QtConcurrent::SequenceHolder2"/>
165 165 <rejection class="QtConcurrent::StoredConstMemberFunctionCall0"/>
166 166 <rejection class="QtConcurrent::StoredConstMemberFunctionCall1"/>
167 167 <rejection class="QtConcurrent::StoredConstMemberFunctionCall2"/>
168 168 <rejection class="QtConcurrent::StoredConstMemberFunctionCall3"/>
169 169 <rejection class="QtConcurrent::StoredConstMemberFunctionCall4"/>
170 170 <rejection class="QtConcurrent::StoredConstMemberFunctionCall5"/>
171 171 <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall0"/>
172 172 <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall1"/>
173 173 <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall2"/>
174 174 <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall3"/>
175 175 <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall4"/>
176 176 <rejection class="QtConcurrent::StoredConstMemberFunctionPointerCall5"/>
177 177 <rejection class="QtConcurrent::StoredFunctorCall0"/>
178 178 <rejection class="QtConcurrent::StoredFunctorCall1"/>
179 179 <rejection class="QtConcurrent::StoredFunctorCall2"/>
180 180 <rejection class="QtConcurrent::StoredFunctorCall3"/>
181 181 <rejection class="QtConcurrent::StoredFunctorCall4"/>
182 182 <rejection class="QtConcurrent::StoredFunctorCall5"/>
183 183 <rejection class="QtConcurrent::StoredFunctorPointerCall0"/>
184 184 <rejection class="QtConcurrent::StoredFunctorPointerCall1"/>
185 185 <rejection class="QtConcurrent::StoredFunctorPointerCall2"/>
186 186 <rejection class="QtConcurrent::StoredFunctorPointerCall3"/>
187 187 <rejection class="QtConcurrent::StoredFunctorPointerCall4"/>
188 188 <rejection class="QtConcurrent::StoredFunctorPointerCall5"/>
189 189 <rejection class="QtConcurrent::StoredMemberFunctionCall0"/>
190 190 <rejection class="QtConcurrent::StoredMemberFunctionCall1"/>
191 191 <rejection class="QtConcurrent::StoredMemberFunctionCall2"/>
192 192 <rejection class="QtConcurrent::StoredMemberFunctionCall3"/>
193 193 <rejection class="QtConcurrent::StoredMemberFunctionCall4"/>
194 194 <rejection class="QtConcurrent::StoredMemberFunctionCall5"/>
195 195 <rejection class="QtConcurrent::StoredMemberFunctionPointerCall0"/>
196 196 <rejection class="QtConcurrent::StoredMemberFunctionPointerCall1"/>
197 197 <rejection class="QtConcurrent::StoredMemberFunctionPointerCall2"/>
198 198 <rejection class="QtConcurrent::StoredMemberFunctionPointerCall3"/>
199 199 <rejection class="QtConcurrent::StoredMemberFunctionPointerCall4"/>
200 200 <rejection class="QtConcurrent::StoredMemberFunctionPointerCall5"/>
201 201 <rejection class="QtConcurrent::ThreadEngine"/>
202 202 <rejection class="QtConcurrent::ThreadEngineBase"/>
203 203 <rejection class="QtConcurrent::ThreadEngineSemaphore"/>
204 204 <rejection class="QtConcurrent::ThreadEngineStarter"/>
205 205 <rejection class="QtConcurrent::ThreadEngineStarterBase"/>
206 206 <rejection class="QtConcurrent::UnhandledException"/>
207 207 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall0"/>
208 208 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall1"/>
209 209 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall2"/>
210 210 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall3"/>
211 211 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall4"/>
212 212 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionCall5"/>
213 213 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall0"/>
214 214 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall1"/>
215 215 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall2"/>
216 216 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall3"/>
217 217 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall4"/>
218 218 <rejection class="QtConcurrent::VoidStoredConstMemberFunctionPointerCall5"/>
219 219 <rejection class="QtConcurrent::VoidStoredFunctorCall0"/>
220 220 <rejection class="QtConcurrent::VoidStoredFunctorCall1"/>
221 221 <rejection class="QtConcurrent::VoidStoredFunctorCall2"/>
222 222 <rejection class="QtConcurrent::VoidStoredFunctorCall3"/>
223 223 <rejection class="QtConcurrent::VoidStoredFunctorCall4"/>
224 224 <rejection class="QtConcurrent::VoidStoredFunctorCall5"/>
225 225 <rejection class="QtConcurrent::VoidStoredFunctorPointerCall0"/>
226 226 <rejection class="QtConcurrent::VoidStoredFunctorPointerCall1"/>
227 227 <rejection class="QtConcurrent::VoidStoredFunctorPointerCall2"/>
228 228 <rejection class="QtConcurrent::VoidStoredFunctorPointerCall3"/>
229 229 <rejection class="QtConcurrent::VoidStoredFunctorPointerCall4"/>
230 230 <rejection class="QtConcurrent::VoidStoredFunctorPointerCall5"/>
231 231 <rejection class="QtConcurrent::VoidStoredMemberFunctionCall0"/>
232 232 <rejection class="QtConcurrent::VoidStoredMemberFunctionCall1"/>
233 233 <rejection class="QtConcurrent::VoidStoredMemberFunctionCall2"/>
234 234 <rejection class="QtConcurrent::VoidStoredMemberFunctionCall3"/>
235 235 <rejection class="QtConcurrent::VoidStoredMemberFunctionCall4"/>
236 236 <rejection class="QtConcurrent::VoidStoredMemberFunctionCall5"/>
237 237 <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall0"/>
238 238 <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall1"/>
239 239 <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall2"/>
240 240 <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall3"/>
241 241 <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall4"/>
242 242 <rejection class="QtConcurrent::VoidStoredMemberFunctionPointerCall5"/>
243 243
244 244 <rejection class="QMdi"/>
245 245 <rejection class="stdext"/>
246 246 <rejection class="QAlgorithmsPrivate"/>
247 247 <rejection class="QAtomic"/>
248 248 <rejection class="QAtomicPointer"/>
249 249 <rejection class="QAtomicInt"/>
250 250 <rejection class="QBasicAtomicInt"/>
251 251 <rejection class="QBasicAtomic"/>
252 252 <rejection class="QBasicAtomicPointer"/>
253 253 <rejection class="QScopedPointer"/>
254 254 <rejection class="QScopedArrayPointer"/>
255 255 <rejection class="QScopedPointer"/>
256 256 <rejection class="QScopedPointerArrayDeleter"/>
257 257 <rejection class="QScopedPointerDeleter"/>
258 258 <rejection class="QScopedPointerPodDeleter"/>
259 259 <rejection class="QScopedPointerSharedDeleter"/>
260 260 <rejection class="QScopedSharedPointer"/>
261 261 <rejection class="QCustomScopedPointer"/>
262 262 <rejection class="QStringBuilder"/>
263 263
264 264 <rejection class="QBitRef"/>
265 265 <rejection class="QCache"/>
266 266 <rejection class="QContiguousCache"/>
267 267 <rejection class="QContiguousCacheData"/>
268 268 <rejection class="QContiguousCacheTypedData"/>
269 269 <rejection class="QCharRef"/>
270 270 <rejection class="QDebug"/>
271 271 <rejection class="QNoDebug"/>
272 272 <rejection class="QExplicitlySharedDataPointer"/>
273 273 <rejection class="QFlag"/>
274 274 <rejection class="QFlags"/>
275 275 <rejection class="QForeachContainer"/>
276 276 <rejection class="QForeachContainerBase"/>
277 277 <rejection class="QGlobalStatic"/>
278 278 <rejection class="QHash"/>
279 279 <rejection class="QHashData"/>
280 280 <rejection class="QHashDummyNode"/>
281 281 <rejection class="QHashDummyNode"/>
282 282 <rejection class="QHashDummyNode"/>
283 283 <rejection class="QHashDummyNode"/>
284 284 <rejection class="QHashDummyNode"/>
285 285 <rejection class="QHashDummyValue"/>
286 286 <rejection class="QHashIterator"/>
287 287 <rejection class="QHashNode"/>
288 288 <rejection class="QHashNode"/>
289 289 <rejection class="QHashNode"/>
290 290 <rejection class="QHashNode"/>
291 291 <rejection class="QHashNode"/>
292 292 <rejection class="QInternal"/>
293 293 <rejection class="QIncompatibleFlag"/>
294 294 <rejection class="QLinkedList"/>
295 295 <rejection class="QLinkedListData"/>
296 296 <rejection class="QLinkedListIterator"/>
297 297 <rejection class="QLinkedListNode"/>
298 298 <rejection class="QListData"/>
299 299 <rejection class="QListIterator"/>
300 300 <rejection class="QMap"/>
301 301 <rejection class="QMapNode"/>
302 302 <rejection class="QMapPayloadNode"/>
303 303 <rejection class="QMapData"/>
304 304 <rejection class="QMapIterator"/>
305 305 <rejection class="QMetaTypeId"/>
306 306 <rejection class="QMultiHash"/>
307 307 <rejection class="QMultiMap"/>
308 308 <rejection class="QMutableHashIterator"/>
309 309 <rejection class="QMutableLinkedListIterator"/>
310 310 <rejection class="QMutableListIterator"/>
311 311 <rejection class="QMutableMapIterator"/>
312 312 <rejection class="QMutableVectorIterator"/>
313 313 <rejection class="QMutexLocker"/>
314 314 <rejection class="QNoImplicitBoolCast"/>
315 315 <rejection class="QObjectCleanupHandler"/>
316 316 <rejection class="QObjectData"/>
317 317 <rejection class="QObjectUserData"/>
318 318 <rejection class="QPluginLoader"/>
319 319 <rejection class="QPointer"/>
320 320 <rejection class="QReadLocker"/>
321 321 <rejection class="QSet"/>
322 322 <rejection class="QSetIterator"/>
323 323 <rejection class="QSharedData"/>
324 324 <rejection class="QSharedDataPointer"/>
325 325 <rejection class="QStack"/>
326 326 <rejection class="QTextStreamManipulator"/>
327 327 <rejection class="QThreadStorage"/>
328 328 <rejection class="QThreadStorageData"/>
329 329 <rejection class="QTypeInfo"/>
330 330 <rejection class="QTypeInfo"/>
331 331 <rejection class="QVFbKeyData"/>
332 332 <rejection class="QVariantComparisonHelper"/>
333 333 <rejection class="QVectorData"/>
334 334 <rejection class="QVectorIterator"/>
335 335 <rejection class="QVectorTypedData"/>
336 336 <rejection class="QWriteLocker"/>
337 337 <rejection class="QtPrivate"/>
338 338 <rejection class="qGreater"/>
339 339 <rejection class="qLess"/>
340 340 <rejection class="std"/>
341 341 <rejection class="QAbstractFileEngine::ExtensionOption"/>
342 342 <rejection class="QAbstractFileEngine::ExtensionReturn"/>
343 343 <rejection class="QByteArray::Data"/>
344 344 <rejection class="QIntForType"/>
345 345 <rejection class="QList::Node"/>
346 346 <rejection class="QList::const_iterator"/>
347 347 <rejection class="QList::iterator"/>
348 348 <rejection class="QMetaTypeId2"/>
349 349 <rejection class="QMutableSetIterator"/>
350 350 <rejection class="QSubString"/>
351 351 <rejection class="QUintForType"/>
352 352 <rejection class="QtConcurrent::internal"/>
353 353 <rejection class="QByteArrayMatcher::Data"/>
354 354 <rejection class="QStringMatcher::Data"/>
355 355
356 356 <rejection class="StringBuilder"/>
357 357 <rejection class="QConcatenable"/>
358 358 <rejection class="QLatin1Literal"/>
359 359 <rejection class="QIntegerForSizeof"/>
360 360
361 361
362 362 <rejection class="QLocale::Data"/>
363 363 <rejection class="QGlobalStaticDeleter"/>
364 364 <rejection class="QVarLengthArray"/>
365 365
366 366 <!-- DBus -->
367 367 <rejection class="QDBusAbstractAdaptor"/>
368 368 <rejection class="QDBusAbstractInterface"/>
369 369 <rejection class="QDBusArgument"/>
370 370 <rejection class="QDBusConnection"/>
371 371 <rejection class="QDBusConnectionInterface"/>
372 372 <rejection class="QDBusContext"/>
373 373 <rejection class="QDBusError"/>
374 374 <rejection class="QDBusInterface"/>
375 375 <rejection class="QDBusMessage"/>
376 376 <rejection class="QDBusMetaType"/>
377 377 <rejection class="QDBusObjectPath"/>
378 378 <rejection class="QDBusReply"/>
379 379 <rejection class="QDBusServer"/>
380 380 <rejection class="QDBusSignature"/>
381 381 <rejection class="QDBusVariant"/>
382 382
383 383 <rejection class="_Revbidit"/>
384 384 <rejection class="_complex"/>
385 385 <rejection class="_exception"/>
386 386 <rejection class="_iobuf"/>
387 387 <rejection class="_stat"/>
388 388 <rejection class="_wfinddata_t"/>
389 389 <rejection class="exception"/>
390 390 <rejection class="istreambuf_iterator"/>
391 391 <rejection class="ostreambuf_iterator"/>
392 392 <rejection class="reverse_bidirectional_iterator"/>
393 393 <rejection class="reverse_iterator"/>
394 394 <rejection class="stat"/>
395 395 <rejection class="tm"/>
396 396
397 397 <rejection class="Qt" enum-name="Initialization"/>
398 398
399 399 <rejection class="QAbstractEventDispatcher" function-name="filterEvent"/>
400 400 <rejection class="QAbstractEventDispatcher" function-name="setEventFilter"/>
401 401
402 402 <rejection class="QAbstractFileEngine" function-name="extension"/>
403 403 <rejection class="QCoreApplication" function-name="compressEvent"/>
404 404 <rejection class="QCoreApplication" function-name="eventFilter"/>
405 405 <rejection class="QCoreApplication" function-name="filterEvent"/>
406 406 <rejection class="QCoreApplication" function-name="setEventFilter"/>
407 407 <rejection class="QFile" function-name="setDecodingFunction"/>
408 408 <rejection class="QFile" function-name="setEncodingFunction"/>
409 409 <rejection class="QList" function-name="begin"/>
410 410 <rejection class="QList" function-name="constBegin"/>
411 411 <rejection class="QList" function-name="constEnd"/>
412 412 <rejection class="QList" function-name="end"/>
413 413 <rejection class="QList" function-name="erase"/>
414 414 <rejection class="QList" function-name="erase"/>
415 415 <rejection class="QList" function-name="free"/>
416 416 <rejection class="QList" function-name="fromList"/>
417 417 <rejection class="QList" function-name="fromSet"/>
418 418 <rejection class="QList" function-name="fromSet"/>
419 419 <rejection class="QList" function-name="insert"/>
420 420 <rejection class="QList" function-name="malloc"/>
421 421 <rejection class="QList" function-name="node_construct"/>
422 422 <rejection class="QList" function-name="node_copy"/>
423 423 <rejection class="QList" function-name="node_destruct"/>
424 424 <rejection class="QList" function-name="toSet"/>
425 425 <rejection class="QObject" function-name="receivers"/>
426 426 <rejection class="QObject" function-name="findChild"/>
427 427 <rejection class="QObject" function-name="findChildren"/>
428 428 <rejection class="QObject" function-name="setUserData"/>
429 429 <rejection class="QObject" function-name="userData"/>
430 430 <rejection class="QObject" function-name="destroyed"/>
431 431 <rejection class="QObject" function-name="connect"/>
432 432 <rejection class="QObject" function-name="connectNotify"/>
433 433 <rejection class="QObject" function-name="disconnect"/>
434 434 <rejection class="QObject" function-name="disconnectNotify"/>
435 435 <rejection class="QObject" function-name="registerUserData"/>
436 436 <rejection class="QProcess" function-name="pid"/>
437 437 <rejection class="QRegion" function-name="cleanUp"/>
438 438 <rejection class="QSettings" function-name="registerFormat"/>
439 439 <rejection class="QVector" function-name="back"/>
440 440 <rejection class="QVector" function-name="begin"/>
441 441 <rejection class="QVector" function-name="constBegin"/>
442 442 <rejection class="QVector" function-name="constEnd"/>
443 443 <rejection class="QVector" function-name="end"/>
444 444 <rejection class="QVector" function-name="erase"/>
445 445 <rejection class="QVector" function-name="free"/>
446 446 <rejection class="QVector" function-name="front"/>
447 447 <rejection class="QVector" function-name="insert"/>
448 448 <rejection class="QVector" function-name="malloc"/>
449 449 <rejection class="QVector" function-name="alloc"/>
450 450 <rejection class="QVector" function-name="operator+="/>
451 451 <rejection class="QAbstractFileEngineIterator" function-name="entryInfo"/>
452 452 <rejection class="QtConcurrent::ThreadEngineBarrier"/>
453 453
454 454 <rejection class="QAbstractFileEngineIterator" enum-name="EntryInfoType"/>
455 455 <rejection class="QDataStream" enum-name="ByteOrder"/>
456 456
457 457
458 458 <namespace-type name="Qt">
459 459
460 460 <extra-includes>
461 461 <include file-name="QTextDocument" location="global"/>
462 462 </extra-includes>
463 463 </namespace-type>
464 464
465 465 <enum-type name="QDate::MonthNameType"/>
466 466 <enum-type name="QAbstractAnimation::DeletionPolicy"/>
467 467 <enum-type name="QAbstractAnimation::Direction"/>
468 468 <enum-type name="QAbstractAnimation::State"/>
469 469 <enum-type name="QDataStream::FloatingPointPrecision"/>
470 470 <enum-type name="QEasingCurve::Type"/>
471 471 <enum-type name="QHistoryState::HistoryType"/>
472 472 <enum-type name="QState::ChildMode"/>
473 473 <enum-type name="QStateMachine::Error"/>
474 474 <enum-type name="QStateMachine::EventPriority"/>
475 475 <enum-type name="QStateMachine::RestorePolicy"/>
476 476 <enum-type name="Qt::AnchorPoint"/>
477 477 <enum-type name="Qt::CoordinateSystem"/>
478 478 <enum-type name="Qt::GestureState"/>
479 479 <enum-type name="Qt::InputMethodHint" flags="Qt::InputMethodHints"/>
480 480 <enum-type name="Qt::NavigationMode"/>
481 481 <enum-type name="Qt::RenderHint"/>
482 482 <enum-type name="Qt::TileRule"/>
483 483 <enum-type name="Qt::TouchPointState" flags="Qt::TouchPointStates"/>
484 484 <enum-type name="QSysInfo::Endian"/>
485 485 <enum-type name="QSysInfo::Sizes"/>
486 486 <enum-type name="QMetaMethod::Access"/>
487 487 <enum-type name="QMetaMethod::Attributes"/>
488 488 <enum-type name="QMetaMethod::MethodType"/>
489 489 <enum-type name="QSharedMemory::AccessMode"/>
490 490 <enum-type name="QSharedMemory::SharedMemoryError"/>
491 491 <enum-type name="QElapsedTimer::ClockType"/>
492 <enum-type name="QMetaType::Type"/>
493 492
494 493 <enum-type name="QtMsgType">
495 494 <reject-enum-value name="QtSystemMsg"/>
496 495 </enum-type>
497 496
498 497
499 498 <enum-type name="QReadWriteLock::RecursionMode"/>
500 499 <enum-type name="QSystemSemaphore::AccessMode"/>
501 500 <enum-type name="QSystemSemaphore::SystemSemaphoreError"/>
502 501 <enum-type name="QTextBoundaryFinder::BoundaryReason" flags="QTextBoundaryFinder::BoundaryReasons"/>
503 502 <enum-type name="QTextBoundaryFinder::BoundaryType"/>
504 503 <enum-type name="QAbstractFileEngine::Extension" extensible="yes"/>
505 504 <enum-type name="QAbstractFileEngine::FileFlag" flags="QAbstractFileEngine::FileFlags"/>
506 505 <enum-type name="QAbstractFileEngine::FileName"/>
507 506 <enum-type name="QAbstractFileEngine::FileOwner"/>
508 507 <enum-type name="QAbstractFileEngine::FileTime"/>
509 508 <enum-type name="QDataStream::Status"/>
510 509 <enum-type name="QDir::Filter" flags="QDir::Filters"/>
511 510 <enum-type name="QEvent::Type" extensible="yes">
512 511 <reject-enum-value name="ApplicationActivated"/>
513 512 <reject-enum-value name="ApplicationDeactivated"/>
514 513 </enum-type>
515 514 <enum-type name="QEventLoop::ProcessEventsFlag" flags="QEventLoop::ProcessEventsFlags"/>
516 515 <enum-type name="QFile::FileError"/>
517 516 <enum-type name="QFile::MemoryMapFlags"/>
518 517 <enum-type name="QFile::Permission" flags="QFile::Permissions"/>
519 518 <enum-type name="QFile::FileHandleFlag" flags="QFile::FileHandleFlags"/>
520 519 <enum-type name="QIODevice::OpenModeFlag" flags="QIODevice::OpenMode"/>
521 520 <enum-type name="QLibraryInfo::LibraryLocation"/>
522 521 <enum-type name="QLibrary::LoadHint" flags="QLibrary::LoadHints"/>
523 522 <enum-type name="QLocale::FormatType"/>
524 523 <enum-type name="QLocale::NumberOption" flags="QLocale::NumberOptions"/>
525 524 <enum-type name="QLocale::MeasurementSystem"/>
526 525 <enum-type name="QLocale::QuotationStyle"/>
527 526 <enum-type name="QLocale::Script"/>
528 527 <enum-type name="QLocale::CurrencySymbolFormat"/>
529 528 <enum-type name="QMutex::RecursionMode"/>
530 529 <enum-type name="QProcess::ExitStatus"/>
531 530 <enum-type name="QProcess::ProcessChannel"/>
532 531 <enum-type name="QProcess::ProcessChannelMode"/>
533 532 <enum-type name="QProcess::ProcessError"/>
534 533 <enum-type name="QProcess::ProcessState"/>
535 534 <enum-type name="QRegExp::CaretMode"/>
536 535 <enum-type name="QRegExp::PatternSyntax"/>
537 536 <enum-type name="QSettings::Format"/>
538 537 <enum-type name="QSettings::Scope"/>
539 538 <enum-type name="QSettings::Status"/>
540 539 <enum-type name="QSocketNotifier::Type"/>
541 540 <enum-type name="QSystemLocale::QueryType"/>
542 541 <enum-type name="QTextCodec::ConversionFlag" flags="QTextCodec::ConversionFlags"/>
543 542 <enum-type name="QTextStream::FieldAlignment"/>
544 543 <enum-type name="QTextStream::NumberFlag" flags="QTextStream::NumberFlags"/>
545 544 <enum-type name="QTextStream::RealNumberNotation"/>
546 545 <enum-type name="QTextStream::Status"/>
547 546 <enum-type name="QTimeLine::CurveShape"/>
548 547 <enum-type name="QTimeLine::Direction"/>
549 548 <enum-type name="QTimeLine::State"/>
550 549 <enum-type name="QUrl::FormattingOption" flags="QUrl::FormattingOptions"/>
551 550 <enum-type name="QUrl::ParsingMode"/>
552 551 <enum-type name="QUuid::Variant"/>
553 552 <enum-type name="QUuid::Version"/>
554 553 <enum-type name="Qt::SizeHint"/>
555 554 <enum-type name="Qt::SizeMode"/>
556 555 <enum-type name="Qt::WindowFrameSection"/>
557 556 <enum-type name="Qt::Axis"/>
558 557 <enum-type name="Qt::AnchorAttribute"/>
559 558 <enum-type name="Qt::ApplicationAttribute"/>
560 559 <enum-type name="Qt::ArrowType"/>
561 560 <enum-type name="Qt::AspectRatioMode"/>
562 561 <enum-type name="Qt::BGMode"/>
563 562 <enum-type name="Qt::BrushStyle"/>
564 563 <enum-type name="Qt::CaseSensitivity"/>
565 564 <enum-type name="Qt::CheckState"/>
566 565 <enum-type name="Qt::ClipOperation"/>
567 566 <enum-type name="Qt::ConnectionType"/>
568 567 <enum-type name="Qt::ContextMenuPolicy"/>
569 568 <enum-type name="Qt::Corner"/>
570 569 <enum-type name="Qt::DayOfWeek"/>
571 570 <enum-type name="Qt::DockWidgetAreaSizes"/>
572 571 <enum-type name="Qt::DropAction" flags="Qt::DropActions"/>
573 572 <enum-type name="Qt::FillRule"/>
574 573 <enum-type name="Qt::FocusPolicy"/>
575 574 <enum-type name="Qt::FocusReason"/>
576 575 <enum-type name="Qt::GlobalColor"/>
577 576 <enum-type name="Qt::GestureType"/>
578 577 <enum-type name="Qt::GestureFlag" flags="Qt::GestureFlags"/>
579 578 <enum-type name="Qt::CursorMoveStyle"/>
580 579 <enum-type name="Qt::HitTestAccuracy"/>
581 580 <enum-type name="Qt::InputMethodQuery"/>
582 581 <enum-type name="Qt::ItemFlag" flags="Qt::ItemFlags"/>
583 582 <enum-type name="Qt::ItemSelectionMode"/>
584 583 <enum-type name="Qt::KeyboardModifier" flags="Qt::KeyboardModifiers"/>
585 584 <enum-type name="Qt::LayoutDirection"/>
586 585 <enum-type name="Qt::MatchFlag" flags="Qt::MatchFlags"/>
587 586 <enum-type name="Qt::MouseButton" flags="Qt::MouseButtons"/>
588 587 <enum-type name="Qt::Orientation" flags="Qt::Orientations"/>
589 588 <enum-type name="Qt::PenCapStyle"/>
590 589 <enum-type name="Qt::PenJoinStyle"/>
591 590 <enum-type name="Qt::PenStyle"/>
592 591 <enum-type name="Qt::ScrollBarPolicy"/>
593 592 <enum-type name="Qt::ShortcutContext"/>
594 593 <enum-type name="Qt::SortOrder"/>
595 594 <enum-type name="Qt::TextElideMode"/>
596 595 <enum-type name="Qt::TextFlag"/>
597 596 <enum-type name="Qt::TextFormat"/>
598 597 <enum-type name="Qt::TextInteractionFlag" flags="Qt::TextInteractionFlags"/>
599 598 <enum-type name="Qt::TimeSpec"/>
600 599 <enum-type name="Qt::ToolBarAreaSizes"/>
601 600 <enum-type name="Qt::ToolButtonStyle"/>
602 601 <enum-type name="Qt::TransformationMode"/>
603 602 <enum-type name="Qt::UIEffect"/>
604 603 <enum-type name="Qt::WhiteSpaceMode"/>
605 604 <enum-type name="Qt::WindowModality"/>
606 605 <enum-type name="Qt::WindowState" flags="Qt::WindowStates"/>
607 606 <enum-type name="Qt::WindowType" flags="Qt::WindowFlags"/>
608 607 <enum-type name="QDirIterator::IteratorFlag" flags="QDirIterator::IteratorFlags"/>
609 608 <enum-type name="Qt::EventPriority"/>
610 609 <enum-type name="Qt::MaskMode"/>
611 610 <enum-type name="QCryptographicHash::Algorithm"/>
612 611
613 612 <enum-type name="QtConcurrent::ReduceOption" flags="QtConcurrent::ReduceOptions"/>
614 613 <enum-type name="QtConcurrent::ThreadFunctionResult"/>
615 614
616 615
617 616 <enum-type name="QCoreApplication::Encoding">
618 617 <reject-enum-value name="DefaultCodec"/>
619 618 </enum-type>
620 619
621 620 <enum-type name="Qt::AlignmentFlag" flags="Qt::Alignment">
622 621 <reject-enum-value name="AlignLeading"/>
623 622 <reject-enum-value name="AlignTrailing"/>
624 623 </enum-type>
625 624
626 625 <enum-type name="Qt::CursorShape">
627 626 <reject-enum-value name="LastCursor"/>
628 627 </enum-type>
629 628
630 629 <enum-type name="Qt::DateFormat">
631 630 <reject-enum-value name="LocalDate"/>
632 631 </enum-type>
633 632
634 633
635 634 <enum-type name="Qt::ItemDataRole" force-integer="yes">
636 635 <reject-enum-value name="BackgroundColorRole"/>
637 636 <reject-enum-value name="TextColorRole"/>
638 637 </enum-type>
639 638
640 639
641 640 <enum-type name="QDataStream::Version">
642 641 <reject-enum-value name="Qt_4_1"/>
643 642 </enum-type>
644 643
645 644 <enum-type name="QDir::SortFlag" flags="QDir::SortFlags">
646 645 <reject-enum-value name="Unsorted"/>
647 646 </enum-type>
648 647
649 648 <enum-type name="Qt::DockWidgetArea" flags="Qt::DockWidgetAreas">
650 649 <reject-enum-value name="AllDockWidgetAreas"/>
651 650 </enum-type>
652 651
653 652 <enum-type name="Qt::ImageConversionFlag" flags="Qt::ImageConversionFlags">
654 653 <reject-enum-value name="AutoDither"/>
655 654 <reject-enum-value name="ColorOnly"/>
656 655 <reject-enum-value name="DiffuseDither"/>
657 656 <reject-enum-value name="NoAlpha"/>
658 657 <reject-enum-value name="ThresholdAlphaDither"/>
659 658 </enum-type>
660 659
661 660 <enum-type name="Qt::Key">
662 661 <reject-enum-value name="Key_Any"/>
663 662 </enum-type>
664 663
665 664 <enum-type name="QLocale::Language">
666 665 <reject-enum-value name="LastLanguage"/>
667 666 <reject-enum-value name="NorwegianBokmal"/>
668 667 <reject-enum-value name="Nynorsk"/>
669 668 </enum-type>
670 669
671 670 <enum-type name="QLocale::Country">
672 671 <reject-enum-value name="LastCountry"/>
673 672 </enum-type>
674 673
675 674 <enum-type name="Qt::ToolBarArea" flags="Qt::ToolBarAreas">
676 675 <reject-enum-value name="AllToolBarAreas"/>
677 676 </enum-type>
678 677
679 678 <enum-type name="Qt::WidgetAttribute">
680 679 <reject-enum-value name="WA_ForceAcceptDrops"/>
681 680 <reject-enum-value name="WA_NoBackground"/>
682 681 <reject-enum-value name="WA_MacMetalStyle"/>
683 682 </enum-type>
684 683
685 684 <value-type name="QProcessEnvironment"/>
686 685 <value-type name="QBasicTimer"/>
687 686 <value-type name="QByteArrayMatcher">
688 687 <modify-function signature="operator=(QByteArrayMatcher)" remove="all"/>
689 688 </value-type>
690 689
691 690 <value-type name="QDate">
692 691 <modify-function signature="julianToGregorian(uint,int&amp;,int&amp;,int&amp;)">
693 692 <remove/>
694 693 </modify-function>
695 694
696 695 <modify-function signature="setYMD(int, int, int)" remove="all"/>
697 696 <!--### Obsolete in 4.3-->
698 697 </value-type>
699 698
700 699 <value-type name="QDateTime">
701 700 <modify-function signature="operator=(QDateTime)" remove="all"/>
702 701 </value-type>
703 702
704 703 <value-type name="QDir">
705 704 <modify-function signature="QDir(QString,QString,QFlags&lt;QDir::SortFlag&gt;,QFlags&lt;QDir::Filter&gt;)">
706 705 <modify-argument index="3">
707 706 <replace-default-expression with="SortFlag.Name, SortFlag.IgnoreCase"/>
708 707 </modify-argument>
709 708 </modify-function>
710 709 <modify-function signature="operator=(QDir)" remove="all"/>
711 710 <modify-function signature="operator=(QString)" remove="all"/>
712 711 <modify-function signature="addResourceSearchPath(QString)" remove="all"/>
713 712 <!--### Obsolete in 4.3-->
714 713 </value-type>
715 714
716 715 <value-type name="QPoint">
717 716 <modify-function signature="rx()" remove="all"/>
718 717 <modify-function signature="ry()" remove="all"/>
719 718 </value-type>
720 719 <value-type name="QPointF">
721 720 <modify-function signature="rx()" remove="all"/>
722 721 <modify-function signature="ry()" remove="all"/>
723 722 </value-type>
724 723 <enum-type name="QLineF::IntersectType"/>
725 724 <value-type name="QLineF"/>
726 725 <value-type name="QLine"/>
727 726
728 727 <value-type name="QRect">
729 728 <modify-function signature="getCoords(int*,int*,int*,int*)const">
730 729 <remove/>
731 730 </modify-function>
732 731 <modify-function signature="getRect(int*,int*,int*,int*)const">
733 732 <remove/>
734 733 </modify-function>
735 734
736 735 <modify-function signature="intersect(const QRect&amp;)const" remove="all"/>
737 736 <!--### Obsolete in 4.3-->
738 737 <modify-function signature="unite(const QRect&amp;)const" remove="all"/>
739 738 <!--### Obsolete in 4.3-->
740 739 </value-type>
741 740
742 741 <value-type name="QRectF">
743 742 <modify-function signature="getCoords(double*,double*,double*,double*)const">
744 743 <remove/>
745 744 </modify-function>
746 745 <modify-function signature="getRect(double*,double*,double*,double*)const">
747 746 <remove/>
748 747 </modify-function>
749 748
750 749 <modify-function signature="intersect(const QRectF&amp;)const" remove="all"/>
751 750 <!--### Obsolete in 4.3-->
752 751 <modify-function signature="unite(const QRectF&amp;)const" remove="all"/>
753 752 <!--### Obsolete in 4.3-->
754 753 </value-type>
755 754
756 755
757 756 <value-type name="QSize">
758 757 <modify-function signature="operator*=(double)">
759 758 <access modifier="private"/>
760 759 </modify-function>
761 760 <modify-function signature="operator/=(double)">
762 761 <access modifier="private"/>
763 762 </modify-function>
764 763 <modify-function signature="operator+=(QSize)">
765 764 <access modifier="private"/>
766 765 </modify-function>
767 766 <modify-function signature="operator-=(QSize)">
768 767 <access modifier="private"/>
769 768 </modify-function>
770 769 <modify-function signature="rheight()">
771 770 <remove/>
772 771 </modify-function>
773 772 <modify-function signature="rwidth()">
774 773 <remove/>
775 774 </modify-function>
776 775 </value-type>
777 776
778 777 <value-type name="QSizeF">
779 778 <modify-function signature="operator*=(double)">
780 779 <access modifier="private"/>
781 780 </modify-function>
782 781 <modify-function signature="operator/=(double)">
783 782 <access modifier="private"/>
784 783 </modify-function>
785 784 <modify-function signature="operator+=(QSizeF)">
786 785 <access modifier="private"/>
787 786 </modify-function>
788 787 <modify-function signature="operator-=(QSizeF)">
789 788 <access modifier="private"/>
790 789 </modify-function>
791 790 <modify-function signature="rheight()">
792 791 <remove/>
793 792 </modify-function>
794 793 <modify-function signature="rwidth()">
795 794 <remove/>
796 795 </modify-function>
797 796 </value-type>
798 797
799 798 <value-type name="QStringMatcher">
800 799 <modify-function signature="operator=(QStringMatcher)" remove="all"/>
801 800 <modify-function signature="QStringMatcher(const QChar*,int,Qt::CaseSensitivity)" remove="all"/>
802 801 <modify-function signature="indexIn(const QChar*,int,int)const" remove="all"/>
803 802 </value-type>
804 803
805 804 <value-type name="QTime"/>
806 805
807 806 <value-type name="QPersistentModelIndex">
808 807 <modify-function signature="operator=(QPersistentModelIndex)" remove="all"/>
809 808 <modify-function signature="operator=(QModelIndex)" remove="all"/>
810 809 <modify-function signature="internalPointer()const" remove="all"/>
811 810 </value-type>
812 811
813 812 <value-type name="QUuid">
814 813 <modify-function signature="QUuid(const char*)">
815 814 <remove/>
816 815 </modify-function>
817 816 </value-type>
818 817
819 818 <value-type name="QLocale">
820 819 <modify-function signature="toString(unsigned long long) const" remove="all"/>
821 820 <modify-function signature="toString(unsigned short) const" remove="all"/>
822 821 <modify-function signature="toString(unsigned int) const" remove="all"/>
823 822 <modify-function signature="toUInt(QString,bool*,int)const" remove="all"/>
824 823 <modify-function signature="toULongLong(QString,bool*,int)const" remove="all"/>
825 824 <modify-function signature="operator=(QLocale)" remove="all"/>
826 825
827 826 <extra-includes>
828 827 <include file-name="QDate" location="global"/>
829 828 </extra-includes>
830 829
831 830 <inject-code class="native" position="beginning">
832 831 Q_DECLARE_METATYPE(QScriptValue)
833 832 </inject-code>
834 833
835 834 <modify-function signature="toDouble(QString,bool*)const">
836 835 <modify-argument index="2">
837 836 <remove-default-expression/>
838 837 <remove-argument/>
839 838 <conversion-rule class="native">
840 839 <insert-template name="core.prepare_removed_bool*_argument"/>
841 840 </conversion-rule>
842 841 </modify-argument>
843 842 <modify-argument index="return">
844 843 <conversion-rule class="native">
845 844 <insert-template name="core.convert_to_null_or_primitive"/>
846 845 </conversion-rule>
847 846 </modify-argument>
848 847 </modify-function>
849 848
850 849 <modify-function signature="toFloat(QString,bool*)const">
851 850 <modify-argument index="2">
852 851 <remove-default-expression/>
853 852 <remove-argument/>
854 853 <conversion-rule class="native">
855 854 <insert-template name="core.prepare_removed_bool*_argument"/>
856 855 </conversion-rule>
857 856 </modify-argument>
858 857 <modify-argument index="return">
859 858 <conversion-rule class="native">
860 859 <insert-template name="core.convert_to_null_or_primitive"/>
861 860 </conversion-rule>
862 861 </modify-argument>
863 862 </modify-function>
864 863
865 864 <modify-function signature="toInt(QString,bool*,int)const">
866 865 <modify-argument index="2">
867 866 <remove-default-expression/>
868 867 <remove-argument/>
869 868 <conversion-rule class="native">
870 869 <insert-template name="core.prepare_removed_bool*_argument"/>
871 870 </conversion-rule>
872 871 </modify-argument>
873 872 <modify-argument index="return">
874 873 <conversion-rule class="native">
875 874 <insert-template name="core.convert_to_null_or_primitive"/>
876 875 </conversion-rule>
877 876 </modify-argument>
878 877 </modify-function>
879 878
880 879 <modify-function signature="toLongLong(QString,bool*,int)const">
881 880 <modify-argument index="2">
882 881 <remove-default-expression/>
883 882 <remove-argument/>
884 883 <conversion-rule class="native">
885 884 <insert-template name="core.prepare_removed_bool*_argument"/>
886 885 </conversion-rule>
887 886 </modify-argument>
888 887 <modify-argument index="return">
889 888 <conversion-rule class="native">
890 889 QScriptValue %out%;
891 890 if (!__ok)
892 891 %out% = context-&gt;engine()-&gt;nullValue();
893 892 else
894 893 %out% = QScriptValue(context-&gt;engine(), double(%in%)).toObject();
895 894 </conversion-rule>
896 895 </modify-argument>
897 896 </modify-function>
898 897
899 898 <modify-function signature="toShort(QString,bool*,int)const">
900 899 <modify-argument index="2">
901 900 <remove-default-expression/>
902 901 <remove-argument/>
903 902 <conversion-rule class="native">
904 903 <insert-template name="core.prepare_removed_bool*_argument"/>
905 904 </conversion-rule>
906 905 </modify-argument>
907 906 <modify-argument index="return">
908 907 <conversion-rule class="native">
909 908 <insert-template name="core.convert_to_null_or_primitive"/>
910 909 </conversion-rule>
911 910 </modify-argument>
912 911 </modify-function>
913 912
914 913 <modify-function signature="toUShort(QString,bool*,int)const">
915 914 <modify-argument index="2">
916 915 <remove-default-expression/>
917 916 <remove-argument/>
918 917 <conversion-rule class="native">
919 918 <insert-template name="core.prepare_removed_bool*_argument"/>
920 919 </conversion-rule>
921 920 </modify-argument>
922 921 <modify-argument index="return">
923 922 <conversion-rule class="native">
924 923 <insert-template name="core.convert_to_null_or_primitive"/>
925 924 </conversion-rule>
926 925 </modify-argument>
927 926 </modify-function>
928 927 </value-type>
929 928
930 929
931 930 <value-type name="QBitArray">
932 931 <modify-function signature="operator[](int)" remove="all"/>
933 932 <modify-function signature="operator[](int)const" remove="all"/>
934 933 <modify-function signature="operator[](uint)const" remove="all"/>
935 934 <modify-function signature="operator[](uint)" remove="all"/>
936 935
937 936 <modify-function signature="operator&amp;=(QBitArray)" access="private"/>
938 937 <modify-function signature="operator=(QBitArray)" access="private"/>
939 938 <modify-function signature="operator^=(QBitArray)" access="private"/>
940 939 <modify-function signature="operator|=(QBitArray)" access="private"/>
941 940 <modify-function signature="operator~()const" access="private"/>
942 941
943 942 <modify-function signature="at(int)const">
944 943 <modify-argument index="1">
945 944 <conversion-rule class="native">
946 945 <insert-template name="core.convert_int_arg_and_check_range">
947 946 <replace from="%CLASS_NAME%" to="QBitArray"/>
948 947 <replace from="%FUNCTION_NAME%" to="at"/>
949 948 </insert-template>
950 949 </conversion-rule>
951 950 </modify-argument>
952 951 </modify-function>
953 952
954 953 <modify-function signature="clearBit(int)">
955 954 <modify-argument index="1">
956 955 <conversion-rule class="native">
957 956 <insert-template name="core.convert_int_arg_and_check_range">
958 957 <replace from="%CLASS_NAME%" to="QBitArray"/>
959 958 <replace from="%FUNCTION_NAME%" to="clearBit"/>
960 959 </insert-template>
961 960 </conversion-rule>
962 961 </modify-argument>
963 962 </modify-function>
964 963
965 964 <modify-function signature="setBit(int)">
966 965 <modify-argument index="1">
967 966 <conversion-rule class="native">
968 967 <insert-template name="core.convert_int_arg_and_check_range">
969 968 <replace from="%CLASS_NAME%" to="QBitArray"/>
970 969 <replace from="%FUNCTION_NAME%" to="setBit"/>
971 970 </insert-template>
972 971 </conversion-rule>
973 972 </modify-argument>
974 973 </modify-function>
975 974
976 975 <modify-function signature="setBit(int,bool)">
977 976 <modify-argument index="1">
978 977 <conversion-rule class="native">
979 978 <insert-template name="core.convert_int_arg_and_check_range">
980 979 <replace from="%CLASS_NAME%" to="QBitArray"/>
981 980 <replace from="%FUNCTION_NAME%" to="setBit"/>
982 981 </insert-template>
983 982 </conversion-rule>
984 983 </modify-argument>
985 984 </modify-function>
986 985
987 986 <modify-function signature="testBit(int)const">
988 987 <modify-argument index="1">
989 988 <conversion-rule class="native">
990 989 <insert-template name="core.convert_int_arg_and_check_range">
991 990 <replace from="%CLASS_NAME%" to="QBitArray"/>
992 991 <replace from="%FUNCTION_NAME%" to="testBit"/>
993 992 </insert-template>
994 993 </conversion-rule>
995 994 </modify-argument>
996 995 </modify-function>
997 996
998 997 <modify-function signature="toggleBit(int)">
999 998 <modify-argument index="1">
1000 999 <conversion-rule class="native">
1001 1000 <insert-template name="core.convert_int_arg_and_check_range">
1002 1001 <replace from="%CLASS_NAME%" to="QBitArray"/>
1003 1002 <replace from="%FUNCTION_NAME%" to="toggleBit"/>
1004 1003 </insert-template>
1005 1004 </conversion-rule>
1006 1005 </modify-argument>
1007 1006 </modify-function>
1008 1007
1009 1008 <modify-function signature="operator&amp;=(QBitArray)">
1010 1009 <modify-argument index="0" replace-value="this"/>
1011 1010 </modify-function>
1012 1011 <modify-function signature="operator=(QBitArray)">
1013 1012 <modify-argument index="0" replace-value="this"/>
1014 1013 </modify-function>
1015 1014 <modify-function signature="operator^=(QBitArray)">
1016 1015 <modify-argument index="0" replace-value="this"/>
1017 1016 </modify-function>
1018 1017 <modify-function signature="operator|=(QBitArray)">
1019 1018 <modify-argument index="0" replace-value="this"/>
1020 1019 </modify-function>
1021 1020 </value-type>
1022 1021
1023 1022 <object-type name="QReadWriteLock"/>
1024 1023 <object-type name="QDirIterator"/>
1025 1024 <object-type name="QAbstractFileEngineIterator"/>
1026 1025 <object-type name="QAbstractItemModel">
1027 1026 <modify-function signature="rowsAboutToBeInserted(QModelIndex,int,int)" private-signal="yes"/>
1028 1027 <modify-function signature="rowsInserted(QModelIndex,int,int)" private-signal="yes"/>
1029 1028
1030 1029 <modify-function signature="rowsAboutToBeRemoved(QModelIndex,int,int)" private-signal="yes"/>
1031 1030 <modify-function signature="rowsRemoved(QModelIndex,int,int)" private-signal="yes"/>
1032 1031
1033 1032 <modify-function signature="columnsAboutToBeInserted(QModelIndex,int,int)" private-signal="yes"/>
1034 1033 <modify-function signature="columnsInserted(QModelIndex,int,int)" private-signal="yes"/>
1035 1034
1036 1035 <modify-function signature="columnsAboutToBeRemoved(QModelIndex,int,int)" private-signal="yes"/>
1037 1036 <modify-function signature="columnsRemoved(QModelIndex,int,int)" private-signal="yes"/>
1038 1037
1039 1038 <modify-function signature="modelAboutToBeReset()" private-signal="yes"/>
1040 1039 <modify-function signature="modelReset()" private-signal="yes"/>
1041 1040 </object-type>
1042 1041
1043 1042 <object-type name="QAbstractListModel">
1044 1043 <extra-includes>
1045 1044 <include file-name="QStringList" location="global"/>
1046 1045 <include file-name="QSize" location="global"/>
1047 1046 </extra-includes>
1048 1047 </object-type>
1049 1048
1050 1049 <value-type name="QUrl">
1051 1050 <extra-includes>
1052 1051 <include file-name="QStringList" location="global"/>
1053 1052 </extra-includes>
1054 1053 <modify-function signature="operator=(QUrl)" remove="all"/>
1055 1054 <modify-function signature="operator=(QString)" remove="all"/>
1056 1055
1057 1056 <modify-function signature="fromPunycode(const QByteArray&amp;)" remove="all"/>
1058 1057 <!--### Obsolete in 4.3-->
1059 1058 <modify-function signature="toPunycode(const QString&amp;)" remove="all"/>
1060 1059 <!--### Obsolete in 4.3-->
1061 1060 </value-type>
1062 1061
1063 1062 <value-type name="QRegExp">
1064 1063 <extra-includes>
1065 1064 <include file-name="QStringList" location="global"/>
1066 1065 </extra-includes>
1067 1066 <modify-function signature="operator=(QRegExp)" remove="all"/>
1068 1067 <modify-function signature="pos(int)const">
1069 1068 <remove/>
1070 1069 </modify-function>
1071 1070 <modify-function signature="cap(int)const">
1072 1071 <remove/>
1073 1072 </modify-function>
1074 1073 <modify-function signature="capturedTexts()const">
1075 1074 <remove/>
1076 1075 </modify-function>
1077 1076 <modify-function signature="errorString()const">
1078 1077 <remove/>
1079 1078 </modify-function>
1080 1079 </value-type>
1081 1080
1082 1081 <value-type name="QFileInfo">
1083 1082 <extra-includes>
1084 1083 <include file-name="QDateTime" location="global"/>
1085 1084 <include file-name="QDir" location="global"/>
1086 1085 </extra-includes>
1087 1086 <modify-function signature="operator!=(const QFileInfo &amp;)const" remove="all"/>
1088 1087 <modify-function signature="operator==(const QFileInfo &amp;)const" remove="all"/>
1089 1088 <modify-function signature="operator=(QFileInfo)" remove="all"/>
1090 1089 <modify-function signature="setFile(QFile)">
1091 1090 <modify-argument index="1">
1092 1091 <reference-count action="ignore"/>
1093 1092 </modify-argument>
1094 1093 </modify-function>
1095 1094
1096 1095 <modify-function signature="readLink()const" remove="all"/>
1097 1096 <!--### Obsolete in 4.3-->
1098 1097
1099 1098 <modify-function signature="QFileInfo(QFile)">
1100 1099 <modify-argument index="1">
1101 1100 <replace-type modified-type="QFile*"/>
1102 1101 <conversion-rule class="native">
1103 1102 QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
1104 1103 </conversion-rule>
1105 1104 </modify-argument>
1106 1105 </modify-function>
1107 1106 <modify-function signature="setFile(QFile)">
1108 1107 <modify-argument index="1">
1109 1108 <replace-type modified-type="QFile*"/>
1110 1109 <conversion-rule class="native">
1111 1110 QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
1112 1111 </conversion-rule>
1113 1112 </modify-argument>
1114 1113 </modify-function>
1115 1114 </value-type>
1116 1115
1117 1116 <interface-type name="QFactoryInterface"/>
1118 1117
1119 1118 <value-type name="QByteArray">
1120 1119
1121 1120 <extra-includes>
1122 1121 <include file-name="QNoImplicitBoolCast" location="global"/>
1123 1122 </extra-includes>
1124 1123
1125 1124 <!-- removed functions -->
1126 1125 <modify-function signature="begin()" remove="all"/>
1127 1126 <modify-function signature="begin()const" remove="all"/>
1128 1127 <modify-function signature="constBegin()const" remove="all"/>
1129 1128 <modify-function signature="constData()const" remove="all"/>
1130 1129 <modify-function signature="constEnd()const" remove="all"/>
1131 1130 <modify-function signature="count()const" remove="all"/>
1132 1131 <modify-function signature="data()const" remove="all"/>
1133 1132 <modify-function signature="end()" remove="all"/>
1134 1133 <modify-function signature="end()const" remove="all"/>
1135 1134 <modify-function signature="number(uint,int)" remove="all"/>
1136 1135 <modify-function signature="number(unsigned long long,int)" remove="all"/>
1137 1136 <modify-function signature="operator const char *()const" remove="all"/>
1138 1137 <modify-function signature="operator const void *()const" remove="all"/>
1139 1138 <modify-function signature="operator+=(const char*)" remove="all"/>
1140 1139 <modify-function signature="operator!=(QString)const" remove="all"/>
1141 1140 <modify-function signature="operator=(const char*)" remove="all"/>
1142 1141 <modify-function signature="operator[](int)" remove="all"/>
1143 1142 <modify-function signature="operator[](int)const" remove="all"/>
1144 1143 <modify-function signature="operator[](uint)" remove="all"/>
1145 1144 <modify-function signature="operator[](uint)const" remove="all"/>
1146 1145 <modify-function signature="push_back(char)" remove="all"/>
1147 1146 <modify-function signature="push_back(const char*)" remove="all"/>
1148 1147 <modify-function signature="push_front(char)" remove="all"/>
1149 1148 <modify-function signature="push_front(const char*)" remove="all"/>
1150 1149 <modify-function signature="setNum(uint,int)" remove="all"/>
1151 1150 <modify-function signature="setNum(unsigned long long,int)" remove="all"/>
1152 1151 <modify-function signature="setNum(unsigned short,int)" remove="all"/>
1153 1152 <modify-function signature="toLong(bool*, int) const" remove="all"/>
1154 1153 <modify-function signature="toLongLong(bool*, int) const" remove="all"/>
1155 1154 <modify-function signature="toShort(bool*, int) const" remove="all"/>
1156 1155 <modify-function signature="toUInt(bool*, int) const" remove="all"/>
1157 1156 <modify-function signature="toULong(bool*, int) const" remove="all"/>
1158 1157 <modify-function signature="toULongLong(bool*, int) const" remove="all"/>
1159 1158
1160 1159 <!-- functions made private... -->
1161 1160 <modify-function signature="operator=(QByteArray)" access="private"/>
1162 1161 <modify-function signature="operator+=(QString)" remove="all"/>
1163 1162 <modify-function signature="operator+=(char)" remove="all"/>
1164 1163
1165 1164 <inject-code class="pywrap-h">
1166 1165 PyObject* data(QByteArray* b) {
1167 1166 if (b-&gt;data()) {
1168 1167 return PyString_FromStringAndSize(b-&gt;data(), b-&gt;size());
1169 1168 } else {
1170 1169 Py_INCREF(Py_None);
1171 1170 return Py_None;
1172 1171 }
1173 1172 }
1174 1173 </inject-code>
1175 1174
1176 1175 <inject-code class="native" position="beginning">
1177 1176 Q_DECLARE_METATYPE(QScriptValue)
1178 1177 </inject-code>
1179 1178
1180 1179 <modify-function signature="QByteArray(const char*,int)" remove="all"/>
1181 1180 <modify-function signature="QByteArray(const char*)" remove="all"/>
1182 1181
1183 1182 <modify-function signature="at(int)const">
1184 1183 <modify-argument index="1">
1185 1184 <conversion-rule class="native">
1186 1185 <insert-template name="core.convert_int_arg_and_check_range">
1187 1186 <replace from="%CLASS_NAME%" to="QByteArray"/>
1188 1187 <replace from="%FUNCTION_NAME%" to="at"/>
1189 1188 </insert-template>
1190 1189 </conversion-rule>
1191 1190 </modify-argument>
1192 1191 </modify-function>
1193 1192
1194 1193 <modify-function signature="append(const char *)" remove="all"/>
1195 1194 <modify-function signature="append(QByteArray)">
1196 1195 <modify-argument index="0" replace-value="this"/>
1197 1196 </modify-function>
1198 1197 <modify-function signature="append(QString)">
1199 1198 <modify-argument index="0" replace-value="this"/>
1200 1199 </modify-function>
1201 1200 <modify-function signature="append(const char *)" remove="all">
1202 1201 <modify-argument index="0" replace-value="this"/>
1203 1202 </modify-function>
1204 1203 <modify-function signature="append(char)">
1205 1204 <modify-argument index="0" replace-value="this"/>
1206 1205 <rename to="appendByte"/>
1207 1206 </modify-function>
1208 1207
1209 1208 <modify-function signature="count(const char *)const" remove="all"/>
1210 1209
1211 1210 <modify-function signature="data()" remove="all"/>
1212 1211
1213 1212 <modify-function signature="endsWith(const char *)const" remove="all"/>
1214 1213
1215 1214 <modify-function signature="fill(char,int)">
1216 1215 <modify-argument index="0" replace-value="this"/>
1217 1216 </modify-function>
1218 1217
1219 1218 <modify-function signature="indexOf(const char*,int)const" remove="all"/>
1220 1219 <modify-function signature="indexOf(char,int)const">
1221 1220 <rename to="indexOfByte"/>
1222 1221 </modify-function>
1223 1222
1224 1223 <modify-function signature="insert(int,QByteArray)">
1225 1224 <modify-argument index="0" replace-value="this"/>
1226 1225 </modify-function>
1227 1226 <modify-function signature="insert(int,QString)">
1228 1227 <modify-argument index="0" replace-value="this"/>
1229 1228 </modify-function>
1230 1229 <modify-function signature="insert(int,const char *)" remove="all"/>
1231 1230 <modify-function signature="insert(int,char)">
1232 1231 <modify-argument index="0" replace-value="this"/>
1233 1232 <rename to="insertByte"/>
1234 1233 </modify-function>
1235 1234
1236 1235 <modify-function signature="lastIndexOf(const char*,int)const" remove="all"/>
1237 1236 <modify-function signature="lastIndexOf(char,int)const">
1238 1237 <rename to="lastIndexOfByte"/>
1239 1238 </modify-function>
1240 1239
1241 1240 <modify-function signature="prepend(QByteArray)">
1242 1241 <modify-argument index="0" replace-value="this"/>
1243 1242 </modify-function>
1244 1243 <modify-function signature="prepend(const char *)" remove="all"/>
1245 1244 <modify-function signature="prepend(char)">
1246 1245 <modify-argument index="0" replace-value="this"/>
1247 1246 <rename to="prependByte"/>
1248 1247 </modify-function>
1249 1248
1250 1249 <modify-function signature="remove(int,int)">
1251 1250 <modify-argument index="0" replace-value="this"/>
1252 1251 </modify-function>
1253 1252
1254 1253 <modify-function signature="replace(int,int,QByteArray)">
1255 1254 <modify-argument index="0" replace-value="this"/>
1256 1255 </modify-function>
1257 1256 <modify-function signature="replace(int,int,const char *)" remove="all"/>
1258 1257 <modify-function signature="replace(QByteArray,QByteArray)">
1259 1258 <modify-argument index="0" replace-value="this"/>
1260 1259 </modify-function>
1261 1260 <modify-function signature="replace(const char*,QByteArray)" remove="all"/>
1262 1261 <modify-function signature="replace(QByteArray,const char *)" remove="all"/>
1263 1262 <modify-function signature="replace(QString,QByteArray)">
1264 1263 <modify-argument index="0" replace-value="this"/>
1265 1264 </modify-function>
1266 1265 <modify-function signature="replace(QString,const char *)" remove="all"/>
1267 1266 <modify-function signature="replace(const char *,const char *)" remove="all"/>
1268 1267 <modify-function signature="replace(char,QByteArray)">
1269 1268 <modify-argument index="0" replace-value="this"/>
1270 1269 </modify-function>
1271 1270 <modify-function signature="replace(char,QString)">
1272 1271 <modify-argument index="0" replace-value="this"/>
1273 1272 </modify-function>
1274 1273 <modify-function signature="replace(char,const char *)" remove="all"/>
1275 1274 <modify-function signature="replace(char,char)">
1276 1275 <modify-argument index="0" replace-value="this"/>
1277 1276 </modify-function>
1278 1277
1279 1278 <modify-function signature="startsWith(const char *)const" remove="all"/>
1280 1279
1281 1280 <modify-function signature="fromRawData(const char*,int)" remove="all"/>
1282 1281
1283 1282 <modify-function signature="number(int,int)">
1284 1283 <rename to="fromInt"/>
1285 1284 </modify-function>
1286 1285 <modify-function signature="number(uint,int)">
1287 1286 <rename to="fromUInt"/>
1288 1287 </modify-function>
1289 1288 <modify-function signature="number(qlonglong,int)">
1290 1289 <rename to="fromLongLong"/>
1291 1290 </modify-function>
1292 1291 <modify-function signature="number(qulonglong,int)">
1293 1292 <rename to="fromULongLong"/>
1294 1293 </modify-function>
1295 1294
1296 1295 <modify-function signature="setNum(int,int)">
1297 1296 <modify-argument index="0" replace-value="this"/>
1298 1297 <rename to="setInt"/>
1299 1298 </modify-function>
1300 1299 <modify-function signature="setNum(uint,int)">
1301 1300 <modify-argument index="0" replace-value="this"/>
1302 1301 <rename to="setUInt"/>
1303 1302 </modify-function>
1304 1303 <modify-function signature="setNum(short,int)">
1305 1304 <modify-argument index="0" replace-value="this"/>
1306 1305 <rename to="setShort"/>
1307 1306 </modify-function>
1308 1307 <modify-function signature="setNum(ushort,int)">
1309 1308 <modify-argument index="0" replace-value="this"/>
1310 1309 <rename to="setUShort"/>
1311 1310 </modify-function>
1312 1311 <modify-function signature="setNum(qlonglong,int)">
1313 1312 <modify-argument index="0" replace-value="this"/>
1314 1313 <rename to="setLongLong"/>
1315 1314 </modify-function>
1316 1315 <modify-function signature="setNum(qulonglong,int)">
1317 1316 <modify-argument index="0" replace-value="this"/>
1318 1317 <rename to="setULongLong"/>
1319 1318 </modify-function>
1320 1319 <modify-function signature="setNum(double,char,int)">
1321 1320 <modify-argument index="0" replace-value="this"/>
1322 1321 <rename to="setDouble"/>
1323 1322 </modify-function>
1324 1323 <modify-function signature="setNum(float,char,int)">
1325 1324 <modify-argument index="0" replace-value="this"/>
1326 1325 <rename to="setFloat"/>
1327 1326 </modify-function>
1328 1327
1329 1328 <modify-function signature="toDouble(bool*)const">
1330 1329 <modify-argument index="1">
1331 1330 <remove-default-expression/>
1332 1331 <remove-argument/>
1333 1332 <conversion-rule class="native">
1334 1333 <insert-template name="core.prepare_removed_bool*_argument"/>
1335 1334 </conversion-rule>
1336 1335 </modify-argument>
1337 1336 <modify-argument index="return">
1338 1337 <conversion-rule class="native">
1339 1338 <insert-template name="core.convert_to_null_or_primitive"/>
1340 1339 </conversion-rule>
1341 1340 </modify-argument>
1342 1341 </modify-function>
1343 1342
1344 1343 <modify-function signature="toFloat(bool*)const">
1345 1344 <modify-argument index="1">
1346 1345 <remove-default-expression/>
1347 1346 <remove-argument/>
1348 1347 <conversion-rule class="native">
1349 1348 <insert-template name="core.prepare_removed_bool*_argument"/>
1350 1349 </conversion-rule>
1351 1350 </modify-argument>
1352 1351 <modify-argument index="return">
1353 1352 <conversion-rule class="native">
1354 1353 <insert-template name="core.convert_to_null_or_primitive"/>
1355 1354 </conversion-rule>
1356 1355 </modify-argument>
1357 1356 </modify-function>
1358 1357
1359 1358 <modify-function signature="toInt(bool*,int)const">
1360 1359 <modify-argument index="1">
1361 1360 <remove-default-expression/>
1362 1361 <remove-argument/>
1363 1362 <conversion-rule class="native">
1364 1363 <insert-template name="core.prepare_removed_bool*_argument"/>
1365 1364 </conversion-rule>
1366 1365 </modify-argument>
1367 1366 <modify-argument index="return">
1368 1367 <conversion-rule class="native">
1369 1368 <insert-template name="core.convert_to_null_or_primitive"/>
1370 1369 </conversion-rule>
1371 1370 </modify-argument>
1372 1371 </modify-function>
1373 1372
1374 1373 <modify-function signature="toUShort(bool*,int)const">
1375 1374 <modify-argument index="1">
1376 1375 <remove-default-expression/>
1377 1376 <remove-argument/>
1378 1377 <conversion-rule class="native">
1379 1378 <insert-template name="core.prepare_removed_bool*_argument"/>
1380 1379 </conversion-rule>
1381 1380 </modify-argument>
1382 1381 <modify-argument index="return">
1383 1382 <conversion-rule class="native">
1384 1383 <insert-template name="core.convert_to_null_or_primitive"/>
1385 1384 </conversion-rule>
1386 1385 </modify-argument>
1387 1386 </modify-function>
1388 1387 </value-type>
1389 1388
1390 1389 <value-type name="QTextBoundaryFinder">
1391 1390 <modify-function signature="QTextBoundaryFinder(QTextBoundaryFinder::BoundaryType,const QChar*,int,unsigned char*,int)" remove="all"/>
1392 1391 <modify-function signature="operator=(QTextBoundaryFinder)" remove="all"/>
1393 1392 </value-type>
1394 1393
1395 1394 <value-type name="QEasingCurve">
1396 1395 <modify-function signature="customType()const" remove="all"/>
1397 1396 <modify-function signature="setCustomType(double)" remove="all"/>
1398 1397 </value-type>
1399 1398
1400 1399 <object-type name="QAbstractAnimation"/>
1401 1400 <object-type name="QVariantAnimation"/>
1402 1401 <object-type name="QAnimationGroup"/>
1403 1402 <object-type name="QPauseAnimation"/>
1404 1403 <object-type name="QParallelAnimationGroup"/>
1405 1404 <object-type name="QSequentialAnimationGroup"/>
1406 1405 <object-type name="QPropertyAnimation"/>
1407 1406
1408 1407 <object-type name="QAbstractState"/>
1409 1408 <object-type name="QAbstractTransition"/>
1410 1409 <object-type name="QState"/>
1411 1410 <object-type name="QStateMachine"/>
1412 1411 <object-type name="QHistoryState"/>
1413 1412 <object-type name="QSignalTransition"/>
1414 1413 <object-type name="QEventTransition"/>
1415 1414 <object-type name="QFinalState"/>
1416 1415
1417 1416 <object-type name="QXmlStreamEntityResolver"/>
1418 1417 <object-type name="QAbstractEventDispatcher">
1419 1418 <extra-includes>
1420 1419 <include file-name="QPair" location="global"/>
1421 1420 </extra-includes>
1422 1421 </object-type>
1423 1422 <object-type name="QEventLoop"/>
1424 1423 <object-type name="QFile">
1425 1424 <modify-function signature="readLink()const" remove="all"/>
1426 1425 <!--### Obsolete in 4.3-->
1427 1426 <modify-function signature="readLink(QString)" remove="all"/>
1428 1427 <!--### Obsolete in 4.3-->
1429 1428 <modify-function signature="map(long long,long long,QFile::MemoryMapFlags)" remove="all"/>
1430 1429 <!-- Can't provide same API and performance -->
1431 1430 <modify-function signature="unmap(unsigned char*)" remove="all"/>
1432 1431 <!-- Can't provide same API and performance -->
1433 1432
1434 1433 <modify-function signature="open(int,QFlags&lt;QIODevice::OpenModeFlag&gt;)" remove="all"/>
1435 1434 <modify-function signature="decodeName(const char*)" remove="all"/>
1436 1435 <modify-function signature="map(qint64,qint64,QFile::MemoryMapFlags)" remove="all"/>
1437 1436 <modify-function signature="unmap(uchar*)" remove="all"/>
1438 1437 </object-type>
1439 1438
1440 1439 <object-type name="QIODevice">
1441 1440 <modify-function signature="peek(char *,qint64)" remove="all"/>
1442 1441 <modify-function signature="read(char *,qint64)" remove="all"/>
1443 1442 <modify-function signature="readLine(char *,qint64)" remove="all"/>
1444 1443 <modify-function signature="write(const char *,qint64)" remove="all"/>
1445 1444 </object-type>
1446 1445 <object-type name="QStateMachine::SignalEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::StateMachineSignal"/>
1447 1446 <object-type name="QStateMachine::WrappedEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::StateMachineWrapped"/>
1448 1447
1449 1448 <object-type name="QCryptographicHash">
1450 1449 <modify-function signature="addData(const char*,int)" remove="all"/>
1451 1450 </object-type>
1452 1451 <object-type name="QLibraryInfo"/>
1453 1452 <object-type name="QMutex"/>
1454 1453 <object-type name="QSemaphore"/>
1455 1454 <object-type name="QSocketNotifier"/>
1456 1455 <object-type name="QSystemLocale"/>
1457 1456 <object-type name="QTemporaryFile">
1458 1457 <modify-function signature="fileName()const" rename="uniqueFilename"/>
1459 1458
1460 1459 <modify-function signature="createLocalFile(QFile&amp;)">
1461 1460 <modify-argument index="1">
1462 1461 <replace-type modified-type="QFile*"/>
1463 1462 <conversion-rule class="native">
1464 1463 QFile &amp; %out% = *qscriptvalue_cast&lt;QFile*&gt;(%in%);
1465 1464 </conversion-rule>
1466 1465 </modify-argument>
1467 1466 </modify-function>
1468 1467 </object-type>
1469 1468 <object-type name="QMimeData">
1470 1469 <extra-includes>
1471 1470 <include file-name="QStringList" location="global"/>
1472 1471 <include file-name="QUrl" location="global"/>
1473 1472 </extra-includes>
1474 1473 </object-type>
1475 1474 <object-type name="QTextCodec">
1476 1475
1477 1476 <modify-function signature="setCodecForTr(QTextCodec*)">
1478 1477 <access modifier="private"/>
1479 1478 <modify-argument index="1">
1480 1479 <reference-count action="set" variable-name="__rcCodecForTr"/>
1481 1480 </modify-argument>
1482 1481 </modify-function>
1483 1482 <modify-function signature="setCodecForCStrings(QTextCodec*)">
1484 1483 <modify-argument index="1">
1485 1484 <reference-count action="set" variable-name="__rcCodecForCStrings"/>
1486 1485 </modify-argument>
1487 1486 </modify-function>
1488 1487 <modify-function signature="setCodecForLocale(QTextCodec*)">
1489 1488 <modify-argument index="1">
1490 1489 <reference-count action="set" variable-name="__rcCodecForLocale"/>
1491 1490 </modify-argument>
1492 1491 </modify-function>
1493 1492
1494 1493
1495 1494 <modify-function signature="codecForTr()">
1496 1495 <remove/>
1497 1496 </modify-function>
1498 1497
1499 1498 <modify-function signature="QTextCodec()">
1500 1499 <modify-argument index="-1">
1501 1500 <define-ownership class="java" owner="c++"/>
1502 1501 </modify-argument>
1503 1502 </modify-function>
1504 1503
1505 1504 <modify-function signature="fromUnicode(const QChar*,int,QTextCodec::ConverterState*)const">
1506 1505 <remove/>
1507 1506 </modify-function>
1508 1507
1509 1508 <modify-function signature="toUnicode(const char*,int,QTextCodec::ConverterState*)const">
1510 1509 <remove/>
1511 1510 </modify-function>
1512 1511
1513 1512 <modify-function signature="toUnicode(const char*)const">
1514 1513 <remove/>
1515 1514 </modify-function>
1516 1515 </object-type>
1517 1516
1518 1517 <object-type name="QTextDecoder">
1519 1518 <modify-function signature="toUnicode(const char*,int)">
1520 1519 <remove/>
1521 1520 </modify-function>
1522 1521 <modify-function signature="toUnicode(QString*,const char*,int)" remove="all"/>
1523 1522 </object-type>
1524 1523 <object-type name="QTextEncoder">
1525 1524 <modify-function signature="fromUnicode(const QChar*,int)">
1526 1525 <remove/>
1527 1526 </modify-function>
1528 1527 </object-type>
1529 1528 <object-type name="QTimeLine"/>
1530 1529 <object-type name="QTranslator">
1531 1530 <modify-function signature="translate(const char*,const char*,const char*,int)const">
1532 1531 <remove/>
1533 1532 </modify-function>
1534 1533 </object-type>
1535 1534
1536 1535 <object-type name="QWaitCondition"/>
1537 1536
1538 1537 <object-type name="QFileSystemWatcher">
1539 1538 <extra-includes>
1540 1539 <include file-name="QStringList" location="global"/>
1541 1540 </extra-includes>
1542 1541 </object-type>
1543 1542
1544 1543 <object-type name="QTextCodec::ConverterState">
1545 1544 <include file-name="QTextCodec" location="global"/>
1546 1545 </object-type>
1547 1546
1548 1547 <object-type name="QBuffer">
1549 1548 <modify-function signature="buffer()">
1550 1549 <remove/>
1551 1550 </modify-function>
1552 1551 <modify-function signature="connectNotify(const char *)" remove="all"/>
1553 1552 <modify-function signature="disconnectNotify(const char *)" remove="all"/>
1554 1553
1555 1554 <!-- ### modify to return value by pointer? -->
1556 1555 <modify-function signature="buffer()const" remove="all"/>
1557 1556 <modify-function signature="data()const" remove="all"/>
1558 1557
1559 1558 <modify-function signature="setData(const char*,int)" remove="all"/>
1560 1559 </object-type>
1561 1560
1562 1561 <object-type name="QTimer"/>
1563 1562
1564 1563 <object-type name="QAbstractFileEngineHandler">
1565 1564 <modify-function signature="create(const QString &amp;) const">
1566 1565 <modify-argument index="return">
1567 1566 <define-ownership owner="c++" class="shell"/>
1568 1567 </modify-argument>
1569 1568 </modify-function>
1570 1569 </object-type>
1571 1570
1572 1571 <object-type name="QAbstractFileEngine::MapExtensionOption"/>
1573 1572 <object-type name="QAbstractFileEngine::MapExtensionReturn"/>
1574 1573 <object-type name="QAbstractFileEngine::UnMapExtensionOption"/>
1575 1574 <object-type name="QAbstractFileEngine">
1576 1575 <extra-includes>
1577 1576 <include file-name="QDateTime" location="global"/>
1578 1577 </extra-includes>
1579 1578 <modify-function signature="map(long long,long long,QFile::MemoryMapFlags)" remove="all"/>
1580 1579 <modify-function signature="unmap(unsigned char*)" remove="all"/>
1581 1580 </object-type>
1582 1581
1583 1582 <object-type name="QProcess">
1584 1583 <modify-function signature="readChannelMode()const" remove="all"/>
1585 1584 <!--### Obsolete in 4.3-->
1586 1585 <modify-function signature="setReadChannelMode(QProcess::ProcessChannelMode)" remove="all"/>
1587 1586 <!--### Obsolete in 4.3-->
1588 1587 </object-type>
1589 1588
1590 1589 <object-type name="QSignalMapper">
1591 1590 <modify-function signature="mapped(const QString &amp;)">
1592 1591 <rename to="mappedString"/>
1593 1592 </modify-function>
1594 1593 <modify-function signature="mapped(int)">
1595 1594 <rename to="mappedInteger"/>
1596 1595 </modify-function>
1597 1596 <modify-function signature="mapped(QObject *)">
1598 1597 <rename to="mappedQObject"/>
1599 1598 </modify-function>
1600 1599 <modify-function signature="mapped(QWidget *)" remove="all"/>
1601 1600
1602 1601 <modify-function signature="mapping(QWidget*)const" remove="all"/>
1603 1602
1604 1603 <modify-function signature="setMapping(QObject*,QWidget*)" remove="all"/>
1605 1604
1606 1605 <!-- ### overloads -->
1607 1606 <modify-function signature="mapping(int)const">
1608 1607 <rename to="mappingById"/>
1609 1608 </modify-function>
1610 1609 <modify-function signature="mapping(QString)const">
1611 1610 <rename to="mappingByString"/>
1612 1611 </modify-function>
1613 1612 <modify-function signature="mapping(QObject*)const">
1614 1613 <rename to="mappingByObject"/>
1615 1614 </modify-function>
1616 1615 <modify-function signature="setMapping(QObject*,int)">
1617 1616 <rename to="setMappingById"/>
1618 1617 </modify-function>
1619 1618 <modify-function signature="setMapping(QObject*,QString)">
1620 1619 <rename to="setMappingByString"/>
1621 1620 </modify-function>
1622 1621 <modify-function signature="setMapping(QObject*,QObject*)">
1623 1622 <rename to="setMappingByObject"/>
1624 1623 </modify-function>
1625 1624 </object-type>
1626 1625
1627 1626 <object-type name="QObject">
1628 1627 <modify-function signature="childEvent(QChildEvent*)">
1629 1628 <modify-argument index="1" invalidate-after-use="yes"/>
1630 1629 </modify-function>
1631 1630 <modify-function signature="customEvent(QEvent*)">
1632 1631 <modify-argument index="1" invalidate-after-use="yes"/>
1633 1632 </modify-function>
1634 1633 <modify-function signature="event(QEvent*)">
1635 1634 <modify-argument index="1" invalidate-after-use="yes"/>
1636 1635 </modify-function>
1637 1636 <modify-function signature="eventFilter(QObject*,QEvent*)">
1638 1637 <modify-argument index="2" invalidate-after-use="yes"/>
1639 1638 </modify-function>
1640 1639 <modify-function signature="timerEvent(QTimerEvent*)">
1641 1640 <modify-argument index="1" invalidate-after-use="yes"/>
1642 1641 </modify-function>
1643 1642
1644 1643 <modify-function signature="installEventFilter(QObject*)">
1645 1644 <modify-argument index="1">
1646 1645 <reference-count action="add" variable-name="__rcEventFilters"/>
1647 1646 </modify-argument>
1648 1647 </modify-function>
1649 1648 <modify-function signature="removeEventFilter(QObject*)">
1650 1649 <modify-argument index="1">
1651 1650 <reference-count action="remove" variable-name="__rcEventFilters"/>
1652 1651 </modify-argument>
1653 1652 </modify-function>
1654 1653 <modify-function signature="setParent(QObject*)">
1655 1654 <modify-argument index="1">
1656 1655 <reference-count action="ignore"/>
1657 1656 </modify-argument>
1658 1657 </modify-function>
1659 1658
1660 1659 <modify-function signature="deleteLater()">
1661 1660 <rename to="disposeLater"/>
1662 1661 </modify-function>
1663 1662
1664 1663 <modify-function signature="inherits(const char*)const">
1665 1664 <remove/>
1666 1665 </modify-function>
1667 1666
1668 1667 <modify-function signature="property(const char*)const">
1669 1668 <access modifier="private"/>
1670 1669 </modify-function>
1671 1670
1672 1671 <modify-function signature="setProperty(const char*,QVariant)">
1673 1672 <access modifier="private"/>
1674 1673 </modify-function>
1675 1674
1676 1675
1677 1676 <extra-includes>
1678 1677 <include file-name="QVarLengthArray" location="global"/>
1679 1678 </extra-includes>
1680 1679
1681 1680
1682 1681 <modify-function signature="property(const char*)const">
1683 1682 <modify-argument index="1">
1684 1683 <replace-type modified-type="QString"/>
1685 1684 <conversion-rule class="native">
1686 1685 <insert-template name="core.convert_string_arg_to_char*"/>
1687 1686 </conversion-rule>
1688 1687 </modify-argument>
1689 1688 </modify-function>
1690 1689
1691 1690 <modify-function signature="setProperty(const char*,QVariant)">
1692 1691 <modify-argument index="1">
1693 1692 <replace-type modified-type="QString"/>
1694 1693 <conversion-rule class="native">
1695 1694 <insert-template name="core.convert_string_arg_to_char*"/>
1696 1695 </conversion-rule>
1697 1696 </modify-argument>
1698 1697 </modify-function>
1699 1698
1700 1699 <modify-function signature="inherits(const char*)const">
1701 1700 <modify-argument index="1">
1702 1701 <replace-type modified-type="QString"/>
1703 1702 <conversion-rule class="native">
1704 1703 <insert-template name="core.convert_string_arg_to_char*"/>
1705 1704 </conversion-rule>
1706 1705 </modify-argument>
1707 1706 </modify-function>
1708 1707 </object-type>
1709 1708
1710 1709 <object-type name="QCoreApplication">
1711 1710 <extra-includes>
1712 1711 <include file-name="QStringList" location="global"/>
1713 1712 </extra-includes>
1714 1713
1715 1714 <modify-function signature="argv()" remove="all"/>
1716 1715 <!-- Obsolete -->
1717 1716 <modify-function signature="argc()" remove="all"/>
1718 1717 <!-- Obsolete -->
1719 1718
1720 1719 <modify-function signature="notify(QObject*,QEvent*)">
1721 1720 <modify-argument index="2" invalidate-after-use="yes"/>
1722 1721 </modify-function>
1723 1722
1724 1723
1725 1724 <modify-function signature="QCoreApplication(int &amp;, char **)">
1726 1725 <access modifier="private"/>
1727 1726 </modify-function>
1728 1727 <modify-function signature="QCoreApplication(int &amp;, char **, int)" remove="all"/>
1729 1728 <modify-function signature="removePostedEvents(QObject*)">
1730 1729 <modify-argument index="1">
1731 1730 <reference-count action="ignore"/>
1732 1731 </modify-argument>
1733 1732 </modify-function>
1734 1733 <modify-function signature="removePostedEvents(QObject*,int)">
1735 1734 <modify-argument index="1">
1736 1735 <reference-count action="ignore"/>
1737 1736 </modify-argument>
1738 1737 </modify-function>
1739 1738
1740 1739 <modify-function signature="installTranslator(QTranslator *)">
1741 1740 <modify-argument index="1">
1742 1741 <reference-count action="add" variable-name="__rcTranslators"/>
1743 1742 </modify-argument>
1744 1743 </modify-function>
1745 1744
1746 1745 <modify-function signature="removeTranslator(QTranslator *)">
1747 1746 <modify-argument index="1">
1748 1747 <reference-count action="remove" variable-name="__rcTranslators"/>
1749 1748 </modify-argument>
1750 1749 </modify-function>
1751 1750
1752 1751
1753 1752 <modify-function signature="postEvent(QObject*,QEvent*)">
1754 1753 <modify-argument index="2">
1755 1754 <define-ownership class="java" owner="c++"/>
1756 1755 </modify-argument>
1757 1756 </modify-function>
1758 1757
1759 1758 <modify-function signature="QCoreApplication(int &amp;, char **)" remove="all"/>
1760 1759 <!-- ### arguments() causes a warning: "QScriptValue::setProperty(arguments): cannot change flags of a native property" -->
1761 1760 <modify-function signature="arguments()" remove="all"/>
1762 1761 <modify-function signature="translate(const char*,const char*,const char*,QCoreApplication::Encoding,int)">
1763 1762 <modify-argument index="1">
1764 1763 <replace-type modified-type="QString"/>
1765 1764 <conversion-rule class="native">
1766 1765 <insert-template name="core.convert_string_arg_to_char*"/>
1767 1766 </conversion-rule>
1768 1767 </modify-argument>
1769 1768 <modify-argument index="2">
1770 1769 <replace-type modified-type="QString"/>
1771 1770 <conversion-rule class="native">
1772 1771 <insert-template name="core.convert_string_arg_to_char*"/>
1773 1772 </conversion-rule>
1774 1773 </modify-argument>
1775 1774 <modify-argument index="3">
1776 1775 <replace-type modified-type="QString"/>
1777 1776 <conversion-rule class="native">
1778 1777 <insert-template name="core.convert_string_arg_to_char*"/>
1779 1778 </conversion-rule>
1780 1779 </modify-argument>
1781 1780 </modify-function>
1782 1781 <modify-function signature="translate(const char *,const char *,const char *,QCoreApplication::Encoding)">
1783 1782 <modify-argument index="1">
1784 1783 <replace-type modified-type="QString"/>
1785 1784 <conversion-rule class="native">
1786 1785 <insert-template name="core.convert_string_arg_to_char*"/>
1787 1786 </conversion-rule>
1788 1787 </modify-argument>
1789 1788 <modify-argument index="2">
1790 1789 <replace-type modified-type="QString"/>
1791 1790 <conversion-rule class="native">
1792 1791 <insert-template name="core.convert_string_arg_to_char*"/>
1793 1792 </conversion-rule>
1794 1793 </modify-argument>
1795 1794 <modify-argument index="3">
1796 1795 <replace-type modified-type="QString"/>
1797 1796 <conversion-rule class="native">
1798 1797 <insert-template name="core.convert_string_arg_to_char*"/>
1799 1798 </conversion-rule>
1800 1799 </modify-argument>
1801 1800 </modify-function>
1802 1801
1803 1802 </object-type>
1804 1803
1805 1804 <object-type name="QSettings">
1806 1805 <extra-includes>
1807 1806 <include file-name="QStringList" location="global"/>
1808 1807 </extra-includes>
1809 1808
1810 1809 <modify-function signature="setIniCodec(QTextCodec*)">
1811 1810 <modify-argument index="1">
1812 1811 <reference-count action="set" variable-name="__rcIniCodec"/>
1813 1812 </modify-argument>
1814 1813 </modify-function>
1815 1814
1816 1815 <modify-function signature="setSystemIniPath(const QString&amp;)" remove="all"/>
1817 1816 <!--### Obsolete in 4.3-->
1818 1817 <modify-function signature="setUserIniPath(const QString&amp;)" remove="all"/>
1819 1818 <!--### Obsolete in 4.3-->
1820 1819 </object-type>
1821 1820
1822 1821 <object-type name="QEvent" polymorphic-base="yes" polymorphic-id-expression="%1-&gt;type() == QEvent::None"/>
1823 1822 <object-type name="QChildEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::ChildAdded || %1-&gt;type() == QEvent::ChildPolished || %1-&gt;type() == QEvent::ChildRemoved">
1824 1823 <modify-field name="c" read="false" write="false"/>
1825 1824 </object-type>
1826 1825 <object-type name="QTimerEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::Timer"/>
1827 1826 <object-type name="QDynamicPropertyChangeEvent" polymorphic-id-expression="%1-&gt;type() == QEvent::DynamicPropertyChange"/>
1828 1827
1829 1828 <object-type name="QDataStream">
1830 1829 <modify-function signature="setDevice(QIODevice*)">
1831 1830 <modify-argument index="1">
1832 1831 <reference-count action="set" variable-name="__rcDevice"/>
1833 1832 </modify-argument>
1834 1833 </modify-function>
1835 1834 <modify-function signature="unsetDevice()">
1836 1835 <inject-code position="end">
1837 1836 __rcDevice = null;
1838 1837 </inject-code>
1839 1838 </modify-function>
1840 1839
1841 1840
1842 1841 <modify-function signature="operator&lt;&lt;(const char*)">
1843 1842 <remove/>
1844 1843 </modify-function>
1845 1844 <modify-function signature="operator&lt;&lt;(unsigned char)">
1846 1845 <remove/>
1847 1846 </modify-function>
1848 1847 <modify-function signature="operator&lt;&lt;(unsigned int)">
1849 1848 <remove/>
1850 1849 </modify-function>
1851 1850 <modify-function signature="operator&lt;&lt;(unsigned long long)">
1852 1851 <remove/>
1853 1852 </modify-function>
1854 1853 <modify-function signature="operator&lt;&lt;(unsigned short)">
1855 1854 <remove/>
1856 1855 </modify-function>
1857 1856
1858 1857 <modify-function signature="operator&gt;&gt;(char &amp;*)">
1859 1858 <remove/>
1860 1859 </modify-function>
1861 1860 <modify-function signature="operator&gt;&gt;(uint&amp;)">
1862 1861 <remove/>
1863 1862 </modify-function>
1864 1863 <modify-function signature="operator&gt;&gt;(unsigned char&amp;)">
1865 1864 <remove/>
1866 1865 </modify-function>
1867 1866 <modify-function signature="operator&gt;&gt;(unsigned long long&amp;)">
1868 1867 <remove/>
1869 1868 </modify-function>
1870 1869
1871 1870 <modify-function signature="readRawData(char*,int)">
1872 1871 <remove/>
1873 1872 </modify-function>
1874 1873 <modify-function signature="readBytes(char&amp;*,uint&amp;)">
1875 1874 <remove/>
1876 1875 </modify-function>
1877 1876 <modify-function signature="writeRawData(const char*,int)">
1878 1877 <remove/>
1879 1878 </modify-function>
1880 1879 <modify-function signature="writeBytes(const char*,uint)">
1881 1880 <remove/>
1882 1881 </modify-function>
1883 1882
1884 1883 <modify-function signature="operator&gt;&gt;(signed char&amp;)" remove="all"/>
1885 1884 <modify-function signature="operator&lt;&lt;(signed char)" remove="all"/>
1886 1885
1887 1886 <modify-function signature="operator&lt;&lt;(bool)">
1888 1887 <rename to="writeBoolean"/>
1889 1888 <modify-argument index="0" replace-value="this"/>
1890 1889 </modify-function>
1891 1890 <modify-function signature="operator&lt;&lt;(unsigned char)">
1892 1891 <modify-argument index="0" replace-value="this"/>
1893 1892 <rename to="writeByte"/>
1894 1893 </modify-function>
1895 1894 <modify-function signature="operator&lt;&lt;(int)">
1896 1895 <rename to="writeInt"/>
1897 1896 <modify-argument index="0" replace-value="this"/>
1898 1897 </modify-function>
1899 1898 <modify-function signature="operator&lt;&lt;(qint64)">
1900 1899 <rename to="writeLongLong"/>
1901 1900 <modify-argument index="0" replace-value="this"/>
1902 1901 </modify-function>
1903 1902 <modify-function signature="operator&lt;&lt;(float)">
1904 1903 <rename to="writeFloat"/>
1905 1904 <modify-argument index="0" replace-value="this"/>
1906 1905 </modify-function>
1907 1906 <modify-function signature="operator&lt;&lt;(double)">
1908 1907 <rename to="writeDouble"/>
1909 1908 <modify-argument index="0" replace-value="this"/>
1910 1909 </modify-function>
1911 1910 <modify-function signature="operator&lt;&lt;(short)">
1912 1911 <rename to="writeShort"/>
1913 1912 <modify-argument index="0" replace-value="this"/>
1914 1913 </modify-function>
1915 1914
1916 1915 <modify-function signature="operator&gt;&gt;(bool &amp;)">
1917 1916 <rename to="readBoolean"/>
1918 1917 <modify-argument index="1">
1919 1918 <remove-argument/>
1920 1919 <conversion-rule class="native">
1921 1920 bool __result;
1922 1921 bool &amp; %out% = __result;
1923 1922 </conversion-rule>
1924 1923 </modify-argument>
1925 1924 <modify-argument index="0" replace-value="void">
1926 1925 <conversion-rule class="native">
1927 1926 bool %out% = __result;
1928 1927 </conversion-rule>
1929 1928 </modify-argument>
1930 1929 </modify-function>
1931 1930 <modify-function signature="operator&gt;&gt;(unsigned char &amp;)">
1932 1931 <rename to="readByte"/>
1933 1932 <modify-argument index="1">
1934 1933 <remove-argument/>
1935 1934 <conversion-rule class="native">
1936 1935 unsigned char __result;
1937 1936 unsigned char &amp; %out% = __result;
1938 1937 </conversion-rule>
1939 1938 </modify-argument>
1940 1939 <modify-argument index="0" replace-value="void">
1941 1940 <conversion-rule class="native">
1942 1941 int %out% = __result;
1943 1942 </conversion-rule>
1944 1943 </modify-argument>
1945 1944 </modify-function>
1946 1945 <modify-function signature="operator&gt;&gt;(int &amp;)">
1947 1946 <rename to="readInt"/>
1948 1947 <modify-argument index="1">
1949 1948 <remove-argument/>
1950 1949 <conversion-rule class="native">
1951 1950 int __result;
1952 1951 int &amp; %out% = __result;
1953 1952 </conversion-rule>
1954 1953 </modify-argument>
1955 1954 <modify-argument index="0" replace-value="void">
1956 1955 <conversion-rule class="native">
1957 1956 int %out% = __result;
1958 1957 </conversion-rule>
1959 1958 </modify-argument>
1960 1959 </modify-function>
1961 1960 <modify-function signature="operator&gt;&gt;(uint &amp;)">
1962 1961 <rename to="readUInt"/>
1963 1962 <modify-argument index="1">
1964 1963 <remove-argument/>
1965 1964 <conversion-rule class="native">
1966 1965 uint __result;
1967 1966 uint &amp; %out% = __result;
1968 1967 </conversion-rule>
1969 1968 </modify-argument>
1970 1969 <modify-argument index="0" replace-value="void">
1971 1970 <conversion-rule class="native">
1972 1971 uint %out% = __result;
1973 1972 </conversion-rule>
1974 1973 </modify-argument>
1975 1974 </modify-function>
1976 1975 <modify-function signature="operator&gt;&gt;(qint64 &amp;)">
1977 1976 <rename to="readLongLong"/>
1978 1977 <modify-argument index="1">
1979 1978 <remove-argument/>
1980 1979 <conversion-rule class="native">
1981 1980 qint64 __result;
1982 1981 qint64 &amp; %out% = __result;
1983 1982 </conversion-rule>
1984 1983 </modify-argument>
1985 1984 <modify-argument index="0" replace-value="void">
1986 1985 <conversion-rule class="native">
1987 1986 qint64 %out% = __result;
1988 1987 </conversion-rule>
1989 1988 </modify-argument>
1990 1989 </modify-function>
1991 1990 <modify-function signature="operator&gt;&gt;(unsigned long long &amp;)">
1992 1991 <rename to="readULongLong"/>
1993 1992 <modify-argument index="1">
1994 1993 <remove-argument/>
1995 1994 <conversion-rule class="native">
1996 1995 unsigned long long __result;
1997 1996 unsigned long long &amp; %out% = __result;
1998 1997 </conversion-rule>
1999 1998 </modify-argument>
2000 1999 <modify-argument index="0" replace-value="void">
2001 2000 <conversion-rule class="native">
2002 2001 unsigned long long %out% = __result;
2003 2002 </conversion-rule>
2004 2003 </modify-argument>
2005 2004 </modify-function>
2006 2005 <modify-function signature="operator&gt;&gt;(float &amp;)">
2007 2006 <rename to="readFloat"/>
2008 2007 <modify-argument index="1">
2009 2008 <remove-argument/>
2010 2009 <conversion-rule class="native">
2011 2010 float __result;
2012 2011 float &amp; %out% = __result;
2013 2012 </conversion-rule>
2014 2013 </modify-argument>
2015 2014 <modify-argument index="0" replace-value="void">
2016 2015 <conversion-rule class="native">
2017 2016 float %out% = __result;
2018 2017 </conversion-rule>
2019 2018 </modify-argument>
2020 2019 </modify-function>
2021 2020 <modify-function signature="operator&gt;&gt;(double &amp;)">
2022 2021 <rename to="readDouble"/>
2023 2022 <modify-argument index="1">
2024 2023 <remove-argument/>
2025 2024 <conversion-rule class="native">
2026 2025 double __result;
2027 2026 double &amp; %out% = __result;
2028 2027 </conversion-rule>
2029 2028 </modify-argument>
2030 2029 <modify-argument index="0" replace-value="void">
2031 2030 <conversion-rule class="native">
2032 2031 double %out% = __result;
2033 2032 </conversion-rule>
2034 2033 </modify-argument>
2035 2034 </modify-function>
2036 2035 <modify-function signature="operator&gt;&gt;(short &amp;)">
2037 2036 <rename to="readShort"/>
2038 2037 <modify-argument index="1">
2039 2038 <remove-argument/>
2040 2039 <conversion-rule class="native">
2041 2040 short __result;
2042 2041 short &amp; %out% = __result;
2043 2042 </conversion-rule>
2044 2043 </modify-argument>
2045 2044 <modify-argument index="0" replace-value="void">
2046 2045 <conversion-rule class="native">
2047 2046 short %out% = __result;
2048 2047 </conversion-rule>
2049 2048 </modify-argument>
2050 2049 </modify-function>
2051 2050 <modify-function signature="operator&gt;&gt;(unsigned short &amp;)">
2052 2051 <rename to="readUShort"/>
2053 2052 <modify-argument index="1">
2054 2053 <remove-argument/>
2055 2054 <conversion-rule class="native">
2056 2055 unsigned short __result;
2057 2056 unsigned short &amp; %out% = __result;
2058 2057 </conversion-rule>
2059 2058 </modify-argument>
2060 2059 <modify-argument index="0" replace-value="void">
2061 2060 <conversion-rule class="native">
2062 2061 unsigned short %out% = __result;
2063 2062 </conversion-rule>
2064 2063 </modify-argument>
2065 2064 </modify-function>
2066 2065 </object-type>
2067 2066
2068 2067 <object-type name="QFSFileEngine">
2069 2068 <extra-includes>
2070 2069 <include file-name="QDateTime" location="global"/>
2071 2070 </extra-includes>
2072 2071 </object-type>
2073 2072
2074 2073 <object-type name="QTextStream">
2075 2074 <modify-function signature="QTextStream(QByteArray *, QFlags&lt;QIODevice::OpenModeFlag&gt;)">
2076 2075 <remove/>
2077 2076 </modify-function>
2078 2077 <modify-function signature="QTextStream(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)">
2079 2078 <remove/>
2080 2079 </modify-function>
2081 2080 <modify-function signature="operator&gt;&gt;(QChar&amp;)">
2082 2081 <remove/>
2083 2082 </modify-function>
2084 2083 <modify-function signature="operator&lt;&lt;(const void*)">
2085 2084 <remove/>
2086 2085 </modify-function>
2087 2086 <modify-function signature="operator&lt;&lt;(unsigned int)">
2088 2087 <remove/>
2089 2088 </modify-function>
2090 2089 <modify-function signature="operator&lt;&lt;(unsigned long long)">
2091 2090 <remove/>
2092 2091 </modify-function>
2093 2092 <modify-function signature="operator&lt;&lt;(const QChar &amp;)">
2094 2093 <remove/>
2095 2094 </modify-function>
2096 2095 <modify-function signature="operator&lt;&lt;(unsigned long)">
2097 2096 <remove/>
2098 2097 </modify-function>
2099 2098 <modify-function signature="operator&lt;&lt;(signed long)">
2100 2099 <remove/>
2101 2100 </modify-function>
2102 2101 <modify-function signature="operator&lt;&lt;(const char*)">
2103 2102 <remove/>
2104 2103 </modify-function>
2105 2104 <modify-function signature="operator&lt;&lt;(unsigned short)">
2106 2105 <remove/>
2107 2106 </modify-function>
2108 2107 <modify-function signature="operator&lt;&lt;(const QByteArray&amp;)">
2109 2108 <remove/>
2110 2109 </modify-function>
2111 2110 <modify-function signature="operator&gt;&gt;(unsigned long long&amp;)">
2112 2111 <remove/>
2113 2112 </modify-function>
2114 2113 <modify-function signature="operator&gt;&gt;(uint&amp;)">
2115 2114 <remove/>
2116 2115 </modify-function>
2117 2116 <modify-function signature="operator&gt;&gt;(ulong&amp;)">
2118 2117 <remove/>
2119 2118 </modify-function>
2120 2119 <modify-function signature="setString(QString*,QFlags&lt;QIODevice::OpenModeFlag&gt;)">
2121 2120 <remove/>
2122 2121 </modify-function>
2123 2122 <modify-function signature="string()const">
2124 2123 <remove/>
2125 2124 </modify-function>
2126 2125 <modify-function signature="operator&gt;&gt;(signed long&amp;)">
2127 2126 <remove/>
2128 2127 </modify-function>
2129 2128 <modify-function signature="operator&gt;&gt;(char*)">
2130 2129 <remove/>
2131 2130 </modify-function>
2132 2131 <modify-function signature="operator&gt;&gt;(QByteArray&amp;)">
2133 2132 <remove/>
2134 2133 </modify-function>
2135 2134 <modify-function signature="operator&gt;&gt;(QString&amp;)">
2136 2135 <remove/>
2137 2136 </modify-function>
2138 2137 <modify-function signature="operator&gt;&gt;(unsigned short&amp;)">
2139 2138 <remove/>
2140 2139 </modify-function>
2141 2140 <modify-function signature="operator&lt;&lt;(const QString&amp;)">
2142 2141 <remove/>
2143 2142 </modify-function>
2144 2143
2145 2144
2146 2145 <modify-function signature="setCodec(QTextCodec *)">
2147 2146 <modify-argument index="1">
2148 2147 <reference-count action="set" variable-name="__rcCodec"/>
2149 2148 </modify-argument>
2150 2149 </modify-function>
2151 2150
2152 2151 <modify-function signature="QTextStream(QIODevice *)">
2153 2152 <modify-argument index="1">
2154 2153 <reference-count action="set" variable-name="__rcDevice"/>
2155 2154 </modify-argument>
2156 2155 </modify-function>
2157 2156 <modify-function signature="setDevice(QIODevice *)">
2158 2157 <modify-argument index="1">
2159 2158 <reference-count action="set" variable-name="__rcDevice"/>
2160 2159 </modify-argument>
2161 2160 </modify-function>
2162 2161
2163 2162 <modify-function signature="setCodec(const char *)">
2164 2163 <modify-argument index="1">
2165 2164 <replace-type modified-type="QString"/>
2166 2165 <conversion-rule class="native">
2167 2166 <insert-template name="core.convert_string_arg_to_char*"/>
2168 2167 </conversion-rule>
2169 2168 </modify-argument>
2170 2169 </modify-function>
2171 2170
2172 2171 <modify-function signature="operator&lt;&lt;(QBool)">
2173 2172 <rename to="writeBoolean"/>
2174 2173 <modify-argument index="0" replace-value="this"/>
2175 2174 </modify-function>
2176 2175 <modify-function signature="operator&lt;&lt;(char)">
2177 2176 <modify-argument index="0" replace-value="this"/>
2178 2177 <rename to="writeByte"/>
2179 2178 </modify-function>
2180 2179 <modify-function signature="operator&lt;&lt;(signed int)">
2181 2180 <rename to="writeInt"/>
2182 2181 <modify-argument index="0" replace-value="this"/>
2183 2182 </modify-function>
2184 2183 <modify-function signature="operator&lt;&lt;(qlonglong)">
2185 2184 <rename to="writeLongLong"/>
2186 2185 <modify-argument index="0" replace-value="this"/>
2187 2186 </modify-function>
2188 2187 <modify-function signature="operator&lt;&lt;(float)">
2189 2188 <rename to="writeFloat"/>
2190 2189 <modify-argument index="0" replace-value="this"/>
2191 2190 </modify-function>
2192 2191 <modify-function signature="operator&lt;&lt;(double)">
2193 2192 <rename to="writeDouble"/>
2194 2193 <modify-argument index="0" replace-value="this"/>
2195 2194 </modify-function>
2196 2195 <modify-function signature="operator&lt;&lt;(signed short)">
2197 2196 <rename to="writeShort"/>
2198 2197 <modify-argument index="0" replace-value="this"/>
2199 2198 </modify-function>
2200 2199 <modify-function signature="operator&lt;&lt;(const QByteArray&amp;)">
2201 2200 <rename to="writeByteArray"/>
2202 2201 <modify-argument index="0" replace-value="this"/>
2203 2202 </modify-function>
2204 2203 <modify-function signature="operator&lt;&lt;(const QString&amp;)">
2205 2204 <rename to="writeString"/>
2206 2205 <modify-argument index="0" replace-value="this"/>
2207 2206 </modify-function>
2208 2207
2209 2208 <modify-function signature="operator&gt;&gt;(char&amp;)">
2210 2209 <rename to="readByte"/>
2211 2210 <modify-argument index="1">
2212 2211 <remove-argument/>
2213 2212 <conversion-rule class="native">
2214 2213 char __result;
2215 2214 char &amp; %out% = __result;
2216 2215 </conversion-rule>
2217 2216 </modify-argument>
2218 2217 <modify-argument index="0" replace-value="void">
2219 2218 <conversion-rule class="native">
2220 2219 int %out% = __result;
2221 2220 </conversion-rule>
2222 2221 </modify-argument>
2223 2222 </modify-function>
2224 2223 <modify-function signature="operator&gt;&gt;(signed short&amp;)">
2225 2224 <rename to="readShort"/>
2226 2225 <modify-argument index="1">
2227 2226 <remove-argument/>
2228 2227 <conversion-rule class="native">
2229 2228 short __result;
2230 2229 short &amp; %out% = __result;
2231 2230 </conversion-rule>
2232 2231 </modify-argument>
2233 2232 <modify-argument index="0" replace-value="void">
2234 2233 <conversion-rule class="native">
2235 2234 short %out% = __result;
2236 2235 </conversion-rule>
2237 2236 </modify-argument>
2238 2237 </modify-function>
2239 2238 <modify-function signature="operator&gt;&gt;(signed int&amp;)">
2240 2239 <rename to="readInt"/>
2241 2240 <modify-argument index="1">
2242 2241 <remove-argument/>
2243 2242 <conversion-rule class="native">
2244 2243 int __result;
2245 2244 int &amp; %out% = __result;
2246 2245 </conversion-rule>
2247 2246 </modify-argument>
2248 2247 <modify-argument index="0" replace-value="void">
2249 2248 <conversion-rule class="native">
2250 2249 int %out% = __result;
2251 2250 </conversion-rule>
2252 2251 </modify-argument>
2253 2252 </modify-function>
2254 2253 <modify-function signature="operator&gt;&gt;(unsigned short&amp;)">
2255 2254 <rename to="readUShort"/>
2256 2255 <modify-argument index="1">
2257 2256 <remove-argument/>
2258 2257 <conversion-rule class="native">
2259 2258 unsigned short __result;
2260 2259 unsigned short &amp; %out% = __result;
2261 2260 </conversion-rule>
2262 2261 </modify-argument>
2263 2262 <modify-argument index="0" replace-value="void">
2264 2263 <conversion-rule class="native">
2265 2264 unsigned short %out% = __result;
2266 2265 </conversion-rule>
2267 2266 </modify-argument>
2268 2267 </modify-function>
2269 2268 <modify-function signature="operator&gt;&gt;(unsigned int&amp;)">
2270 2269 <rename to="readUInt"/>
2271 2270 <modify-argument index="1">
2272 2271 <remove-argument/>
2273 2272 <conversion-rule class="native">
2274 2273 unsigned int __result;
2275 2274 unsigned int &amp; %out% = __result;
2276 2275 </conversion-rule>
2277 2276 </modify-argument>
2278 2277 <modify-argument index="0" replace-value="void">
2279 2278 <conversion-rule class="native">
2280 2279 unsigned int %out% = __result;
2281 2280 </conversion-rule>
2282 2281 </modify-argument>
2283 2282 </modify-function>
2284 2283 <modify-function signature="operator&gt;&gt;(qlonglong&amp;)">
2285 2284 <rename to="readLongLong"/>
2286 2285 <modify-argument index="1">
2287 2286 <remove-argument/>
2288 2287 <conversion-rule class="native">
2289 2288 qlonglong __result;
2290 2289 qlonglong &amp; %out% = __result;
2291 2290 </conversion-rule>
2292 2291 </modify-argument>
2293 2292 <modify-argument index="0" replace-value="void">
2294 2293 <conversion-rule class="native">
2295 2294 qlonglong %out% = __result;
2296 2295 </conversion-rule>
2297 2296 </modify-argument>
2298 2297 </modify-function>
2299 2298 <modify-function signature="operator&gt;&gt;(qulonglong&amp;)">
2300 2299 <rename to="readULongLong"/>
2301 2300 <modify-argument index="1">
2302 2301 <remove-argument/>
2303 2302 <conversion-rule class="native">
2304 2303 qulonglong __result;
2305 2304 qulonglong &amp; %out% = __result;
2306 2305 </conversion-rule>
2307 2306 </modify-argument>
2308 2307 <modify-argument index="0" replace-value="void">
2309 2308 <conversion-rule class="native">
2310 2309 qulonglong %out% = __result;
2311 2310 </conversion-rule>
2312 2311 </modify-argument>
2313 2312 </modify-function>
2314 2313 <modify-function signature="operator&gt;&gt;(float&amp;)">
2315 2314 <rename to="readFloat"/>
2316 2315 <modify-argument index="1">
2317 2316 <remove-argument/>
2318 2317 <conversion-rule class="native">
2319 2318 float __result;
2320 2319 float &amp; %out% = __result;
2321 2320 </conversion-rule>
2322 2321 </modify-argument>
2323 2322 <modify-argument index="0" replace-value="void">
2324 2323 <conversion-rule class="native">
2325 2324 float %out% = __result;
2326 2325 </conversion-rule>
2327 2326 </modify-argument>
2328 2327 </modify-function>
2329 2328 <modify-function signature="operator&gt;&gt;(double&amp;)">
2330 2329 <rename to="readDouble"/>
2331 2330 <modify-argument index="1">
2332 2331 <remove-argument/>
2333 2332 <conversion-rule class="native">
2334 2333 double __result;
2335 2334 double &amp; %out% = __result;
2336 2335 </conversion-rule>
2337 2336 </modify-argument>
2338 2337 <modify-argument index="0" replace-value="void">
2339 2338 <conversion-rule class="native">
2340 2339 double %out% = __result;
2341 2340 </conversion-rule>
2342 2341 </modify-argument>
2343 2342 </modify-function>
2344 2343
2345 2344 <modify-function signature="operator&lt;&lt;(qulonglong)" remove="all"/>
2346 2345 <modify-function signature="operator&gt;&gt;(qulonglong&amp;)" remove="all"/>
2347 2346 </object-type>
2348 2347
2349 2348 <object-type name="QSystemSemaphore"/>
2350 2349
2351 2350 <namespace-type name="QtConcurrent" target-type="class">
2352 2351 <extra-includes>
2353 2352 <include file-name="qtconcurrentreducekernel.h" location="global"/>
2354 2353 <include file-name="qtconcurrentthreadengine.h" location="global"/>
2355 2354 </extra-includes>
2356 2355 </namespace-type>
2357 2356
2358 2357 <value-type name="QFuture" generate="no">
2359 2358 <modify-function signature="operator T() const" remove="all"/>
2360 2359 <modify-function signature="operator=(const QFuture &amp;)" remove="all"/>
2361 2360 </value-type>
2362 2361 <value-type name="QtJambiVoidFuture" java-name="QFutureVoid">
2363 2362 <modify-function signature="resultCount()const" remove="all"/>
2364 2363 <modify-function signature="isResultReadyAt(int)const" remove="all"/>
2365 2364 </value-type>
2366 2365 <value-type name="QtJambiFuture" java-name="QFuture" generic-class="yes"/>
2367 2366
2368 2367 <object-type name="QFutureWatcherBase">
2369 2368 <modify-function signature="connectNotify(const char *)" remove="all"/>
2370 2369 <modify-function signature="disconnectNotify(const char *)" remove="all"/>
2371 2370 </object-type>
2372 2371 <object-type name="QtJambiVoidFutureWatcher" java-name="QFutureWatcherVoid"/>
2373 2372
2374 2373 <object-type name="QFutureWatcher" generate="no">
2375 2374 <modify-function signature="future()const" remove="all"/>
2376 2375 </object-type>
2377 2376 <object-type name="QtJambiFutureWatcher" java-name="QFutureWatcher" generic-class="yes"/>
2378 2377
2379 2378 <object-type name="QFutureSynchronizer" generate="no"/>
2380 2379 <object-type name="QtJambiFutureSynchronizer" generic-class="yes" java-name="QFutureSynchronizer"/>
2381 2380 <object-type name="QtJambiVoidFutureSynchronizer" java-name="QFutureSynchronizerVoid"/>
2382 2381 <object-type name="QThreadPool"/>
2383 2382
2384 2383 <object-type name="QFutureIterator" generate="no">
2385 2384 <modify-function signature="operator=(const QFuture&amp;)" remove="all"/>
2386 2385 </object-type>
2387 2386 <object-type name="QtJambiFutureIterator" generic-class="yes" java-name="QFutureIterator"/>
2388 2387 <object-type name="QRunnable"/>
2389 2388
2390 2389 <object-type name="QSysInfo"/>
2391 2390 <object-type name="QLibrary"/>
2392 2391 <object-type name="QResource"/>
2393 2392 <object-type name="QSharedMemory"/>
2394 2393 <object-type name="QMetaObject"/>
2395 2394 <object-type name="QMetaMethod"/>
2396 2395 <object-type name="QMetaEnum"/>
2397 2396 <object-type name="QMetaProperty"/>
2398 2397 <object-type name="QMetaClassInfo"/>
2399 2398 <object-type name="QElapsedTimer"/>
2400 2399 <object-type name="QMetaType"/>
2401 2400
2402 2401 <!-- Inefficient hash codes -->
2403 2402 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QUuid' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2404 2403 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QLocale' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2405 2404 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QFuture' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2406 2405 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QRegExp' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2407 2406 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QFutureVoid' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2408 2407 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QUrl' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2409 2408 <suppress-warning text="WARNING(MetaJavaBuilder) :: Class 'QProcessEnvironment' has equals operators but no qHash() function. Hashcode of objects will consistently be 0."/>
2410 2409
2411 2410 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::selectIteration', unmatched parameter type 'T'"/>
2412 2411 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QVariantAnimation::registerInterpolator', unmatched parameter type 'QVariantAnimation::Interpolator'"/>
2413 2412
2414 2413 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'Qt::Initialization'"/>
2415 2414 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'std::*'"/>
2416 2415 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type '*Private\*'"/>
2417 2416 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type '*Private&amp;'"/>
2418 2417 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'FILE\*'"/>
2419 2418 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QByteArray::Data\*'"/>
2420 2419 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QTSMFC'"/>
2421 2420 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QTSMFI'"/>
2422 2421 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QAbstractFileEngine::ExtensionOption const\*'"/>
2423 2422 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QAbstractFileEngine::Iterator\*'"/>
2424 2423 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QDataStream::ByteOrder'"/>
2425 2424 <suppress-warning text="WARNING(MetaJavaBuilder) :: visibility of function '*' modified in class '*'"/>
2426 2425 <suppress-warning text="WARNING(MetaJavaBuilder) :: hiding of function '*' in class '*'"/>
2427 2426 <suppress-warning text="WARNING(CppImplGenerator) :: protected function '*' in final class '*'"/>
2428 2427 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QPointer&lt;*&gt;'"/>
2429 2428 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping * unmatched *type 'QVector&lt;*&gt;'"/>
2430 2429 <suppress-warning text="* private virtual function '*' in 'QAbstractListModel'"/>
2431 2430 <suppress-warning text="* private virtual function '*' in 'QAbstractTableModel'"/>
2432 2431 <suppress-warning text="* private virtual function '*' in 'QListWidget'"/>
2433 2432 <suppress-warning text="* private virtual function '*' in 'QTreeWidget'"/>
2434 2433 <suppress-warning text="* private virtual function '*' in 'QFontDialog'"/>
2435 2434 <suppress-warning text="* private virtual function '*' in 'QTableWidget'"/>
2436 2435 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcherBase::futureInterface', unmatched return type 'QFutureInterfaceBase&amp;'"/>
2437 2436 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcherBase::futureInterface', unmatched return type 'QFutureInterfaceBase const&amp;'"/>
2438 2437 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcher::futureInterface', unmatched return type 'QFutureInterfaceBase&amp;'"/>
2439 2438 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFutureWatcher::futureInterface', unmatched return type 'QFutureInterfaceBase const&amp;'"/>
2440 2439 <suppress-warning text="WARNING(MetaJavaBuilder) :: unknown operator 'T'"/>
2441 2440 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::constBegin', unmatched return type 'const_iterator'"/>
2442 2441 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::end', unmatched return type 'const_iterator'"/>
2443 2442 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::constEnd', unmatched return type 'const_iterator'"/>
2444 2443 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::QFuture', unmatched parameter type 'QFutureInterface&lt;T&gt;*'"/>
2445 2444 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QFuture::begin', unmatched return type 'const_iterator'"/>
2446 2445 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::advance', unmatched parameter type 'It&amp;'"/>
2447 2446 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'Sequence'"/>
2448 2447 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'QList&lt;U&gt;'"/>
2449 2448 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'QList&lt;MapFunctor::result_type&gt;'"/>
2450 2449 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMapped', unmatched return type 'OutputSequence'"/>
2451 2450 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filtered', unmatched parameter type 'Iterator'"/>
2452 2451 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filtered', unmatched parameter type 'Sequence const&amp;'"/>
2453 2452 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filter', unmatched parameter type 'Sequence&amp;'"/>
2454 2453 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFiltered', unmatched return type 'ThreadEngineStarter&lt;qValueType&lt;Iterator&gt;::value_type&gt;"/>
2455 2454 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFiltered', unmatched return type 'ThreadEngineStarter&lt;Sequence::value_type&gt;'"/>
2456 2455 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFiltered', unmatched return type 'ThreadEngineStarter&lt;Iterator::value_type&gt;'"/>
2457 2456 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'V'"/>
2458 2457 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'W'"/>
2459 2458 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'ResultType'"/>
2460 2459 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMappedReduced', unmatched return type 'U'"/>
2461 2460 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFiltered', unmatched return type 'OutputSequence'"/>
2462 2461 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFiltered', unmatched return type 'Sequence'"/>
2463 2462 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startMappedReduced', unmatched return type 'ThreadEngineStarter&lt;ResultType&gt;'"/>
2464 2463 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilteredReduced', unmatched return type 'U'"/>
2465 2464 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilteredReduced', unmatched return type 'V'"/>
2466 2465 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilteredReduced', unmatched return type 'ResultType'"/>
2467 2466 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startMap', unmatched return type 'ThreadEngineStarter&lt;void&gt;'"/>
2468 2467 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startThreadEngine', unmatched return type 'ThreadEngineStarter&lt;ThreadEngine::ResultType&gt;'"/>
2469 2468 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mappedReduced', unmatched parameter type 'Iterator'"/>
2470 2469 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mappedReduced', unmatched parameter type 'Sequence const&amp;'"/>
2471 2470 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filteredReduced', unmatched parameter type 'Iterator'"/>
2472 2471 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filteredReduced', unmatched parameter type 'Sequence const&amp;'"/>
2473 2472 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::map', unmatched parameter type 'Iterator'"/>
2474 2473 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::map', unmatched parameter type 'Sequence&amp;'"/>
2475 2474 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::filterInternal', unmatched return type 'ThreadEngineStarter&lt;void&gt;'"/>
2476 2475 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::createFunctor', unmatched return type 'QtConcurrent::SelectMemberFunctor0lt;T,Class&gt;::type'"/>
2477 2476 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::createFunctor', unmatched return type 'SelectFunctor0&lt;T,T&gt;::type'"/>
2478 2477 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mapped', unmatched parameter type 'Iterator'"/>
2479 2478 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::mapped', unmatched parameter type 'Sequence const&amp;'"/>
2480 2479 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMap', unmatched parameter type 'Iterator'"/>
2481 2480 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingMap', unmatched parameter type 'Sequence&amp;'"/>
2482 2481 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startMapped', unmatched return type 'QtConcurrent::ThreadEngineStarter&lt;T&gt;'"/>
2483 2482 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::startFilteredReduced', unmatched return type 'ThreadEngineStarter&lt;ResultType&gt;'"/>
2484 2483 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'Class const*'"/>
2485 2484 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'Class*'"/>
2486 2485 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'Class const&amp;'"/>
2487 2486 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'FunctionObject*'"/>
2488 2487 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'FunctionObject'"/>
2489 2488 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::run', unmatched parameter type 'T'"/>
2490 2489 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::blockingFilter', unmatched parameter type 'Sequence&amp;'"/>
2491 2490 <suppress-warning text="WARNING(MetaJavaBuilder) :: skipping function 'QtConcurrent::createFunctor', unmatched return type 'QtConcurrent::SelectMemberFunctor0&lt;T,Class&gt;::type'"/>
2492 2491
2493 2492 <suppress-warning text="WARNING(Parser) :: ** WARNING scope not found for function definition:QFuture&lt;void&gt;::operator= - definition *ignored*"/>
2494 2493 <suppress-warning text="WARNING(Parser) :: ** WARNING scope not found for function definition:QFutureInterface&lt;void&gt;::future - definition *ignored*"/>
2495 2494 <suppress-warning text="WARNING(Parser) :: ** WARNING scope not found for function definition:QFutureWatcher&lt;void&gt;::setFuture - definition *ignored*"/>
2496 2495
2497 2496
2498 2497 </typesystem>
General Comments 0
You need to be logged in to leave comments. Login now