Warning: That file was not part of the compilation database. It may have many parsing errors.
1 | /**************************************************************************** |
---|---|
2 | ** |
3 | ** Copyright (C) 2014 Digia Plc and/or its subsidiary(-ies). |
4 | ** Contact: http://www.qt-project.org/legal |
5 | ** |
6 | ** This file is part of the tools applications of the Qt Toolkit. |
7 | ** |
8 | ** $QT_BEGIN_LICENSE:LGPL$ |
9 | ** Commercial License Usage |
10 | ** Licensees holding valid commercial Qt licenses may use this file in |
11 | ** accordance with the commercial license agreement provided with the |
12 | ** Software or, alternatively, in accordance with the terms contained in |
13 | ** a written agreement between you and Digia. For licensing terms and |
14 | ** conditions see http://qt.digia.com/licensing. For further information |
15 | ** use the contact form at http://qt.digia.com/contact-us. |
16 | ** |
17 | ** GNU Lesser General Public License Usage |
18 | ** Alternatively, this file may be used under the terms of the GNU Lesser |
19 | ** General Public License version 2.1 as published by the Free Software |
20 | ** Foundation and appearing in the file LICENSE.LGPL included in the |
21 | ** packaging of this file. Please review the following information to |
22 | ** ensure the GNU Lesser General Public License version 2.1 requirements |
23 | ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
24 | ** |
25 | ** In addition, as a special exception, Digia gives you certain additional |
26 | ** rights. These rights are described in the Digia Qt LGPL Exception |
27 | ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
28 | ** |
29 | ** GNU General Public License Usage |
30 | ** Alternatively, this file may be used under the terms of the GNU |
31 | ** General Public License version 3.0 as published by the Free Software |
32 | ** Foundation and appearing in the file LICENSE.GPL included in the |
33 | ** packaging of this file. Please review the following information to |
34 | ** ensure the GNU General Public License version 3.0 requirements will be |
35 | ** met: http://www.gnu.org/copyleft/gpl.html. |
36 | ** |
37 | ** |
38 | ** $QT_END_LICENSE$ |
39 | ** |
40 | ****************************************************************************/ |
41 | |
42 | /* |
43 | node.h |
44 | */ |
45 | |
46 | #ifndef NODE_H |
47 | #define NODE_H |
48 | |
49 | #include <qdir.h> |
50 | #include <qmap.h> |
51 | #include <qpair.h> |
52 | #include <qstringlist.h> |
53 | |
54 | #include "codechunk.h" |
55 | #include "doc.h" |
56 | #include "location.h" |
57 | #include "text.h" |
58 | |
59 | QT_BEGIN_NAMESPACE |
60 | |
61 | class Node; |
62 | class ClassNode; |
63 | class InnerNode; |
64 | class ExampleNode; |
65 | class QmlClassNode; |
66 | |
67 | typedef QMap<QString, const Node*> NodeMap; |
68 | typedef QMultiMap<QString, Node*> NodeMultiMap; |
69 | typedef QMap<QString, const ExampleNode*> ExampleNodeMap; |
70 | |
71 | class Node |
72 | { |
73 | public: |
74 | enum Type { |
75 | Namespace, |
76 | Class, |
77 | Fake, |
78 | Enum, |
79 | Typedef, |
80 | Function, |
81 | Property, |
82 | Variable, |
83 | #ifdef QDOC_QML |
84 | Target, |
85 | QmlProperty, |
86 | QmlSignal, |
87 | QmlMethod, |
88 | LastType |
89 | #else |
90 | Target, |
91 | LastType |
92 | #endif |
93 | }; |
94 | |
95 | enum SubType { |
96 | NoSubType, |
97 | Example, |
98 | HeaderFile, |
99 | File, |
100 | Image, |
101 | Group, |
102 | Module, |
103 | Page, |
104 | #ifdef QDOC_QML |
105 | ExternalPage, |
106 | QmlClass, |
107 | QmlPropertyGroup, |
108 | QmlBasicType |
109 | #else |
110 | ExternalPage |
111 | #endif |
112 | }; |
113 | |
114 | enum Access { Public, Protected, Private }; |
115 | |
116 | enum Status { |
117 | Compat, |
118 | Obsolete, |
119 | Deprecated, |
120 | Preliminary, |
121 | Commendable, |
122 | Main, |
123 | Internal |
124 | }; // don't reorder this enum |
125 | |
126 | enum ThreadSafeness { |
127 | UnspecifiedSafeness, |
128 | NonReentrant, |
129 | Reentrant, |
130 | ThreadSafe |
131 | }; |
132 | |
133 | enum LinkType { |
134 | StartLink, |
135 | NextLink, |
136 | PreviousLink, |
137 | ContentsLink, |
138 | IndexLink, |
139 | InheritsLink /*, |
140 | GlossaryLink, |
141 | CopyrightLink, |
142 | ChapterLink, |
143 | SectionLink, |
144 | SubsectionLink, |
145 | AppendixLink */ |
146 | }; |
147 | |
148 | enum PageType { |
149 | NoPageType, |
150 | ApiPage, |
151 | ArticlePage, |
152 | ExamplePage |
153 | }; |
154 | |
155 | virtual ~Node(); |
156 | |
157 | void setAccess(Access access) { acc = access; } |
158 | void setLocation(const Location& location) { loc = location; } |
159 | void setDoc(const Doc& doc, bool replace = false); |
160 | void setStatus(Status status) { sta = status; } |
161 | void setThreadSafeness(ThreadSafeness safeness) { saf = safeness; } |
162 | void setSince(const QString &since); |
163 | void setRelates(InnerNode* pseudoParent); |
164 | void setModuleName(const QString &module) { mod = module; } |
165 | void setLink(LinkType linkType, const QString &link, const QString &desc); |
166 | void setUrl(const QString &url); |
167 | void setTemplateStuff(const QString &templateStuff) { tpl = templateStuff; } |
168 | void setPageType(PageType t) { pageTyp = t; } |
169 | void setPageType(const QString& t); |
170 | virtual void addDependency(const QString& ) { } |
171 | |
172 | virtual bool isInnerNode() const = 0; |
173 | virtual bool isReimp() const { return false; } |
174 | virtual bool isFunction() const { return false; } |
175 | virtual bool isQmlNode() const { return false; } |
176 | virtual bool isInternal() const { return false; } |
177 | Type type() const { return typ; } |
178 | virtual SubType subType() const { return NoSubType; } |
179 | InnerNode* parent() const { return par; } |
180 | InnerNode* relates() const { return rel; } |
181 | const QString& name() const { return nam; } |
182 | QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; } |
183 | QString moduleName() const; |
184 | QString url() const; |
185 | virtual QString nameForLists() const { return nam; } |
186 | |
187 | Access access() const { return acc; } |
188 | QString accessString() const; |
189 | const Location& location() const { return loc; } |
190 | const Doc& doc() const { return d; } |
191 | Status status() const { return sta; } |
192 | Status inheritedStatus() const; |
193 | ThreadSafeness threadSafeness() const; |
194 | ThreadSafeness inheritedThreadSafeness() const; |
195 | QString since() const { return sinc; } |
196 | QString templateStuff() const { return tpl; } |
197 | PageType pageType() const { return pageTyp; } |
198 | virtual void addPageKeywords(const QString& ) { } |
199 | |
200 | void clearRelated() { rel = 0; } |
201 | |
202 | virtual QString fileBase() const; |
203 | QString guid() const; |
204 | QString ditaXmlHref(); |
205 | QString extractClassName(const QString &string) const; |
206 | const QmlClassNode* qmlClassNode() const; |
207 | const ClassNode* declarativeCppNode() const; |
208 | |
209 | protected: |
210 | Node(Type type, InnerNode* parent, const QString& name); |
211 | |
212 | private: |
213 | |
214 | #ifdef Q_WS_WIN |
215 | Type typ; |
216 | Access acc; |
217 | ThreadSafeness saf; |
218 | PageType pageTyp; |
219 | Status sta; |
220 | #else |
221 | Type typ : 4; |
222 | Access acc : 2; |
223 | ThreadSafeness saf : 2; |
224 | PageType pageTyp : 4; |
225 | Status sta : 3; |
226 | #endif |
227 | InnerNode* par; |
228 | InnerNode* rel; |
229 | QString nam; |
230 | Location loc; |
231 | Doc d; |
232 | QMap<LinkType, QPair<QString, QString> > linkMap; |
233 | QString mod; |
234 | QString u; |
235 | QString sinc; |
236 | QString tpl; |
237 | mutable QString uuid; |
238 | }; |
239 | |
240 | class FunctionNode; |
241 | class EnumNode; |
242 | |
243 | typedef QList<Node*> NodeList; |
244 | |
245 | class InnerNode : public Node |
246 | { |
247 | public: |
248 | virtual ~InnerNode(); |
249 | |
250 | Node* findNode(const QString& name); |
251 | Node* findNode(const QString& name, Type type); |
252 | FunctionNode* findFunctionNode(const QString& name); |
253 | FunctionNode* findFunctionNode(const FunctionNode* clone); |
254 | void addInclude(const QString &include); |
255 | void setIncludes(const QStringList &includes); |
256 | void setOverload(const FunctionNode* func, bool overlode); |
257 | void normalizeOverloads(); |
258 | void makeUndocumentedChildrenInternal(); |
259 | void deleteChildren(); |
260 | void removeFromRelated(); |
261 | |
262 | virtual bool isInnerNode() const; |
263 | const Node* findNode(const QString& name) const; |
264 | const Node* findNode(const QString& name, Type type) const; |
265 | const FunctionNode* findFunctionNode(const QString& name) const; |
266 | const FunctionNode* findFunctionNode(const FunctionNode* clone) const; |
267 | const EnumNode* findEnumNodeForValue(const QString &enumValue) const; |
268 | const NodeList & childNodes() const { return children; } |
269 | const NodeList & relatedNodes() const { return related; } |
270 | int count() const { return children.size(); } |
271 | int overloadNumber(const FunctionNode* func) const; |
272 | int numOverloads(const QString& funcName) const; |
273 | NodeList overloads(const QString &funcName) const; |
274 | const QStringList& includes() const { return inc; } |
275 | |
276 | QStringList primaryKeys(); |
277 | QStringList secondaryKeys(); |
278 | const QStringList& pageKeywords() const { return pageKeywds; } |
279 | virtual void addPageKeywords(const QString& t) { pageKeywds << t; } |
280 | virtual bool isAbstract() const { return false; } |
281 | virtual void setAbstract(bool ) { } |
282 | |
283 | protected: |
284 | InnerNode(Type type, InnerNode* parent, const QString& name); |
285 | |
286 | private: |
287 | friend class Node; |
288 | |
289 | static bool isSameSignature(const FunctionNode* f1, const FunctionNode* f2); |
290 | void addChild(Node* child); |
291 | void removeChild(Node* child); |
292 | void removeRelated(Node* pseudoChild); |
293 | |
294 | QStringList pageKeywds; |
295 | QStringList inc; |
296 | NodeList children; |
297 | NodeList enumChildren; |
298 | NodeList related; |
299 | QMap<QString, Node*> childMap; |
300 | QMap<QString, Node*> primaryFunctionMap; |
301 | QMap<QString, NodeList> secondaryFunctionMap; |
302 | }; |
303 | |
304 | class LeafNode : public Node |
305 | { |
306 | public: |
307 | LeafNode(); |
308 | virtual ~LeafNode() { } |
309 | |
310 | virtual bool isInnerNode() const; |
311 | |
312 | protected: |
313 | LeafNode(Type type, InnerNode* parent, const QString& name); |
314 | }; |
315 | |
316 | class NamespaceNode : public InnerNode |
317 | { |
318 | public: |
319 | NamespaceNode(InnerNode* parent, const QString& name); |
320 | virtual ~NamespaceNode() { } |
321 | }; |
322 | |
323 | class ClassNode; |
324 | |
325 | struct RelatedClass |
326 | { |
327 | RelatedClass() { } |
328 | RelatedClass(Node::Access access0, |
329 | ClassNode* node0, |
330 | const QString& dataTypeWithTemplateArgs0 = "") |
331 | : access(access0), |
332 | node(node0), |
333 | dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0) { } |
334 | QString accessString() const; |
335 | |
336 | Node::Access access; |
337 | ClassNode* node; |
338 | QString dataTypeWithTemplateArgs; |
339 | }; |
340 | |
341 | class PropertyNode; |
342 | |
343 | class ClassNode : public InnerNode |
344 | { |
345 | public: |
346 | ClassNode(InnerNode* parent, const QString& name); |
347 | virtual ~ClassNode() { } |
348 | |
349 | void addBaseClass(Access access, |
350 | ClassNode* node, |
351 | const QString &dataTypeWithTemplateArgs = ""); |
352 | void fixBaseClasses(); |
353 | |
354 | const QList<RelatedClass> &baseClasses() const { return bases; } |
355 | const QList<RelatedClass> &derivedClasses() const { return derived; } |
356 | const QList<RelatedClass> &ignoredBaseClasses() const { return ignoredBases; } |
357 | |
358 | bool hideFromMainList() const { return hidden; } |
359 | void setHideFromMainList(bool value) { hidden = value; } |
360 | |
361 | QString serviceName() const { return sname; } |
362 | void setServiceName(const QString& value) { sname = value; } |
363 | QString qmlElement() const { return qmlelement; } |
364 | void setQmlElement(const QString& value) { qmlelement = value; } |
365 | virtual bool isAbstract() const { return abstract; } |
366 | virtual void setAbstract(bool b) { abstract = b; } |
367 | const PropertyNode* findPropertyNode(const QString& name) const; |
368 | |
369 | private: |
370 | QList<RelatedClass> bases; |
371 | QList<RelatedClass> derived; |
372 | QList<RelatedClass> ignoredBases; |
373 | bool hidden; |
374 | bool abstract; |
375 | QString sname; |
376 | QString qmlelement; |
377 | }; |
378 | |
379 | class FakeNode : public InnerNode |
380 | { |
381 | public: |
382 | |
383 | FakeNode(InnerNode* parent, const QString& name, SubType subType); |
384 | virtual ~FakeNode() { } |
385 | |
386 | void setTitle(const QString &title) { tle = title; } |
387 | void setSubTitle(const QString &subTitle) { stle = subTitle; } |
388 | void addGroupMember(Node* node) { gr.append(node); } |
389 | |
390 | SubType subType() const { return sub; } |
391 | virtual QString title() const; |
392 | virtual QString fullTitle() const; |
393 | virtual QString subTitle() const; |
394 | virtual QString imageFileName() const { return QString(); } |
395 | const NodeList &groupMembers() const { return gr; } |
396 | virtual QString nameForLists() const { return title(); } |
397 | virtual void setImageFileName(const QString& ) { } |
398 | |
399 | private: |
400 | SubType sub; |
401 | QString tle; |
402 | QString stle; |
403 | NodeList gr; |
404 | }; |
405 | |
406 | class ExampleNode : public FakeNode |
407 | { |
408 | public: |
409 | ExampleNode(InnerNode* parent, const QString& name); |
410 | virtual ~ExampleNode() { } |
411 | virtual QString imageFileName() const { return imageFileName_; } |
412 | virtual void setImageFileName(const QString& ifn) { imageFileName_ = ifn; } |
413 | virtual void addDependency(const QString& arg) { dependencies_.append(arg); } |
414 | const QStringList& dependencies() const { return dependencies_; } |
415 | |
416 | public: |
417 | static ExampleNodeMap exampleNodeMap; |
418 | |
419 | private: |
420 | QString imageFileName_; |
421 | QStringList dependencies_; |
422 | }; |
423 | |
424 | class QmlClassNode : public FakeNode |
425 | { |
426 | public: |
427 | QmlClassNode(InnerNode* parent, |
428 | const QString& name, |
429 | const ClassNode* cn); |
430 | virtual ~QmlClassNode(); |
431 | virtual bool isQmlNode() const { return true; } |
432 | |
433 | const ClassNode* classNode() const { return cnode; } |
434 | virtual QString fileBase() const; |
435 | static void addInheritedBy(const QString& base, Node* sub); |
436 | static void subclasses(const QString& base, NodeList& subs); |
437 | static void clear(); |
438 | |
439 | public: |
440 | static bool qmlOnly; |
441 | static QMultiMap<QString,Node*> inheritedBy; |
442 | |
443 | private: |
444 | const ClassNode* cnode; |
445 | }; |
446 | |
447 | class QmlBasicTypeNode : public FakeNode |
448 | { |
449 | public: |
450 | QmlBasicTypeNode(InnerNode* parent, |
451 | const QString& name); |
452 | virtual ~QmlBasicTypeNode() { } |
453 | virtual bool isQmlNode() const { return true; } |
454 | }; |
455 | |
456 | class QmlPropGroupNode : public FakeNode |
457 | { |
458 | public: |
459 | QmlPropGroupNode(QmlClassNode* parent, |
460 | const QString& name, |
461 | bool attached); |
462 | virtual ~QmlPropGroupNode() { } |
463 | virtual bool isQmlNode() const { return true; } |
464 | |
465 | const QString& element() const { return parent()->name(); } |
466 | void setDefault() { isdefault = true; } |
467 | bool isDefault() const { return isdefault; } |
468 | bool isAttached() const { return att; } |
469 | |
470 | private: |
471 | bool isdefault; |
472 | bool att; |
473 | }; |
474 | |
475 | class Tree; |
476 | |
477 | class QmlPropertyNode : public LeafNode |
478 | { |
479 | public: |
480 | QmlPropertyNode(QmlPropGroupNode* parent, |
481 | const QString& name, |
482 | const QString& type, |
483 | bool attached); |
484 | virtual ~QmlPropertyNode() { } |
485 | |
486 | void setDataType(const QString& dataType) { dt = dataType; } |
487 | void setStored(bool stored) { sto = toTrool(stored); } |
488 | void setDesignable(bool designable) { des = toTrool(designable); } |
489 | void setWritable(bool writable) { wri = toTrool(writable); } |
490 | |
491 | const QString &dataType() const { return dt; } |
492 | QString qualifiedDataType() const { return dt; } |
493 | bool isStored() const { return fromTrool(sto,true); } |
494 | bool isDesignable() const { return fromTrool(des,false); } |
495 | bool isWritable(const Tree* tree) const; |
496 | bool isAttached() const { return att; } |
497 | virtual bool isQmlNode() const { return true; } |
498 | |
499 | const PropertyNode *correspondingProperty(const Tree *tree) const; |
500 | |
501 | const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); } |
502 | |
503 | private: |
504 | enum Trool { Trool_True, Trool_False, Trool_Default }; |
505 | |
506 | static Trool toTrool(bool boolean); |
507 | static bool fromTrool(Trool troolean, bool defaultValue); |
508 | |
509 | QString dt; |
510 | Trool sto; |
511 | Trool des; |
512 | Trool wri; |
513 | bool att; |
514 | }; |
515 | |
516 | class EnumItem |
517 | { |
518 | public: |
519 | EnumItem() { } |
520 | EnumItem(const QString& name, const QString& value) |
521 | : nam(name), val(value) { } |
522 | EnumItem(const QString& name, const QString& value, const Text &txt) |
523 | : nam(name), val(value), txt(txt) { } |
524 | |
525 | const QString& name() const { return nam; } |
526 | const QString& value() const { return val; } |
527 | const Text &text() const { return txt; } |
528 | |
529 | private: |
530 | QString nam; |
531 | QString val; |
532 | Text txt; |
533 | }; |
534 | |
535 | class TypedefNode; |
536 | |
537 | class EnumNode : public LeafNode |
538 | { |
539 | public: |
540 | EnumNode(InnerNode* parent, const QString& name); |
541 | virtual ~EnumNode() { } |
542 | |
543 | void addItem(const EnumItem& item); |
544 | void setFlagsType(TypedefNode* typedeff); |
545 | bool hasItem(const QString &name) const { return names.contains(name); } |
546 | |
547 | const QList<EnumItem>& items() const { return itms; } |
548 | Access itemAccess(const QString& name) const; |
549 | const TypedefNode* flagsType() const { return ft; } |
550 | QString itemValue(const QString &name) const; |
551 | |
552 | private: |
553 | QList<EnumItem> itms; |
554 | QSet<QString> names; |
555 | const TypedefNode* ft; |
556 | }; |
557 | |
558 | class TypedefNode : public LeafNode |
559 | { |
560 | public: |
561 | TypedefNode(InnerNode* parent, const QString& name); |
562 | virtual ~TypedefNode() { } |
563 | |
564 | const EnumNode* associatedEnum() const { return ae; } |
565 | |
566 | private: |
567 | void setAssociatedEnum(const EnumNode* enume); |
568 | |
569 | friend class EnumNode; |
570 | |
571 | const EnumNode* ae; |
572 | }; |
573 | |
574 | inline void EnumNode::setFlagsType(TypedefNode* typedeff) |
575 | { |
576 | ft = typedeff; |
577 | typedeff->setAssociatedEnum(this); |
578 | } |
579 | |
580 | |
581 | class Parameter |
582 | { |
583 | public: |
584 | Parameter() {} |
585 | Parameter(const QString& leftType, |
586 | const QString& rightType = "", |
587 | const QString& name = "", |
588 | const QString& defaultValue = ""); |
589 | Parameter(const Parameter& p); |
590 | |
591 | Parameter& operator=(const Parameter& p); |
592 | |
593 | void setName(const QString& name) { nam = name; } |
594 | |
595 | bool hasType() const { return lef.length() + rig.length() > 0; } |
596 | const QString& leftType() const { return lef; } |
597 | const QString& rightType() const { return rig; } |
598 | const QString& name() const { return nam; } |
599 | const QString& defaultValue() const { return def; } |
600 | |
601 | QString reconstruct(bool value = false) const; |
602 | |
603 | private: |
604 | QString lef; |
605 | QString rig; |
606 | QString nam; |
607 | QString def; |
608 | }; |
609 | |
610 | class PropertyNode; |
611 | |
612 | class FunctionNode : public LeafNode |
613 | { |
614 | public: |
615 | enum Metaness { |
616 | Plain, |
617 | Signal, |
618 | Slot, |
619 | Ctor, |
620 | Dtor, |
621 | MacroWithParams, |
622 | MacroWithoutParams, |
623 | Native }; |
624 | enum Virtualness { NonVirtual, ImpureVirtual, PureVirtual }; |
625 | |
626 | FunctionNode(InnerNode* parent, const QString &name); |
627 | FunctionNode(Type type, InnerNode* parent, const QString &name, bool attached); |
628 | virtual ~FunctionNode() { } |
629 | |
630 | void setReturnType(const QString& returnType) { rt = returnType; } |
631 | void setParentPath(const QStringList& parentPath) { pp = parentPath; } |
632 | void setMetaness(Metaness metaness) { met = metaness; } |
633 | void setVirtualness(Virtualness virtualness); |
634 | void setConst(bool conste) { con = conste; } |
635 | void setStatic(bool statique) { sta = statique; } |
636 | void setOverload(bool overlode); |
637 | void setReimp(bool r); |
638 | void addParameter(const Parameter& parameter); |
639 | inline void setParameters(const QList<Parameter>& parameters); |
640 | void borrowParameterNames(const FunctionNode* source); |
641 | void setReimplementedFrom(FunctionNode* from); |
642 | |
643 | const QString& returnType() const { return rt; } |
644 | Metaness metaness() const { return met; } |
645 | bool isMacro() const { |
646 | return met == MacroWithParams || met == MacroWithoutParams; |
647 | } |
648 | Virtualness virtualness() const { return vir; } |
649 | bool isConst() const { return con; } |
650 | bool isStatic() const { return sta; } |
651 | bool isOverload() const { return ove; } |
652 | bool isReimp() const { return reimp; } |
653 | bool isFunction() const { return true; } |
654 | int overloadNumber() const; |
655 | int numOverloads() const; |
656 | const QList<Parameter>& parameters() const { return params; } |
657 | QStringList parameterNames() const; |
658 | QString rawParameters(bool names = false, bool values = false) const; |
659 | const FunctionNode* reimplementedFrom() const { return rf; } |
660 | const QList<FunctionNode*> &reimplementedBy() const { return rb; } |
661 | const PropertyNode* associatedProperty() const { return ap; } |
662 | const QStringList& parentPath() const { return pp; } |
663 | |
664 | QStringList reconstructParams(bool values = false) const; |
665 | QString signature(bool values = false) const; |
666 | const QString& element() const { return parent()->name(); } |
667 | bool isAttached() const { return att; } |
668 | virtual bool isQmlNode() const { |
669 | return ((type() == QmlSignal) || (type() == QmlMethod)); |
670 | } |
671 | virtual bool isInternal() const; |
672 | |
673 | void debug() const; |
674 | |
675 | private: |
676 | void setAssociatedProperty(PropertyNode* property); |
677 | |
678 | friend class InnerNode; |
679 | friend class PropertyNode; |
680 | |
681 | QString rt; |
682 | QStringList pp; |
683 | #ifdef Q_WS_WIN |
684 | Metaness met; |
685 | Virtualness vir; |
686 | #else |
687 | Metaness met : 4; |
688 | Virtualness vir : 2; |
689 | #endif |
690 | bool con : 1; |
691 | bool sta : 1; |
692 | bool ove : 1; |
693 | bool reimp: 1; |
694 | bool att: 1; |
695 | QList<Parameter> params; |
696 | const FunctionNode* rf; |
697 | const PropertyNode* ap; |
698 | QList<FunctionNode*> rb; |
699 | }; |
700 | |
701 | class PropertyNode : public LeafNode |
702 | { |
703 | public: |
704 | enum FunctionRole { Getter, Setter, Resetter, Notifier }; |
705 | enum { NumFunctionRoles = Notifier + 1 }; |
706 | |
707 | PropertyNode(InnerNode* parent, const QString& name); |
708 | virtual ~PropertyNode() { } |
709 | |
710 | void setDataType(const QString& dataType) { dt = dataType; } |
711 | void addFunction(FunctionNode* function, FunctionRole role); |
712 | void addSignal(FunctionNode* function, FunctionRole role); |
713 | void setStored(bool stored) { sto = toTrool(stored); } |
714 | void setDesignable(bool designable) { des = toTrool(designable); } |
715 | void setScriptable(bool scriptable) { scr = toTrool(scriptable); } |
716 | void setWritable(bool writable) { wri = toTrool(writable); } |
717 | void setUser(bool user) { usr = toTrool(user); } |
718 | void setOverriddenFrom(const PropertyNode* baseProperty); |
719 | void setRuntimeDesFunc(const QString& rdf) { runtimeDesFunc = rdf; } |
720 | void setRuntimeScrFunc(const QString& scrf) { runtimeScrFunc = scrf; } |
721 | void setConstant() { cst = true; } |
722 | void setFinal() { fnl = true; } |
723 | void setRevision(int revision) { rev = revision; } |
724 | |
725 | const QString &dataType() const { return dt; } |
726 | QString qualifiedDataType() const; |
727 | NodeList functions() const; |
728 | NodeList functions(FunctionRole role) const { return funcs[(int)role]; } |
729 | NodeList getters() const { return functions(Getter); } |
730 | NodeList setters() const { return functions(Setter); } |
731 | NodeList resetters() const { return functions(Resetter); } |
732 | NodeList notifiers() const { return functions(Notifier); } |
733 | bool isStored() const { return fromTrool(sto, storedDefault()); } |
734 | bool isDesignable() const { return fromTrool(des, designableDefault()); } |
735 | bool isScriptable() const { return fromTrool(scr, scriptableDefault()); } |
736 | const QString& runtimeDesignabilityFunction() const { return runtimeDesFunc; } |
737 | const QString& runtimeScriptabilityFunction() const { return runtimeScrFunc; } |
738 | bool isWritable() const { return fromTrool(wri, writableDefault()); } |
739 | bool isUser() const { return fromTrool(usr, userDefault()); } |
740 | bool isConstant() const { return cst; } |
741 | bool isFinal() const { return fnl; } |
742 | const PropertyNode* overriddenFrom() const { return overrides; } |
743 | |
744 | bool storedDefault() const { return true; } |
745 | bool userDefault() const { return false; } |
746 | bool designableDefault() const { return !setters().isEmpty(); } |
747 | bool scriptableDefault() const { return true; } |
748 | bool writableDefault() const { return !setters().isEmpty(); } |
749 | |
750 | private: |
751 | enum Trool { Trool_True, Trool_False, Trool_Default }; |
752 | |
753 | static Trool toTrool(bool boolean); |
754 | static bool fromTrool(Trool troolean, bool defaultValue); |
755 | |
756 | QString dt; |
757 | QString runtimeDesFunc; |
758 | QString runtimeScrFunc; |
759 | NodeList funcs[NumFunctionRoles]; |
760 | Trool sto; |
761 | Trool des; |
762 | Trool scr; |
763 | Trool wri; |
764 | Trool usr; |
765 | bool cst; |
766 | bool fnl; |
767 | int rev; |
768 | const PropertyNode* overrides; |
769 | }; |
770 | |
771 | inline void FunctionNode::setParameters(const QList<Parameter> ¶meters) |
772 | { |
773 | params = parameters; |
774 | } |
775 | |
776 | inline void PropertyNode::addFunction(FunctionNode* function, FunctionRole role) |
777 | { |
778 | funcs[(int)role].append(function); |
779 | function->setAssociatedProperty(this); |
780 | } |
781 | |
782 | inline void PropertyNode::addSignal(FunctionNode* function, FunctionRole role) |
783 | { |
784 | funcs[(int)role].append(function); |
785 | } |
786 | |
787 | inline NodeList PropertyNode::functions() const |
788 | { |
789 | NodeList list; |
790 | for (int i = 0; i < NumFunctionRoles; ++i) |
791 | list += funcs[i]; |
792 | return list; |
793 | } |
794 | |
795 | class VariableNode : public LeafNode |
796 | { |
797 | public: |
798 | VariableNode(InnerNode* parent, const QString &name); |
799 | virtual ~VariableNode() { } |
800 | |
801 | void setLeftType(const QString &leftType) { lt = leftType; } |
802 | void setRightType(const QString &rightType) { rt = rightType; } |
803 | void setStatic(bool statique) { sta = statique; } |
804 | |
805 | const QString &leftType() const { return lt; } |
806 | const QString &rightType() const { return rt; } |
807 | QString dataType() const { return lt + rt; } |
808 | bool isStatic() const { return sta; } |
809 | |
810 | private: |
811 | QString lt; |
812 | QString rt; |
813 | bool sta; |
814 | }; |
815 | |
816 | inline VariableNode::VariableNode(InnerNode* parent, const QString &name) |
817 | : LeafNode(Variable, parent, name), sta(false) |
818 | { |
819 | // nothing. |
820 | } |
821 | |
822 | class TargetNode : public LeafNode |
823 | { |
824 | public: |
825 | TargetNode(InnerNode* parent, const QString& name); |
826 | virtual ~TargetNode() { } |
827 | |
828 | virtual bool isInnerNode() const; |
829 | }; |
830 | |
831 | QT_END_NAMESPACE |
832 | |
833 | #endif |
834 |
Warning: That file was not part of the compilation database. It may have many parsing errors.