1 /****************************************************************************
2 **
3 ** Copyright (C) 2016 The Qt Company Ltd.
4 ** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
5 ** Contact: https://www.qt.io/licensing/
6 **
7 ** This file is part of Qt for Python.
8 **
9 ** $QT_BEGIN_LICENSE:GPL-EXCEPT$
10 ** Commercial License Usage
11 ** Licensees holding valid commercial Qt licenses may use this file in
12 ** accordance with the commercial license agreement provided with the
13 ** Software or, alternatively, in accordance with the terms contained in
14 ** a written agreement between you and The Qt Company. For licensing terms
15 ** and conditions see https://www.qt.io/terms-conditions. For further
16 ** information use the contact form at https://www.qt.io/contact-us.
17 **
18 ** GNU General Public License Usage
19 ** Alternatively, this file may be used under the terms of the GNU
20 ** General Public License version 3 as published by the Free Software
21 ** Foundation with exceptions as appearing in the file LICENSE.GPL3-EXCEPT
22 ** included in the packaging of this file. Please review the following
23 ** information to ensure the GNU General Public License requirements will
24 ** be met: https://www.gnu.org/licenses/gpl-3.0.html.
25 **
26 ** $QT_END_LICENSE$
27 **
28 ****************************************************************************/
29
30
31 #ifndef CODEMODEL_H
32 #define CODEMODEL_H
33
34 #include "codemodel_fwd.h"
35 #include "codemodel_enums.h"
36 #include "enumvalue.h"
37
38 #include <QtCore/QHash>
39 #include <QtCore/QPair>
40 #include <QtCore/QSet>
41 #include <QtCore/QString>
42 #include <QtCore/QStringList>
43 #include <QtCore/QVector>
44
QT_FORWARD_DECLARE_CLASS(QDebug)45 QT_FORWARD_DECLARE_CLASS(QDebug)
46
47 #define DECLARE_MODEL_NODE(k) \
48 enum { __node_kind = Kind_##k };
49
50 class SourceLocation;
51
52 class CodeModel
53 {
54 public:
55 Q_DISABLE_COPY(CodeModel)
56
57 enum AccessPolicy {
58 Public,
59 Protected,
60 Private
61 };
62
63 enum FunctionType {
64 Normal,
65 Constructor,
66 CopyConstructor,
67 MoveConstructor,
68 Destructor,
69 Signal,
70 Slot
71 };
72
73 enum ClassType {
74 Class,
75 Struct,
76 Union
77 };
78
79 public:
80 CodeModel();
81 virtual ~CodeModel();
82
83 FileList files() const { return m_files; }
84 NamespaceModelItem globalNamespace() const;
85
86 void addFile(const FileModelItem &item);
87 FileModelItem findFile(const QString &name) const;
88
89 CodeModelItem findItem(const QStringList &qualifiedName, const ScopeModelItem &scope) const;
90
91 private:
92 FileList m_files;
93 NamespaceModelItem m_globalNamespace;
94 };
95
96 #ifndef QT_NO_DEBUG_STREAM
97 QDebug operator<<(QDebug d, const CodeModel *m);
98 #endif
99
100 class TypeInfo
101 {
102 friend class TypeParser;
103 public:
104 using Indirections = QVector<Indirection>;
105
TypeInfo()106 TypeInfo() : flags(0), m_referenceType(NoReference) {}
107
qualifiedName()108 QStringList qualifiedName() const
109 {
110 return m_qualifiedName;
111 }
112
setQualifiedName(const QStringList & qualified_name)113 void setQualifiedName(const QStringList &qualified_name)
114 {
115 m_qualifiedName = qualified_name;
116 }
117
118 bool isVoid() const;
119
isConstant()120 bool isConstant() const
121 {
122 return m_constant;
123 }
124
setConstant(bool is)125 void setConstant(bool is)
126 {
127 m_constant = is;
128 }
129
isVolatile()130 bool isVolatile() const
131 {
132 return m_volatile;
133 }
134
setVolatile(bool is)135 void setVolatile(bool is)
136 {
137 m_volatile = is;
138 }
139
referenceType()140 ReferenceType referenceType() const { return m_referenceType; }
setReferenceType(ReferenceType r)141 void setReferenceType(ReferenceType r) { m_referenceType = r; }
142
indirectionsV()143 Indirections indirectionsV() const { return m_indirections; }
setIndirectionsV(const Indirections & i)144 void setIndirectionsV(const Indirections &i) { m_indirections = i; }
addIndirection(Indirection i)145 void addIndirection(Indirection i) { m_indirections.append(i); }
146
147 // "Legacy", rename?
indirections()148 int indirections() const { return m_indirections.size(); }
149
setIndirections(int indirections)150 void setIndirections(int indirections)
151 {
152 m_indirections = Indirections(indirections, Indirection::Pointer);
153 }
154
isFunctionPointer()155 bool isFunctionPointer() const
156 {
157 return m_functionPointer;
158 }
setFunctionPointer(bool is)159 void setFunctionPointer(bool is)
160 {
161 m_functionPointer = is;
162 }
163
arrayElements()164 QStringList arrayElements() const
165 {
166 return m_arrayElements;
167 }
setArrayElements(const QStringList & arrayElements)168 void setArrayElements(const QStringList &arrayElements)
169 {
170 m_arrayElements = arrayElements;
171 }
172
addArrayElement(const QString & a)173 void addArrayElement(const QString &a) { m_arrayElements.append(a); }
174
arguments()175 QVector<TypeInfo> arguments() const { return m_arguments; }
176
177 void setArguments(const QVector<TypeInfo> &arguments);
178
addArgument(const TypeInfo & arg)179 void addArgument(const TypeInfo &arg)
180 {
181 m_arguments.append(arg);
182 }
183
instantiations()184 QVector<TypeInfo> instantiations() const { return m_instantiations; }
setInstantiations(const QVector<TypeInfo> & i)185 void setInstantiations(const QVector<TypeInfo> &i) { m_instantiations = i; }
addInstantiation(const TypeInfo & i)186 void addInstantiation(const TypeInfo &i) { m_instantiations.append(i); }
clearInstantiations()187 void clearInstantiations() { m_instantiations.clear(); }
188
189 bool isStdType() const;
190
191 QPair<int, int> parseTemplateArgumentList(const QString &l, int from = 0);
192
193 bool operator==(const TypeInfo &other) const;
194
195 bool operator!=(const TypeInfo &other) const
196 {
197 return !(*this == other);
198 }
199
200 // ### arrays and templates??
201
202 QString toString() const;
203
204 static TypeInfo combine(const TypeInfo &__lhs, const TypeInfo &__rhs);
205 static TypeInfo resolveType(TypeInfo const &__type, const ScopeModelItem &__scope);
206
207 void formatTypeSystemSignature(QTextStream &str) const;
208
209 #ifndef QT_NO_DEBUG_STREAM
210 void formatDebug(QDebug &d) const;
211 #endif
212
213 static QString indirectionKeyword(Indirection i);
214
215 static bool stripLeadingConst(QString *s);
216 static bool stripLeadingVolatile(QString *s);
217 static bool stripLeadingQualifier(const QString &qualifier, QString *s);
218 static void stripQualifiers(QString *s);
219
220 void simplifyStdType();
221
222 private:
223 friend class TypeInfoTemplateArgumentHandler;
224
225 static TypeInfo resolveType(CodeModelItem item, TypeInfo const &__type, const ScopeModelItem &__scope);
226
227 QStringList m_qualifiedName;
228 QStringList m_arrayElements;
229 QVector<TypeInfo> m_arguments;
230 QVector<TypeInfo> m_instantiations;
231 Indirections m_indirections;
232
233 union {
234 uint flags;
235
236 struct {
237 uint m_constant: 1;
238 uint m_volatile: 1;
239 uint m_functionPointer: 1;
240 uint m_padding: 29;
241 };
242 };
243
244 ReferenceType m_referenceType;
245 };
246
247 #ifndef QT_NO_DEBUG_STREAM
248 QDebug operator<<(QDebug d, const TypeInfo &t);
249 #endif
250
251 class _CodeModelItem
252 {
253 Q_DISABLE_COPY(_CodeModelItem)
254 public:
255 enum Kind {
256 /* These are bit-flags resembling inheritance */
257 Kind_Scope = 0x1,
258 Kind_Namespace = 0x2 | Kind_Scope,
259 Kind_Member = 0x4,
260 Kind_Function = 0x8 | Kind_Member,
261 KindMask = 0xf,
262
263 /* These are for classes that are not inherited from */
264 FirstKind = 0x8,
265 Kind_Argument = 1 << FirstKind,
266 Kind_Class = 2 << FirstKind | Kind_Scope,
267 Kind_Enum = 3 << FirstKind,
268 Kind_Enumerator = 4 << FirstKind,
269 Kind_File = 5 << FirstKind | Kind_Namespace,
270 Kind_TemplateParameter = 7 << FirstKind,
271 Kind_TypeDef = 8 << FirstKind,
272 Kind_TemplateTypeAlias = 9 << FirstKind,
273 Kind_Variable = 10 << FirstKind | Kind_Member
274 };
275
276 public:
277 virtual ~_CodeModelItem();
278
279 int kind() const;
280
281 QStringList qualifiedName() const;
282
283 QString name() const;
284 void setName(const QString &name);
285
286 QStringList scope() const;
287 void setScope(const QStringList &scope);
288
289 QString fileName() const;
290 void setFileName(const QString &fileName);
291
292 FileModelItem file() const;
293
294 void getStartPosition(int *line, int *column);
startLine()295 int startLine() const { return m_startLine; }
296 void setStartPosition(int line, int column);
297
298 void getEndPosition(int *line, int *column);
299 void setEndPosition(int line, int column);
300
301 SourceLocation sourceLocation() const;
302
model()303 inline CodeModel *model() const { return m_model; }
304
305 #ifndef QT_NO_DEBUG_STREAM
306 static void formatKind(QDebug &d, int k);
307 virtual void formatDebug(QDebug &d) const;
308 #endif
309
310 protected:
311 explicit _CodeModelItem(CodeModel *model, int kind);
312 explicit _CodeModelItem(CodeModel *model, const QString &name, int kind);
313
314 private:
315 CodeModel *m_model;
316 int m_kind;
317 int m_startLine;
318 int m_startColumn;
319 int m_endLine;
320 int m_endColumn;
321 QString m_name;
322 QString m_fileName;
323 QStringList m_scope;
324 };
325
326 #ifndef QT_NO_DEBUG_STREAM
327 QDebug operator<<(QDebug d, const _CodeModelItem *t);
328 #endif
329
330 class _ScopeModelItem: public _CodeModelItem
331 {
332 public:
333 DECLARE_MODEL_NODE(Scope)
334
335 ~_ScopeModelItem();
336
classes()337 ClassList classes() const { return m_classes; }
enums()338 EnumList enums() const { return m_enums; }
functions()339 inline FunctionList functions() const { return m_functions; }
typeDefs()340 TypeDefList typeDefs() const { return m_typeDefs; }
templateTypeAliases()341 TemplateTypeAliasList templateTypeAliases() const { return m_templateTypeAliases; }
variables()342 VariableList variables() const { return m_variables; }
343
344 void addClass(const ClassModelItem &item);
345 void addEnum(const EnumModelItem &item);
346 void addFunction(const FunctionModelItem &item);
347 void addTypeDef(const TypeDefModelItem &item);
348 void addTemplateTypeAlias(const TemplateTypeAliasModelItem &item);
349 void addVariable(const VariableModelItem &item);
350
351 ClassModelItem findClass(const QString &name) const;
352 EnumModelItem findEnum(const QString &name) const;
353 FunctionList findFunctions(const QString &name) const;
354 TypeDefModelItem findTypeDef(const QString &name) const;
355 TemplateTypeAliasModelItem findTemplateTypeAlias(const QString &name) const;
356 VariableModelItem findVariable(const QString &name) const;
357
358 void addEnumsDeclaration(const QString &enumsDeclaration);
enumsDeclarations()359 QStringList enumsDeclarations() const { return m_enumsDeclarations; }
360
361 FunctionModelItem declaredFunction(const FunctionModelItem &item);
362
363 bool isEmpty() const;
364 void purgeClassDeclarations();
365
366 #ifndef QT_NO_DEBUG_STREAM
367 void formatDebug(QDebug &d) const override;
368 #endif
369
370 protected:
371 explicit _ScopeModelItem(CodeModel *model, int kind = __node_kind)
_CodeModelItem(model,kind)372 : _CodeModelItem(model, kind) {}
373 explicit _ScopeModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_CodeModelItem(model,name,kind)374 : _CodeModelItem(model, name, kind) {}
375
376 void appendScope(const _ScopeModelItem &other);
377
378 #ifndef QT_NO_DEBUG_STREAM
379 void formatScopeItemsDebug(QDebug &d) const;
380 #endif
381
382 private:
383 ClassList m_classes;
384 EnumList m_enums;
385 TypeDefList m_typeDefs;
386 TemplateTypeAliasList m_templateTypeAliases;
387 VariableList m_variables;
388 FunctionList m_functions;
389
390 private:
391 QStringList m_enumsDeclarations;
392 };
393
394 class _ClassModelItem: public _ScopeModelItem
395 {
396 public:
397 DECLARE_MODEL_NODE(Class)
398
399 struct BaseClass
400 {
401 QString name;
402 CodeModel::AccessPolicy accessPolicy = CodeModel::Public;
403 };
404
405 explicit _ClassModelItem(CodeModel *model, int kind = __node_kind)
_ScopeModelItem(model,kind)406 : _ScopeModelItem(model, kind), m_classType(CodeModel::Class) {}
407 explicit _ClassModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_ScopeModelItem(model,name,kind)408 : _ScopeModelItem(model, name, kind), m_classType(CodeModel::Class) {}
409 ~_ClassModelItem();
410
baseClasses()411 QVector<BaseClass> baseClasses() const { return m_baseClasses; }
412
413 void addBaseClass(const QString &name, CodeModel::AccessPolicy accessPolicy);
414
415 TemplateParameterList templateParameters() const;
416 void setTemplateParameters(const TemplateParameterList &templateParameters);
417
418 bool extendsClass(const QString &name) const;
419
420 void setClassType(CodeModel::ClassType type);
421 CodeModel::ClassType classType() const;
422
423 void addPropertyDeclaration(const QString &propertyDeclaration);
propertyDeclarations()424 QStringList propertyDeclarations() const { return m_propertyDeclarations; }
425
isFinal()426 bool isFinal() const { return m_final; }
setFinal(bool f)427 void setFinal(bool f) { m_final = f; }
428
429 bool isEmpty() const;
430 bool isTemplate() const;
431
432 #ifndef QT_NO_DEBUG_STREAM
433 void formatDebug(QDebug &d) const override;
434 #endif
435
436 private:
437 QVector<BaseClass> m_baseClasses;
438 TemplateParameterList m_templateParameters;
439 CodeModel::ClassType m_classType;
440
441 QStringList m_propertyDeclarations;
442 bool m_final = false;
443 };
444
445 class _NamespaceModelItem: public _ScopeModelItem
446 {
447 public:
DECLARE_MODEL_NODE(Namespace)448 DECLARE_MODEL_NODE(Namespace)
449
450 explicit _NamespaceModelItem(CodeModel *model, int kind = __node_kind)
451 : _ScopeModelItem(model, kind) {}
452 explicit _NamespaceModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_ScopeModelItem(model,name,kind)453 : _ScopeModelItem(model, name, kind) {}
454 ~_NamespaceModelItem();
455
namespaces()456 const NamespaceList &namespaces() const { return m_namespaces; }
457
type()458 NamespaceType type() const { return m_type; }
setType(NamespaceType t)459 void setType(NamespaceType t) { m_type = t; }
460
461 void addNamespace(NamespaceModelItem item);
462
463 NamespaceModelItem findNamespace(const QString &name) const;
464
465 void appendNamespace(const _NamespaceModelItem &other);
466
467 #ifndef QT_NO_DEBUG_STREAM
468 void formatDebug(QDebug &d) const override;
469 #endif
470
471 private:
472 NamespaceList m_namespaces;
473 NamespaceType m_type = NamespaceType::Default;
474 };
475
476 class _FileModelItem: public _NamespaceModelItem
477 {
478 public:
DECLARE_MODEL_NODE(File)479 DECLARE_MODEL_NODE(File)
480
481 explicit _FileModelItem(CodeModel *model, int kind = __node_kind)
482 : _NamespaceModelItem(model, kind) {}
483 explicit _FileModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_NamespaceModelItem(model,name,kind)484 : _NamespaceModelItem(model, name, kind) {}
485 ~_FileModelItem();
486 };
487
488 class _ArgumentModelItem: public _CodeModelItem
489 {
490 public:
DECLARE_MODEL_NODE(Argument)491 DECLARE_MODEL_NODE(Argument)
492
493 explicit _ArgumentModelItem(CodeModel *model, int kind = __node_kind)
494 : _CodeModelItem(model, kind), m_defaultValue(false) {}
495 explicit _ArgumentModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_CodeModelItem(model,name,kind)496 : _CodeModelItem(model, name, kind), m_defaultValue(false) {}
497 ~_ArgumentModelItem();
498
499 TypeInfo type() const;
500 void setType(const TypeInfo &type);
501
502 bool defaultValue() const;
503 void setDefaultValue(bool defaultValue);
504
defaultValueExpression()505 QString defaultValueExpression() const { return m_defaultValueExpression; }
setDefaultValueExpression(const QString & expr)506 void setDefaultValueExpression(const QString &expr) { m_defaultValueExpression = expr; }
507
508 #ifndef QT_NO_DEBUG_STREAM
509 void formatDebug(QDebug &d) const override;
510 #endif
511
512 private:
513 TypeInfo m_type;
514 QString m_defaultValueExpression;
515 bool m_defaultValue;
516 };
517
518 class _MemberModelItem: public _CodeModelItem
519 {
520 public:
DECLARE_MODEL_NODE(Member)521 DECLARE_MODEL_NODE(Member)
522
523 explicit _MemberModelItem(CodeModel *model, int kind = __node_kind)
524 : _CodeModelItem(model, kind), m_accessPolicy(CodeModel::Public), m_flags(0) {}
525 explicit _MemberModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_CodeModelItem(model,name,kind)526 : _CodeModelItem(model, name, kind), m_accessPolicy(CodeModel::Public), m_flags(0) {}
527 ~_MemberModelItem();
528
529 bool isConstant() const;
530 void setConstant(bool isConstant);
531
532 bool isVolatile() const;
533 void setVolatile(bool isVolatile);
534
535 bool isStatic() const;
536 void setStatic(bool isStatic);
537
538 bool isAuto() const;
539 void setAuto(bool isAuto);
540
541 bool isFriend() const;
542 void setFriend(bool isFriend);
543
544 bool isRegister() const;
545 void setRegister(bool isRegister);
546
547 bool isExtern() const;
548 void setExtern(bool isExtern);
549
550 bool isMutable() const;
551 void setMutable(bool isMutable);
552
553 CodeModel::AccessPolicy accessPolicy() const;
554 void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
555
templateParameters()556 TemplateParameterList templateParameters() const { return m_templateParameters; }
setTemplateParameters(const TemplateParameterList & templateParameters)557 void setTemplateParameters(const TemplateParameterList &templateParameters) { m_templateParameters = templateParameters; }
558
559 TypeInfo type() const;
560 void setType(const TypeInfo &type);
561
562 #ifndef QT_NO_DEBUG_STREAM
563 void formatDebug(QDebug &d) const override;
564 #endif
565
566 private:
567 TemplateParameterList m_templateParameters;
568 TypeInfo m_type;
569 CodeModel::AccessPolicy m_accessPolicy;
570 union {
571 struct {
572 uint m_isConstant: 1;
573 uint m_isVolatile: 1;
574 uint m_isStatic: 1;
575 uint m_isAuto: 1;
576 uint m_isFriend: 1;
577 uint m_isRegister: 1;
578 uint m_isExtern: 1;
579 uint m_isMutable: 1;
580 };
581 uint m_flags;
582 };
583
584 };
585
586 class _FunctionModelItem: public _MemberModelItem
587 {
588 public:
DECLARE_MODEL_NODE(Function)589 DECLARE_MODEL_NODE(Function)
590
591 explicit _FunctionModelItem(CodeModel *model, int kind = __node_kind)
592 : _MemberModelItem(model, kind), m_functionType(CodeModel::Normal), m_flags(0) {}
593 explicit _FunctionModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_MemberModelItem(model,name,kind)594 : _MemberModelItem(model, name, kind), m_functionType(CodeModel::Normal), m_flags(0) {}
595 ~_FunctionModelItem();
596
597 ArgumentList arguments() const;
598
599 void addArgument(const ArgumentModelItem& item);
600
601 CodeModel::FunctionType functionType() const;
602 void setFunctionType(CodeModel::FunctionType functionType);
603
604 bool isDeleted() const;
605 void setDeleted(bool d);
606
607 bool isDeprecated() const;
608 void setDeprecated(bool d);
609
610 bool isVirtual() const;
611 void setVirtual(bool isVirtual);
612
613 bool isOverride() const;
614 void setOverride(bool o);
615
616 bool isFinal() const;
617 void setFinal(bool f);
618
619 bool isInline() const;
620 void setInline(bool isInline);
621
622 bool isExplicit() const;
623 void setExplicit(bool isExplicit);
624
625 bool isInvokable() const; // Qt
626 void setInvokable(bool isInvokable); // Qt
627
628 bool isAbstract() const;
629 void setAbstract(bool isAbstract);
630
631 bool isVariadics() const;
632 void setVariadics(bool isVariadics);
633
634
635 bool isSimilar(const FunctionModelItem &other) const;
636
637 bool isNoExcept() const;
638
639 ExceptionSpecification exceptionSpecification() const;
640 void setExceptionSpecification(ExceptionSpecification e);
641
642 QString typeSystemSignature() const; // For dumping out type system files
643
644 #ifndef QT_NO_DEBUG_STREAM
645 void formatDebug(QDebug &d) const override;
646 #endif
647
648 private:
649 ArgumentList m_arguments;
650 CodeModel::FunctionType m_functionType;
651 union {
652 struct {
653 uint m_isDeleted: 1;
654 uint m_isVirtual: 1;
655 uint m_isOverride: 1;
656 uint m_isFinal: 1;
657 uint m_isDeprecated: 1;
658 uint m_isInline: 1;
659 uint m_isAbstract: 1;
660 uint m_isExplicit: 1;
661 uint m_isVariadics: 1;
662 uint m_isInvokable : 1; // Qt
663 };
664 uint m_flags;
665 };
666 ExceptionSpecification m_exceptionSpecification = ExceptionSpecification::Unknown;
667 };
668
669 class _VariableModelItem: public _MemberModelItem
670 {
671 public:
DECLARE_MODEL_NODE(Variable)672 DECLARE_MODEL_NODE(Variable)
673
674 explicit _VariableModelItem(CodeModel *model, int kind = __node_kind)
675 : _MemberModelItem(model, kind) {}
676 explicit _VariableModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_MemberModelItem(model,name,kind)677 : _MemberModelItem(model, name, kind) {}
678 };
679
680 class _TypeDefModelItem: public _CodeModelItem
681 {
682 public:
DECLARE_MODEL_NODE(TypeDef)683 DECLARE_MODEL_NODE(TypeDef)
684
685 explicit _TypeDefModelItem(CodeModel *model, int kind = __node_kind)
686 : _CodeModelItem(model, kind) {}
687 explicit _TypeDefModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_CodeModelItem(model,name,kind)688 : _CodeModelItem(model, name, kind) {}
689
690 TypeInfo type() const;
691 void setType(const TypeInfo &type);
692
693 #ifndef QT_NO_DEBUG_STREAM
694 void formatDebug(QDebug &d) const override;
695 #endif
696
697 private:
698 TypeInfo m_type;
699 };
700
701 class _TemplateTypeAliasModelItem : public _CodeModelItem
702 {
703 public:
704 DECLARE_MODEL_NODE(TemplateTypeAlias)
705
706 explicit _TemplateTypeAliasModelItem(CodeModel *model, int kind = __node_kind);
707 explicit _TemplateTypeAliasModelItem(CodeModel *model, const QString &name,
708 int kind = __node_kind);
709
710 TemplateParameterList templateParameters() const;
711 void addTemplateParameter(const TemplateParameterModelItem &templateParameter);
712
713 TypeInfo type() const;
714 void setType(const TypeInfo &type);
715
716 #ifndef QT_NO_DEBUG_STREAM
717 void formatDebug(QDebug &d) const override;
718 #endif
719
720 private:
721 TemplateParameterList m_templateParameters;
722 TypeInfo m_type;
723 };
724
725 class _EnumModelItem: public _CodeModelItem
726 {
727 public:
DECLARE_MODEL_NODE(Enum)728 DECLARE_MODEL_NODE(Enum)
729
730 explicit _EnumModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
731 : _CodeModelItem(model, name, kind) {}
732 explicit _EnumModelItem(CodeModel *model, int kind = __node_kind)
_CodeModelItem(model,kind)733 : _CodeModelItem(model, kind) {}
734 ~_EnumModelItem();
735
736 CodeModel::AccessPolicy accessPolicy() const;
737 void setAccessPolicy(CodeModel::AccessPolicy accessPolicy);
738
hasValues()739 bool hasValues() const { return !m_enumerators.isEmpty(); }
740 EnumeratorList enumerators() const;
741 void addEnumerator(const EnumeratorModelItem &item);
742
enumKind()743 EnumKind enumKind() const { return m_enumKind; }
setEnumKind(EnumKind kind)744 void setEnumKind(EnumKind kind) { m_enumKind = kind; }
745
746 #ifndef QT_NO_DEBUG_STREAM
747 void formatDebug(QDebug &d) const override;
748 #endif
749
750 bool isSigned() const;
751 void setSigned(bool s);
752
753 private:
754 CodeModel::AccessPolicy m_accessPolicy = CodeModel::Public;
755 EnumeratorList m_enumerators;
756 EnumKind m_enumKind = CEnum;
757 bool m_signed = true;
758 };
759
760 class _EnumeratorModelItem: public _CodeModelItem
761 {
762 public:
DECLARE_MODEL_NODE(Enumerator)763 DECLARE_MODEL_NODE(Enumerator)
764
765 explicit _EnumeratorModelItem(CodeModel *model, int kind = __node_kind)
766 : _CodeModelItem(model, kind) {}
767 explicit _EnumeratorModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_CodeModelItem(model,name,kind)768 : _CodeModelItem(model, name, kind) {}
769 ~_EnumeratorModelItem();
770
771 QString stringValue() const;
772 void setStringValue(const QString &stringValue);
773
value()774 EnumValue value() const { return m_value; }
setValue(EnumValue v)775 void setValue(EnumValue v) { m_value = v; }
776
777 #ifndef QT_NO_DEBUG_STREAM
778 void formatDebug(QDebug &d) const override;
779 #endif
780
781 private:
782 QString m_stringValue;
783 EnumValue m_value;
784 };
785
786 class _TemplateParameterModelItem: public _CodeModelItem
787 {
788 public:
DECLARE_MODEL_NODE(TemplateParameter)789 DECLARE_MODEL_NODE(TemplateParameter)
790
791 explicit _TemplateParameterModelItem(CodeModel *model, int kind = __node_kind)
792 : _CodeModelItem(model, kind), m_defaultValue(false) {}
793 explicit _TemplateParameterModelItem(CodeModel *model, const QString &name, int kind = __node_kind)
_CodeModelItem(model,name,kind)794 : _CodeModelItem(model, name, kind), m_defaultValue(false) {}
795 ~_TemplateParameterModelItem();
796
797 TypeInfo type() const;
798 void setType(const TypeInfo &type);
799
800 bool defaultValue() const;
801 void setDefaultValue(bool defaultValue);
802
803 #ifndef QT_NO_DEBUG_STREAM
804 void formatDebug(QDebug &d) const override;
805 #endif
806
807 private:
808 TypeInfo m_type;
809 bool m_defaultValue;
810 };
811
812 #endif // CODEMODEL_H
813
814 // kate: space-indent on; indent-width 2; replace-tabs on;
815