1 /****************************************************************************
3 ** Copyright (C) 1992-2008 Trolltech ASA. All rights reserved.
4 ** Copyright (C) 2002-2005 Roberto Raggi <roberto@kdevelop.org>
6 ** This file is part of the Qt Script Generator project on Trolltech Labs.
8 ** This file may be used under the terms of the GNU General Public
9 ** License version 2.0 as published by the Free Software Foundation
10 ** and appearing in the file LICENSE.GPL included in the packaging of
11 ** this file. Please review the following information to ensure GNU
12 ** General Public Licensing requirements will be met:
13 ** http://www.trolltech.com/products/qt/opensource.html
15 ** If you are unsure which license is appropriate for your use, please
16 ** review the following information:
17 ** http://www.trolltech.com/products/qt/licensing.html or contact the
18 ** sales department at sales@trolltech.com.
20 ** This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
21 ** WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE.
23 ****************************************************************************/
29 #include "codemodel_fwd.h"
30 #include <codemodel_pointer.h>
32 #include <QtCore/QHash>
33 #include <QtCore/QList>
34 #include <QtCore/QString>
35 #include <QtCore/QStringList>
36 #include <QtCore/QVector>
38 #define DECLARE_MODEL_NODE(k) \
39 enum { __node_kind = Kind_##k }; \
40 typedef CodeModelPointer<k##ModelItem> Pointer;
42 template <class _Target
, class _Source
>
43 _Target
model_static_cast(_Source item
)
45 typedef typename
_Target::Type
* _Target_pointer
;
47 _Target
ptr (static_cast<_Target_pointer
>(item
.data()));
79 template <class _Target
> _Target
create()
81 typedef typename
_Target::Type _Target_type
;
83 _Target result
= _Target_type::create(this);
84 result
->setCreationId(_M_creation_id
++);
88 FileList
files() const;
89 NamespaceModelItem
globalNamespace() const;
91 void addFile(FileModelItem item
);
92 void removeFile(FileModelItem item
);
93 FileModelItem
findFile(const QString
&name
) const;
94 QHash
<QString
, FileModelItem
> fileMap() const;
96 CodeModelItem
findItem(const QStringList
&qualifiedName
, CodeModelItem scope
) const;
101 QHash
<QString
, FileModelItem
> _M_files
;
102 NamespaceModelItem _M_globalNamespace
;
103 std::size_t _M_creation_id
;
106 CodeModel(const CodeModel
&other
);
107 void operator = (const CodeModel
&other
);
113 TypeInfo(const TypeInfo
&other
)
114 : flags(other
.flags
),
115 m_qualifiedName(other
.m_qualifiedName
),
116 m_arrayElements(other
.m_arrayElements
),
117 m_arguments(other
.m_arguments
)
124 QStringList
qualifiedName() const { return m_qualifiedName
; }
125 void setQualifiedName(const QStringList
&qualified_name
) { m_qualifiedName
= qualified_name
; }
127 bool isConstant() const { return f
.m_constant
; }
128 void setConstant(bool is
) { f
.m_constant
= is
; }
130 bool isVolatile() const { return f
.m_volatile
; }
131 void setVolatile(bool is
) { f
.m_volatile
= is
; }
133 bool isReference() const { return f
.m_reference
; }
134 void setReference(bool is
) { f
.m_reference
= is
; }
136 int indirections() const { return f
.m_indirections
; }
137 void setIndirections(int indirections
) { f
.m_indirections
= indirections
; }
139 bool isFunctionPointer() const { return f
.m_functionPointer
; }
140 void setFunctionPointer(bool is
) { f
.m_functionPointer
= is
; }
142 QStringList
arrayElements() const { return m_arrayElements
; }
143 void setArrayElements(const QStringList
&arrayElements
) { m_arrayElements
= arrayElements
; }
145 QList
<TypeInfo
> arguments() const { return m_arguments
; }
146 void setArguments(const QList
<TypeInfo
> &arguments
);
147 void addArgument(const TypeInfo
&arg
) { m_arguments
.append(arg
); }
149 bool operator==(const TypeInfo
&other
);
150 bool operator!=(const TypeInfo
&other
) { return !(*this==other
); }
152 // ### arrays and templates??
154 QString
toString() const;
156 static TypeInfo
combine (const TypeInfo
&__lhs
, const TypeInfo
&__rhs
);
157 static TypeInfo
resolveType (TypeInfo
const &__type
, CodeModelItem __scope
);
169 uint m_functionPointer
: 1;
170 uint m_indirections
: 6;
175 QStringList m_qualifiedName
;
176 QStringList m_arrayElements
;
177 QList
<TypeInfo
> m_arguments
;
180 class _CodeModelItem
: public QSharedData
185 /* These are bit-flags resembling inheritance */
187 Kind_Namespace
= 0x2 | Kind_Scope
,
189 Kind_Function
= 0x8 | Kind_Member
,
192 /* These are for classes that are not inherited from */
194 Kind_Argument
= 1 << FirstKind
,
195 Kind_Class
= 2 << FirstKind
| Kind_Scope
,
196 Kind_Enum
= 3 << FirstKind
,
197 Kind_Enumerator
= 4 << FirstKind
,
198 Kind_File
= 5 << FirstKind
| Kind_Namespace
,
199 Kind_FunctionDefinition
= 6 << FirstKind
| Kind_Function
,
200 Kind_TemplateParameter
= 7 << FirstKind
,
201 Kind_TypeAlias
= 8 << FirstKind
,
202 Kind_Variable
= 9 << FirstKind
| Kind_Member
206 virtual ~_CodeModelItem();
210 QStringList
qualifiedName() const;
212 QString
name() const;
213 void setName(const QString
&name
);
215 QStringList
scope() const;
216 void setScope(const QStringList
&scope
);
218 QString
fileName() const;
219 void setFileName(const QString
&fileName
);
221 FileModelItem
file() const;
223 void getStartPosition(int *line
, int *column
);
224 void setStartPosition(int line
, int column
);
226 void getEndPosition(int *line
, int *column
);
227 void setEndPosition(int line
, int column
);
229 inline std::size_t creationId() const { return _M_creation_id
; }
230 inline void setCreationId(std::size_t creation_id
) { _M_creation_id
= creation_id
; }
232 inline CodeModel
*model() const { return _M_model
; }
234 CodeModelItem
toItem() const;
237 _CodeModelItem(CodeModel
*model
, int kind
);
238 void setKind(int kind
);
247 std::size_t _M_creation_id
;
250 QStringList _M_scope
;
253 _CodeModelItem(const _CodeModelItem
&other
);
254 void operator = (const _CodeModelItem
&other
);
257 class _ScopeModelItem
: public _CodeModelItem
260 DECLARE_MODEL_NODE(Scope
)
262 static ScopeModelItem
create(CodeModel
*model
);
265 ClassList
classes() const;
266 EnumList
enums() const;
267 FunctionDefinitionList
functionDefinitions() const;
268 FunctionList
functions() const;
269 TypeAliasList
typeAliases() const;
270 VariableList
variables() const;
272 void addClass(ClassModelItem item
);
273 void addEnum(EnumModelItem item
);
274 void addFunction(FunctionModelItem item
);
275 void addFunctionDefinition(FunctionDefinitionModelItem item
);
276 void addTypeAlias(TypeAliasModelItem item
);
277 void addVariable(VariableModelItem item
);
279 void removeClass(ClassModelItem item
);
280 void removeEnum(EnumModelItem item
);
281 void removeFunction(FunctionModelItem item
);
282 void removeFunctionDefinition(FunctionDefinitionModelItem item
);
283 void removeTypeAlias(TypeAliasModelItem item
);
284 void removeVariable(VariableModelItem item
);
286 ClassModelItem
findClass(const QString
&name
) const;
287 EnumModelItem
findEnum(const QString
&name
) const;
288 FunctionDefinitionList
findFunctionDefinitions(const QString
&name
) const;
289 FunctionList
findFunctions(const QString
&name
) const;
290 TypeAliasModelItem
findTypeAlias(const QString
&name
) const;
291 VariableModelItem
findVariable(const QString
&name
) const;
293 void addEnumsDeclaration(const QString
&enumsDeclaration
);
294 QStringList
enumsDeclarations() const { return _M_enumsDeclarations
; }
296 inline QHash
<QString
, ClassModelItem
> classMap() const { return _M_classes
; }
297 inline QHash
<QString
, EnumModelItem
> enumMap() const { return _M_enums
; }
298 inline QHash
<QString
, TypeAliasModelItem
> typeAliasMap() const { return _M_typeAliases
; }
299 inline QHash
<QString
, VariableModelItem
> variableMap() const { return _M_variables
; }
300 inline QMultiHash
<QString
, FunctionDefinitionModelItem
> functionDefinitionMap() const { return _M_functionDefinitions
; }
301 inline QMultiHash
<QString
, FunctionModelItem
> functionMap() const { return _M_functions
; }
303 FunctionModelItem
declaredFunction(FunctionModelItem item
);
306 _ScopeModelItem(CodeModel
*model
, int kind
= __node_kind
)
307 : _CodeModelItem(model
, kind
) {}
310 QHash
<QString
, ClassModelItem
> _M_classes
;
311 QHash
<QString
, EnumModelItem
> _M_enums
;
312 QHash
<QString
, TypeAliasModelItem
> _M_typeAliases
;
313 QHash
<QString
, VariableModelItem
> _M_variables
;
314 QMultiHash
<QString
, FunctionDefinitionModelItem
> _M_functionDefinitions
;
315 QMultiHash
<QString
, FunctionModelItem
> _M_functions
;
318 _ScopeModelItem(const _ScopeModelItem
&other
);
319 void operator = (const _ScopeModelItem
&other
);
321 QStringList _M_enumsDeclarations
;
324 class _ClassModelItem
: public _ScopeModelItem
327 DECLARE_MODEL_NODE(Class
)
329 static ClassModelItem
create(CodeModel
*model
);
332 QStringList
baseClasses() const;
333 QStringList
baseModifiers() const;
335 void setBaseClasses(const QStringList
&baseClasses
);
336 void addBaseClass(const QString
&baseClass
, const QString
&baseModifier
= QString());
337 void removeBaseClass(const QString
&baseClass
);
339 void setBaseModifiers(const QStringList
&baseModifiers
);
341 TemplateParameterList
templateParameters() const;
342 void setTemplateParameters(const TemplateParameterList
&templateParameters
);
344 bool extendsClass(const QString
&name
) const;
346 void setClassType(CodeModel::ClassType type
);
347 CodeModel::ClassType
classType() const;
349 void addPropertyDeclaration(const QString
&propertyDeclaration
);
350 QStringList
propertyDeclarations() const { return _M_propertyDeclarations
; }
353 _ClassModelItem(CodeModel
*model
, int kind
= __node_kind
)
354 : _ScopeModelItem(model
, kind
), _M_classType(CodeModel::Class
) {}
357 QStringList _M_baseClasses
;
358 QStringList _M_baseModifiers
;
359 TemplateParameterList _M_templateParameters
;
360 CodeModel::ClassType _M_classType
;
362 QStringList _M_propertyDeclarations
;
365 _ClassModelItem(const _ClassModelItem
&other
);
366 void operator = (const _ClassModelItem
&other
);
369 class _NamespaceModelItem
: public _ScopeModelItem
372 DECLARE_MODEL_NODE(Namespace
)
374 static NamespaceModelItem
create(CodeModel
*model
);
377 NamespaceList
namespaces() const;
379 void addNamespace(NamespaceModelItem item
);
380 void removeNamespace(NamespaceModelItem item
);
382 NamespaceModelItem
findNamespace(const QString
&name
) const;
384 inline QHash
<QString
, NamespaceModelItem
> namespaceMap() const { return _M_namespaces
; };
387 _NamespaceModelItem(CodeModel
*model
, int kind
= __node_kind
)
388 : _ScopeModelItem(model
, kind
) {}
391 QHash
<QString
, NamespaceModelItem
> _M_namespaces
;
394 _NamespaceModelItem(const _NamespaceModelItem
&other
);
395 void operator = (const _NamespaceModelItem
&other
);
398 class _FileModelItem
: public _NamespaceModelItem
401 DECLARE_MODEL_NODE(File
)
403 static FileModelItem
create(CodeModel
*model
);
406 _FileModelItem(CodeModel
*model
, int kind
= __node_kind
)
407 : _NamespaceModelItem(model
, kind
) {}
410 _FileModelItem(const _FileModelItem
&other
);
411 void operator = (const _FileModelItem
&other
);
414 class _ArgumentModelItem
: public _CodeModelItem
417 DECLARE_MODEL_NODE(Argument
)
419 static ArgumentModelItem
create(CodeModel
*model
);
422 TypeInfo
type() const;
423 void setType(const TypeInfo
&type
);
425 bool defaultValue() const;
426 void setDefaultValue(bool defaultValue
);
428 QString
defaultValueExpression() const { return _M_defaultValueExpression
; }
429 void setDefaultValueExpression(const QString
&expr
) { _M_defaultValueExpression
= expr
; }
432 _ArgumentModelItem(CodeModel
*model
, int kind
= __node_kind
)
433 : _CodeModelItem(model
, kind
), _M_defaultValue(false) {}
437 QString _M_defaultValueExpression
;
438 bool _M_defaultValue
;
441 _ArgumentModelItem(const _ArgumentModelItem
&other
);
442 void operator = (const _ArgumentModelItem
&other
);
445 class _MemberModelItem
: public _CodeModelItem
448 DECLARE_MODEL_NODE(Member
)
450 bool isConstant() const;
451 void setConstant(bool isConstant
);
453 bool isVolatile() const;
454 void setVolatile(bool isVolatile
);
456 bool isStatic() const;
457 void setStatic(bool isStatic
);
460 void setAuto(bool isAuto
);
462 bool isFriend() const;
463 void setFriend(bool isFriend
);
465 bool isRegister() const;
466 void setRegister(bool isRegister
);
468 bool isExtern() const;
469 void setExtern(bool isExtern
);
471 bool isMutable() const;
472 void setMutable(bool isMutable
);
474 CodeModel::AccessPolicy
accessPolicy() const;
475 void setAccessPolicy(CodeModel::AccessPolicy accessPolicy
);
477 TemplateParameterList
templateParameters() const
478 { return _M_templateParameters
; }
480 void setTemplateParameters(const TemplateParameterList
&templateParameters
)
481 { _M_templateParameters
= templateParameters
; }
483 TypeInfo
type() const;
484 void setType(const TypeInfo
&type
);
487 _MemberModelItem(CodeModel
*model
, int kind
)
488 : _CodeModelItem(model
, kind
),
489 _M_accessPolicy(CodeModel::Public
),
494 TemplateParameterList _M_templateParameters
;
496 CodeModel::AccessPolicy _M_accessPolicy
;
503 uint _M_isConstant
: 1;
504 uint _M_isVolatile
: 1;
508 uint _M_isRegister
: 1;
510 uint _M_isMutable
: 1;
511 uint _M_isVariadics
: 1;
512 uint _M_isVirtual
: 1;
513 uint _M_isExplicit
: 1;
515 uint _M_isAbstract
: 1;
522 class _FunctionModelItem
: public _MemberModelItem
525 DECLARE_MODEL_NODE(Function
)
527 static FunctionModelItem
create(CodeModel
*model
);
530 ArgumentList
arguments() const;
532 void addArgument(ArgumentModelItem item
);
533 void removeArgument(ArgumentModelItem item
);
535 CodeModel::FunctionType
functionType() const;
536 void setFunctionType(CodeModel::FunctionType functionType
);
538 bool isVirtual() const;
539 void setVirtual(bool isVirtual
);
541 bool isInline() const;
542 void setInline(bool isInline
);
544 bool isExplicit() const;
545 void setExplicit(bool isExplicit
);
547 bool isInvokable() const; // Qt
548 void setInvokable(bool isInvokable
); // Qt
550 bool isAbstract() const;
551 void setAbstract(bool isAbstract
);
553 bool isVariadics() const;
554 void setVariadics(bool isVariadics
);
556 bool isSimilar(FunctionModelItem other
) const;
559 _FunctionModelItem(CodeModel
*model
, int kind
= __node_kind
)
560 : _MemberModelItem(model
, kind
),
561 _M_functionType(CodeModel::Normal
),
566 ArgumentList _M_arguments
;
567 CodeModel::FunctionType _M_functionType
;
572 uint _M_isVirtual
: 1;
574 uint _M_isAbstract
: 1;
575 uint _M_isExplicit
: 1;
576 uint _M_isVariadics
: 1;
577 uint _M_isInvokable
: 1; // Qt
583 _FunctionModelItem(const _FunctionModelItem
&other
);
584 void operator = (const _FunctionModelItem
&other
);
587 class _FunctionDefinitionModelItem
: public _FunctionModelItem
590 DECLARE_MODEL_NODE(FunctionDefinition
)
592 static FunctionDefinitionModelItem
create(CodeModel
*model
);
595 _FunctionDefinitionModelItem(CodeModel
*model
, int kind
= __node_kind
)
596 : _FunctionModelItem(model
, kind
) {}
599 _FunctionDefinitionModelItem(const _FunctionDefinitionModelItem
&other
);
600 void operator = (const _FunctionDefinitionModelItem
&other
);
603 class _VariableModelItem
: public _MemberModelItem
606 DECLARE_MODEL_NODE(Variable
)
608 static VariableModelItem
create(CodeModel
*model
);
611 _VariableModelItem(CodeModel
*model
, int kind
= __node_kind
)
612 : _MemberModelItem(model
, kind
)
616 _VariableModelItem(const _VariableModelItem
&other
);
617 void operator = (const _VariableModelItem
&other
);
620 class _TypeAliasModelItem
: public _CodeModelItem
623 DECLARE_MODEL_NODE(TypeAlias
)
625 static TypeAliasModelItem
create(CodeModel
*model
);
628 TypeInfo
type() const;
629 void setType(const TypeInfo
&type
);
632 _TypeAliasModelItem(CodeModel
*model
, int kind
= __node_kind
)
633 : _CodeModelItem(model
, kind
) {}
639 _TypeAliasModelItem(const _TypeAliasModelItem
&other
);
640 void operator = (const _TypeAliasModelItem
&other
);
643 class _EnumModelItem
: public _CodeModelItem
646 DECLARE_MODEL_NODE(Enum
)
648 static EnumModelItem
create(CodeModel
*model
);
651 CodeModel::AccessPolicy
accessPolicy() const;
652 void setAccessPolicy(CodeModel::AccessPolicy accessPolicy
);
654 EnumeratorList
enumerators() const;
655 void addEnumerator(EnumeratorModelItem item
);
656 void removeEnumerator(EnumeratorModelItem item
);
659 _EnumModelItem(CodeModel
*model
, int kind
= __node_kind
)
660 : _CodeModelItem(model
, kind
),
661 _M_accessPolicy(CodeModel::Public
)
665 CodeModel::AccessPolicy _M_accessPolicy
;
666 EnumeratorList _M_enumerators
;
669 _EnumModelItem(const _EnumModelItem
&other
);
670 void operator = (const _EnumModelItem
&other
);
673 class _EnumeratorModelItem
: public _CodeModelItem
676 DECLARE_MODEL_NODE(Enumerator
)
678 static EnumeratorModelItem
create(CodeModel
*model
);
681 QString
value() const;
682 void setValue(const QString
&value
);
685 _EnumeratorModelItem(CodeModel
*model
, int kind
= __node_kind
)
686 : _CodeModelItem(model
, kind
) {}
692 _EnumeratorModelItem(const _EnumeratorModelItem
&other
);
693 void operator = (const _EnumeratorModelItem
&other
);
696 class _TemplateParameterModelItem
: public _CodeModelItem
699 DECLARE_MODEL_NODE(TemplateParameter
)
701 static TemplateParameterModelItem
create(CodeModel
*model
);
704 TypeInfo
type() const;
705 void setType(const TypeInfo
&type
);
707 bool defaultValue() const;
708 void setDefaultValue(bool defaultValue
);
711 _TemplateParameterModelItem(CodeModel
*model
, int kind
= __node_kind
)
712 : _CodeModelItem(model
, kind
), _M_defaultValue(false) {}
716 bool _M_defaultValue
;
719 _TemplateParameterModelItem(const _TemplateParameterModelItem
&other
);
720 void operator = (const _TemplateParameterModelItem
&other
);
723 template <class _Target
, class _Source
>
724 _Target
model_safe_cast(_Source item
)
726 typedef typename
_Target::Type
* _Target_pointer
;
727 typedef typename
_Source::Type
* _Source_pointer
;
729 _Source_pointer source
= item
.data();
730 if (source
&& source
->kind() == _Target_pointer(0)->__node_kind
)
732 _Target
ptr(static_cast<_Target_pointer
>(source
));
739 template <typename _Target
, typename _Source
>
740 _Target
model_dynamic_cast(_Source item
)
742 typedef typename
_Target::Type
* _Target_pointer
;
743 typedef typename
_Source::Type
* _Source_pointer
;
745 _Source_pointer source
= item
.data();
746 if (source
&& (source
->kind() == _Target_pointer(0)->__node_kind
747 || (int(_Target_pointer(0)->__node_kind
) <= int(_CodeModelItem::KindMask
)
748 && ((source
->kind() & _Target_pointer(0)->__node_kind
)
749 == _Target_pointer(0)->__node_kind
))))
751 _Target
ptr(static_cast<_Target_pointer
>(source
));
757 #endif // CODEMODEL_H
759 // kate: space-indent on; indent-width 2; replace-tabs on;