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
59QT_BEGIN_NAMESPACE
60
61class Node;
62class ClassNode;
63class InnerNode;
64class ExampleNode;
65class QmlClassNode;
66
67typedef QMap<QString, const Node*> NodeMap;
68typedef QMultiMap<QString, Node*> NodeMultiMap;
69typedef QMap<QString, const ExampleNode*> ExampleNodeMap;
70
71class 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
240class FunctionNode;
241class EnumNode;
242
243typedef QList<Node*> NodeList;
244
245class 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
304class 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
316class NamespaceNode : public InnerNode
317{
318 public:
319 NamespaceNode(InnerNode* parent, const QString& name);
320 virtual ~NamespaceNode() { }
321};
322
323class ClassNode;
324
325struct 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
341class PropertyNode;
342
343class 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
379class 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
406class 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
424class 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
447class 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
456class 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
475class Tree;
476
477class 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
516class 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
535class TypedefNode;
536
537class 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
558class 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
574inline void EnumNode::setFlagsType(TypedefNode* typedeff)
575{
576 ft = typedeff;
577 typedeff->setAssociatedEnum(this);
578}
579
580
581class 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
610class PropertyNode;
611
612class 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
701class 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
771inline void FunctionNode::setParameters(const QList<Parameter> &parameters)
772{
773 params = parameters;
774}
775
776inline void PropertyNode::addFunction(FunctionNode* function, FunctionRole role)
777{
778 funcs[(int)role].append(function);
779 function->setAssociatedProperty(this);
780}
781
782inline void PropertyNode::addSignal(FunctionNode* function, FunctionRole role)
783{
784 funcs[(int)role].append(function);
785}
786
787inline 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
795class 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
816inline VariableNode::VariableNode(InnerNode* parent, const QString &name)
817 : LeafNode(Variable, parent, name), sta(false)
818{
819 // nothing.
820}
821
822class TargetNode : public LeafNode
823{
824 public:
825 TargetNode(InnerNode* parent, const QString& name);
826 virtual ~TargetNode() { }
827
828 virtual bool isInnerNode() const;
829};
830
831QT_END_NAMESPACE
832
833#endif
834

Warning: That file was not part of the compilation database. It may have many parsing errors.