1 /****************************************************************************
2 **
3 ** Copyright (C) 2015 The Qt Company Ltd.
4 ** Contact: http://www.qt.io/licensing/
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 The Qt Company. For licensing terms
14 ** and conditions see http://www.qt.io/terms-conditions. For further
15 ** information use the contact form at http://www.qt.io/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 or version 3 as published by the Free
20 ** Software Foundation and appearing in the file LICENSE.LGPLv21 and
21 ** LICENSE.LGPLv3 included in the packaging of this file. Please review the
22 ** following information to ensure the GNU Lesser General Public License
23 ** requirements will be met: https://www.gnu.org/licenses/lgpl.html and
24 ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
25 **
26 ** As a special exception, The Qt Company gives you certain additional
27 ** rights. These rights are described in The Qt Company LGPL Exception
28 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
29 **
30 ** GNU General Public License Usage
31 ** Alternatively, this file may be used under the terms of the GNU
32 ** General Public License version 3.0 as published by the Free Software
33 ** Foundation and appearing in the file LICENSE.GPL included in the
34 ** packaging of this file. Please review the following information to
35 ** ensure the GNU General Public License version 3.0 requirements will be
36 ** met: http://www.gnu.org/copyleft/gpl.html.
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
setAccess(Access access)157 void setAccess(Access access) { acc = access; }
setLocation(const Location & location)158 void setLocation(const Location& location) { loc = location; }
159 void setDoc(const Doc& doc, bool replace = false);
setStatus(Status status)160 void setStatus(Status status) { sta = status; }
setThreadSafeness(ThreadSafeness safeness)161 void setThreadSafeness(ThreadSafeness safeness) { saf = safeness; }
162 void setSince(const QString &since);
163 void setRelates(InnerNode* pseudoParent);
setModuleName(const QString & module)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);
setTemplateStuff(const QString & templateStuff)167 void setTemplateStuff(const QString &templateStuff) { tpl = templateStuff; }
setPageType(PageType t)168 void setPageType(PageType t) { pageTyp = t; }
169 void setPageType(const QString& t);
addDependency(const QString &)170 virtual void addDependency(const QString& ) { }
171
172 virtual bool isInnerNode() const = 0;
isReimp()173 virtual bool isReimp() const { return false; }
isFunction()174 virtual bool isFunction() const { return false; }
isQmlNode()175 virtual bool isQmlNode() const { return false; }
isInternal()176 virtual bool isInternal() const { return false; }
type()177 Type type() const { return typ; }
subType()178 virtual SubType subType() const { return NoSubType; }
parent()179 InnerNode* parent() const { return par; }
relates()180 InnerNode* relates() const { return rel; }
name()181 const QString& name() const { return nam; }
links()182 QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; }
183 QString moduleName() const;
184 QString url() const;
nameForLists()185 virtual QString nameForLists() const { return nam; }
186
access()187 Access access() const { return acc; }
188 QString accessString() const;
location()189 const Location& location() const { return loc; }
doc()190 const Doc& doc() const { return d; }
status()191 Status status() const { return sta; }
192 Status inheritedStatus() const;
193 ThreadSafeness threadSafeness() const;
194 ThreadSafeness inheritedThreadSafeness() const;
since()195 QString since() const { return sinc; }
templateStuff()196 QString templateStuff() const { return tpl; }
pageType()197 PageType pageType() const { return pageTyp; }
addPageKeywords(const QString &)198 virtual void addPageKeywords(const QString& ) { }
199
clearRelated()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;
childNodes()268 const NodeList & childNodes() const { return children; }
relatedNodes()269 const NodeList & relatedNodes() const { return related; }
count()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;
includes()274 const QStringList& includes() const { return inc; }
275
276 QStringList primaryKeys();
277 QStringList secondaryKeys();
pageKeywords()278 const QStringList& pageKeywords() const { return pageKeywds; }
addPageKeywords(const QString & t)279 virtual void addPageKeywords(const QString& t) { pageKeywds << t; }
isAbstract()280 virtual bool isAbstract() const { return false; }
setAbstract(bool)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();
~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);
~NamespaceNode()320 virtual ~NamespaceNode() { }
321 };
322
323 class ClassNode;
324
325 struct RelatedClass
326 {
RelatedClassRelatedClass327 RelatedClass() { }
328 RelatedClass(Node::Access access0,
329 ClassNode* node0,
330 const QString& dataTypeWithTemplateArgs0 = "")
accessRelatedClass331 : 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);
~ClassNode()347 virtual ~ClassNode() { }
348
349 void addBaseClass(Access access,
350 ClassNode* node,
351 const QString &dataTypeWithTemplateArgs = "");
352 void fixBaseClasses();
353
baseClasses()354 const QList<RelatedClass> &baseClasses() const { return bases; }
derivedClasses()355 const QList<RelatedClass> &derivedClasses() const { return derived; }
ignoredBaseClasses()356 const QList<RelatedClass> &ignoredBaseClasses() const { return ignoredBases; }
357
hideFromMainList()358 bool hideFromMainList() const { return hidden; }
setHideFromMainList(bool value)359 void setHideFromMainList(bool value) { hidden = value; }
360
serviceName()361 QString serviceName() const { return sname; }
setServiceName(const QString & value)362 void setServiceName(const QString& value) { sname = value; }
qmlElement()363 QString qmlElement() const { return qmlelement; }
setQmlElement(const QString & value)364 void setQmlElement(const QString& value) { qmlelement = value; }
isAbstract()365 virtual bool isAbstract() const { return abstract; }
setAbstract(bool b)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);
~FakeNode()384 virtual ~FakeNode() { }
385
setTitle(const QString & title)386 void setTitle(const QString &title) { tle = title; }
setSubTitle(const QString & subTitle)387 void setSubTitle(const QString &subTitle) { stle = subTitle; }
addGroupMember(Node * node)388 void addGroupMember(Node* node) { gr.append(node); }
389
subType()390 SubType subType() const { return sub; }
391 virtual QString title() const;
392 virtual QString fullTitle() const;
393 virtual QString subTitle() const;
imageFileName()394 virtual QString imageFileName() const { return QString(); }
groupMembers()395 const NodeList &groupMembers() const { return gr; }
nameForLists()396 virtual QString nameForLists() const { return title(); }
setImageFileName(const QString &)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);
~ExampleNode()410 virtual ~ExampleNode() { }
imageFileName()411 virtual QString imageFileName() const { return imageFileName_; }
setImageFileName(const QString & ifn)412 virtual void setImageFileName(const QString& ifn) { imageFileName_ = ifn; }
addDependency(const QString & arg)413 virtual void addDependency(const QString& arg) { dependencies_.append(arg); }
dependencies()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();
isQmlNode()431 virtual bool isQmlNode() const { return true; }
432
classNode()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);
~QmlBasicTypeNode()452 virtual ~QmlBasicTypeNode() { }
isQmlNode()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);
~QmlPropGroupNode()462 virtual ~QmlPropGroupNode() { }
isQmlNode()463 virtual bool isQmlNode() const { return true; }
464
element()465 const QString& element() const { return parent()->name(); }
setDefault()466 void setDefault() { isdefault = true; }
isDefault()467 bool isDefault() const { return isdefault; }
isAttached()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);
~QmlPropertyNode()484 virtual ~QmlPropertyNode() { }
485
setDataType(const QString & dataType)486 void setDataType(const QString& dataType) { dt = dataType; }
setStored(bool stored)487 void setStored(bool stored) { sto = toTrool(stored); }
setDesignable(bool designable)488 void setDesignable(bool designable) { des = toTrool(designable); }
setWritable(bool writable)489 void setWritable(bool writable) { wri = toTrool(writable); }
490
dataType()491 const QString &dataType() const { return dt; }
qualifiedDataType()492 QString qualifiedDataType() const { return dt; }
isStored()493 bool isStored() const { return fromTrool(sto,true); }
isDesignable()494 bool isDesignable() const { return fromTrool(des,false); }
495 bool isWritable(const Tree* tree) const;
isAttached()496 bool isAttached() const { return att; }
isQmlNode()497 virtual bool isQmlNode() const { return true; }
498
499 const PropertyNode *correspondingProperty(const Tree *tree) const;
500
element()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:
EnumItem()519 EnumItem() { }
EnumItem(const QString & name,const QString & value)520 EnumItem(const QString& name, const QString& value)
521 : nam(name), val(value) { }
EnumItem(const QString & name,const QString & value,const Text & txt)522 EnumItem(const QString& name, const QString& value, const Text &txt)
523 : nam(name), val(value), txt(txt) { }
524
name()525 const QString& name() const { return nam; }
value()526 const QString& value() const { return val; }
text()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);
~EnumNode()541 virtual ~EnumNode() { }
542
543 void addItem(const EnumItem& item);
544 void setFlagsType(TypedefNode* typedeff);
hasItem(const QString & name)545 bool hasItem(const QString &name) const { return names.contains(name); }
546
items()547 const QList<EnumItem>& items() const { return itms; }
548 Access itemAccess(const QString& name) const;
flagsType()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);
~TypedefNode()562 virtual ~TypedefNode() { }
563
associatedEnum()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
setFlagsType(TypedefNode * typedeff)574 inline void EnumNode::setFlagsType(TypedefNode* typedeff)
575 {
576 ft = typedeff;
577 typedeff->setAssociatedEnum(this);
578 }
579
580
581 class Parameter
582 {
583 public:
Parameter()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
setName(const QString & name)593 void setName(const QString& name) { nam = name; }
594
hasType()595 bool hasType() const { return lef.length() + rig.length() > 0; }
leftType()596 const QString& leftType() const { return lef; }
rightType()597 const QString& rightType() const { return rig; }
name()598 const QString& name() const { return nam; }
defaultValue()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);
~FunctionNode()628 virtual ~FunctionNode() { }
629
setReturnType(const QString & returnType)630 void setReturnType(const QString& returnType) { rt = returnType; }
setParentPath(const QStringList & parentPath)631 void setParentPath(const QStringList& parentPath) { pp = parentPath; }
setMetaness(Metaness metaness)632 void setMetaness(Metaness metaness) { met = metaness; }
633 void setVirtualness(Virtualness virtualness);
setConst(bool conste)634 void setConst(bool conste) { con = conste; }
setStatic(bool statique)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
returnType()643 const QString& returnType() const { return rt; }
metaness()644 Metaness metaness() const { return met; }
isMacro()645 bool isMacro() const {
646 return met == MacroWithParams || met == MacroWithoutParams;
647 }
virtualness()648 Virtualness virtualness() const { return vir; }
isConst()649 bool isConst() const { return con; }
isStatic()650 bool isStatic() const { return sta; }
isOverload()651 bool isOverload() const { return ove; }
isReimp()652 bool isReimp() const { return reimp; }
isFunction()653 bool isFunction() const { return true; }
654 int overloadNumber() const;
655 int numOverloads() const;
parameters()656 const QList<Parameter>& parameters() const { return params; }
657 QStringList parameterNames() const;
658 QString rawParameters(bool names = false, bool values = false) const;
reimplementedFrom()659 const FunctionNode* reimplementedFrom() const { return rf; }
reimplementedBy()660 const QList<FunctionNode*> &reimplementedBy() const { return rb; }
associatedProperty()661 const PropertyNode* associatedProperty() const { return ap; }
parentPath()662 const QStringList& parentPath() const { return pp; }
663
664 QStringList reconstructParams(bool values = false) const;
665 QString signature(bool values = false) const;
element()666 const QString& element() const { return parent()->name(); }
isAttached()667 bool isAttached() const { return att; }
isQmlNode()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);
~PropertyNode()708 virtual ~PropertyNode() { }
709
setDataType(const QString & dataType)710 void setDataType(const QString& dataType) { dt = dataType; }
711 void addFunction(FunctionNode* function, FunctionRole role);
712 void addSignal(FunctionNode* function, FunctionRole role);
setStored(bool stored)713 void setStored(bool stored) { sto = toTrool(stored); }
setDesignable(bool designable)714 void setDesignable(bool designable) { des = toTrool(designable); }
setScriptable(bool scriptable)715 void setScriptable(bool scriptable) { scr = toTrool(scriptable); }
setWritable(bool writable)716 void setWritable(bool writable) { wri = toTrool(writable); }
setUser(bool user)717 void setUser(bool user) { usr = toTrool(user); }
718 void setOverriddenFrom(const PropertyNode* baseProperty);
setRuntimeDesFunc(const QString & rdf)719 void setRuntimeDesFunc(const QString& rdf) { runtimeDesFunc = rdf; }
setRuntimeScrFunc(const QString & scrf)720 void setRuntimeScrFunc(const QString& scrf) { runtimeScrFunc = scrf; }
setConstant()721 void setConstant() { cst = true; }
setFinal()722 void setFinal() { fnl = true; }
setRevision(int revision)723 void setRevision(int revision) { rev = revision; }
724
dataType()725 const QString &dataType() const { return dt; }
726 QString qualifiedDataType() const;
727 NodeList functions() const;
functions(FunctionRole role)728 NodeList functions(FunctionRole role) const { return funcs[(int)role]; }
getters()729 NodeList getters() const { return functions(Getter); }
setters()730 NodeList setters() const { return functions(Setter); }
resetters()731 NodeList resetters() const { return functions(Resetter); }
notifiers()732 NodeList notifiers() const { return functions(Notifier); }
isStored()733 bool isStored() const { return fromTrool(sto, storedDefault()); }
isDesignable()734 bool isDesignable() const { return fromTrool(des, designableDefault()); }
isScriptable()735 bool isScriptable() const { return fromTrool(scr, scriptableDefault()); }
runtimeDesignabilityFunction()736 const QString& runtimeDesignabilityFunction() const { return runtimeDesFunc; }
runtimeScriptabilityFunction()737 const QString& runtimeScriptabilityFunction() const { return runtimeScrFunc; }
isWritable()738 bool isWritable() const { return fromTrool(wri, writableDefault()); }
isUser()739 bool isUser() const { return fromTrool(usr, userDefault()); }
isConstant()740 bool isConstant() const { return cst; }
isFinal()741 bool isFinal() const { return fnl; }
overriddenFrom()742 const PropertyNode* overriddenFrom() const { return overrides; }
743
storedDefault()744 bool storedDefault() const { return true; }
userDefault()745 bool userDefault() const { return false; }
designableDefault()746 bool designableDefault() const { return !setters().isEmpty(); }
scriptableDefault()747 bool scriptableDefault() const { return true; }
writableDefault()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
setParameters(const QList<Parameter> & parameters)771 inline void FunctionNode::setParameters(const QList<Parameter> ¶meters)
772 {
773 params = parameters;
774 }
775
addFunction(FunctionNode * function,FunctionRole role)776 inline void PropertyNode::addFunction(FunctionNode* function, FunctionRole role)
777 {
778 funcs[(int)role].append(function);
779 function->setAssociatedProperty(this);
780 }
781
addSignal(FunctionNode * function,FunctionRole role)782 inline void PropertyNode::addSignal(FunctionNode* function, FunctionRole role)
783 {
784 funcs[(int)role].append(function);
785 }
786
functions()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);
~VariableNode()799 virtual ~VariableNode() { }
800
setLeftType(const QString & leftType)801 void setLeftType(const QString &leftType) { lt = leftType; }
setRightType(const QString & rightType)802 void setRightType(const QString &rightType) { rt = rightType; }
setStatic(bool statique)803 void setStatic(bool statique) { sta = statique; }
804
leftType()805 const QString &leftType() const { return lt; }
rightType()806 const QString &rightType() const { return rt; }
dataType()807 QString dataType() const { return lt + rt; }
isStatic()808 bool isStatic() const { return sta; }
809
810 private:
811 QString lt;
812 QString rt;
813 bool sta;
814 };
815
VariableNode(InnerNode * parent,const QString & name)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);
~TargetNode()826 virtual ~TargetNode() { }
827
828 virtual bool isInnerNode() const;
829 };
830
831 QT_END_NAMESPACE
832
833 #endif
834