| /**************************************************************************** |
| ** |
| ** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies). |
| ** All rights reserved. |
| ** Contact: Nokia Corporation (qt-info@nokia.com) |
| ** |
| ** This file is part of the tools applications of the Qt Toolkit. |
| ** |
| ** $QT_BEGIN_LICENSE:LGPL$ |
| ** GNU Lesser General Public License Usage |
| ** This file may be used under the terms of the GNU Lesser General Public |
| ** License version 2.1 as published by the Free Software Foundation and |
| ** appearing in the file LICENSE.LGPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU Lesser |
| ** General Public License version 2.1 requirements will be met: |
| ** http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html. |
| ** |
| ** In addition, as a special exception, Nokia gives you certain additional |
| ** rights. These rights are described in the Nokia Qt LGPL Exception |
| ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package. |
| ** |
| ** GNU General Public License Usage |
| ** Alternatively, this file may be used under the terms of the GNU General |
| ** Public License version 3.0 as published by the Free Software Foundation |
| ** and appearing in the file LICENSE.GPL included in the packaging of this |
| ** file. Please review the following information to ensure the GNU General |
| ** Public License version 3.0 requirements will be met: |
| ** http://www.gnu.org/copyleft/gpl.html. |
| ** |
| ** Other Usage |
| ** Alternatively, this file may be used in accordance with the terms and |
| ** conditions contained in a signed written agreement between you and Nokia. |
| ** |
| ** |
| ** |
| ** |
| ** |
| ** $QT_END_LICENSE$ |
| ** |
| ****************************************************************************/ |
| |
| /* |
| node.h |
| */ |
| |
| #ifndef NODE_H |
| #define NODE_H |
| |
| #include <qdir.h> |
| #include <qmap.h> |
| #include <qpair.h> |
| #include <qstringlist.h> |
| |
| #include "codechunk.h" |
| #include "doc.h" |
| #include "location.h" |
| #include "text.h" |
| |
| QT_BEGIN_NAMESPACE |
| |
| class InnerNode; |
| |
| class Node |
| { |
| public: |
| enum Type { |
| Namespace, |
| Class, |
| Fake, |
| Enum, |
| Typedef, |
| Function, |
| Property, |
| Variable, |
| #ifdef QDOC_QML |
| Target, |
| QmlProperty, |
| QmlSignal, |
| QmlMethod, |
| LastType |
| #else |
| Target, |
| LastType |
| #endif |
| }; |
| |
| enum SubType { |
| NoSubType, |
| Example, |
| HeaderFile, |
| File, |
| Image, |
| Group, |
| Module, |
| Page, |
| #ifdef QDOC_QML |
| ExternalPage, |
| QmlClass, |
| QmlPropertyGroup, |
| QmlBasicType |
| #else |
| ExternalPage |
| #endif |
| }; |
| |
| enum Access { Public, Protected, Private }; |
| |
| enum Status { |
| Compat, |
| Obsolete, |
| Deprecated, |
| Preliminary, |
| Commendable, |
| Main, |
| Internal |
| }; // don't reorder this enum |
| |
| enum ThreadSafeness { |
| UnspecifiedSafeness, |
| NonReentrant, |
| Reentrant, |
| ThreadSafe |
| }; |
| |
| enum LinkType { |
| StartLink, |
| NextLink, |
| PreviousLink, |
| ContentsLink, |
| IndexLink, |
| InheritsLink /*, |
| GlossaryLink, |
| CopyrightLink, |
| ChapterLink, |
| SectionLink, |
| SubsectionLink, |
| AppendixLink */ |
| }; |
| |
| enum PageType { |
| NoPageType, |
| ApiPage, |
| ArticlePage, |
| ExamplePage |
| }; |
| |
| virtual ~Node(); |
| |
| void setAccess(Access access) { acc = access; } |
| void setLocation(const Location& location) { loc = location; } |
| void setDoc(const Doc& doc, bool replace = false); |
| void setStatus(Status status) { sta = status; } |
| void setThreadSafeness(ThreadSafeness safeness) { saf = safeness; } |
| void setSince(const QString &since); |
| void setRelates(InnerNode* pseudoParent); |
| void setModuleName(const QString &module) { mod = module; } |
| void setLink(LinkType linkType, const QString &link, const QString &desc); |
| void setUrl(const QString &url); |
| void setTemplateStuff(const QString &templateStuff) { tpl = templateStuff; } |
| void setPageType(PageType t) { pageTyp = t; } |
| void setPageType(const QString& t); |
| |
| virtual bool isInnerNode() const = 0; |
| virtual bool isReimp() const { return false; } |
| virtual bool isFunction() const { return false; } |
| virtual bool isQmlNode() const { return false; } |
| virtual bool isInternal() const { return false; } |
| Type type() const { return typ; } |
| virtual SubType subType() const { return NoSubType; } |
| InnerNode* parent() const { return par; } |
| InnerNode* relates() const { return rel; } |
| const QString& name() const { return nam; } |
| QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; } |
| QString moduleName() const; |
| QString url() const; |
| virtual QString nameForLists() const { return nam; } |
| |
| Access access() const { return acc; } |
| QString accessString() const; |
| const Location& location() const { return loc; } |
| const Doc& doc() const { return d; } |
| Status status() const { return sta; } |
| Status inheritedStatus() const; |
| ThreadSafeness threadSafeness() const; |
| ThreadSafeness inheritedThreadSafeness() const; |
| QString since() const { return sinc; } |
| QString templateStuff() const { return tpl; } |
| PageType pageType() const { return pageTyp; } |
| virtual void addPageKeywords(const QString& ) { } |
| |
| void clearRelated() { rel = 0; } |
| |
| virtual QString fileBase() const; |
| QString guid() const; |
| QString ditaXmlHref(); |
| QString extractClassName(const QString &string) const; |
| |
| protected: |
| Node(Type type, InnerNode* parent, const QString& name); |
| |
| private: |
| |
| #ifdef Q_WS_WIN |
| Type typ; |
| Access acc; |
| ThreadSafeness saf; |
| PageType pageTyp; |
| Status sta; |
| #else |
| Type typ : 4; |
| Access acc : 2; |
| ThreadSafeness saf : 2; |
| PageType pageTyp : 4; |
| Status sta : 3; |
| #endif |
| InnerNode* par; |
| InnerNode* rel; |
| QString nam; |
| Location loc; |
| Doc d; |
| QMap<LinkType, QPair<QString, QString> > linkMap; |
| QString mod; |
| QString u; |
| QString sinc; |
| QString tpl; |
| mutable QString uuid; |
| }; |
| |
| class FunctionNode; |
| class EnumNode; |
| |
| typedef QList<Node*> NodeList; |
| |
| class InnerNode : public Node |
| { |
| public: |
| virtual ~InnerNode(); |
| |
| Node* findNode(const QString& name); |
| Node* findNode(const QString& name, Type type); |
| FunctionNode* findFunctionNode(const QString& name); |
| FunctionNode* findFunctionNode(const FunctionNode* clone); |
| void addInclude(const QString &include); |
| void setIncludes(const QStringList &includes); |
| void setOverload(const FunctionNode* func, bool overlode); |
| void normalizeOverloads(); |
| void makeUndocumentedChildrenInternal(); |
| void deleteChildren(); |
| void removeFromRelated(); |
| |
| virtual bool isInnerNode() const; |
| const Node* findNode(const QString& name) const; |
| const Node* findNode(const QString& name, Type type) const; |
| const FunctionNode* findFunctionNode(const QString& name) const; |
| const FunctionNode* findFunctionNode(const FunctionNode* clone) const; |
| const EnumNode* findEnumNodeForValue(const QString &enumValue) const; |
| const NodeList & childNodes() const { return children; } |
| const NodeList & relatedNodes() const { return related; } |
| int count() const { return children.size(); } |
| int overloadNumber(const FunctionNode* func) const; |
| int numOverloads(const QString& funcName) const; |
| NodeList overloads(const QString &funcName) const; |
| const QStringList& includes() const { return inc; } |
| |
| QStringList primaryKeys(); |
| QStringList secondaryKeys(); |
| const QStringList& pageKeywords() const { return pageKeywds; } |
| virtual void addPageKeywords(const QString& t) { pageKeywds << t; } |
| virtual bool isAbstract() const { return false; } |
| virtual void setAbstract(bool ) { } |
| |
| protected: |
| InnerNode(Type type, InnerNode* parent, const QString& name); |
| |
| private: |
| friend class Node; |
| |
| static bool isSameSignature(const FunctionNode* f1, const FunctionNode* f2); |
| void addChild(Node* child); |
| void removeChild(Node* child); |
| void removeRelated(Node* pseudoChild); |
| |
| QStringList pageKeywds; |
| QStringList inc; |
| NodeList children; |
| NodeList enumChildren; |
| NodeList related; |
| QMap<QString, Node*> childMap; |
| QMap<QString, Node*> primaryFunctionMap; |
| QMap<QString, NodeList> secondaryFunctionMap; |
| }; |
| |
| class LeafNode : public Node |
| { |
| public: |
| LeafNode(); |
| virtual ~LeafNode() { } |
| |
| virtual bool isInnerNode() const; |
| |
| protected: |
| LeafNode(Type type, InnerNode* parent, const QString& name); |
| }; |
| |
| class NamespaceNode : public InnerNode |
| { |
| public: |
| NamespaceNode(InnerNode* parent, const QString& name); |
| virtual ~NamespaceNode() { } |
| }; |
| |
| class ClassNode; |
| |
| struct RelatedClass |
| { |
| RelatedClass() { } |
| RelatedClass(Node::Access access0, |
| ClassNode* node0, |
| const QString& dataTypeWithTemplateArgs0 = "") |
| : access(access0), |
| node(node0), |
| dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0) { } |
| QString accessString() const; |
| |
| Node::Access access; |
| ClassNode* node; |
| QString dataTypeWithTemplateArgs; |
| }; |
| |
| class PropertyNode; |
| |
| class ClassNode : public InnerNode |
| { |
| public: |
| ClassNode(InnerNode* parent, const QString& name); |
| virtual ~ClassNode() { } |
| |
| void addBaseClass(Access access, |
| ClassNode* node, |
| const QString &dataTypeWithTemplateArgs = ""); |
| void fixBaseClasses(); |
| |
| const QList<RelatedClass> &baseClasses() const { return bases; } |
| const QList<RelatedClass> &derivedClasses() const { return derived; } |
| const QList<RelatedClass> &ignoredBaseClasses() const { return ignoredBases; } |
| |
| bool hideFromMainList() const { return hidden; } |
| void setHideFromMainList(bool value) { hidden = value; } |
| |
| QString serviceName() const { return sname; } |
| void setServiceName(const QString& value) { sname = value; } |
| QString qmlElement() const { return qmlelement; } |
| void setQmlElement(const QString& value) { qmlelement = value; } |
| virtual bool isAbstract() const { return abstract; } |
| virtual void setAbstract(bool b) { abstract = b; } |
| const PropertyNode* findPropertyNode(const QString& name) const; |
| |
| private: |
| QList<RelatedClass> bases; |
| QList<RelatedClass> derived; |
| QList<RelatedClass> ignoredBases; |
| bool hidden; |
| bool abstract; |
| QString sname; |
| QString qmlelement; |
| }; |
| |
| class FakeNode : public InnerNode |
| { |
| public: |
| |
| FakeNode(InnerNode* parent, const QString& name, SubType subType); |
| virtual ~FakeNode() { } |
| |
| void setTitle(const QString &title) { tle = title; } |
| void setSubTitle(const QString &subTitle) { stle = subTitle; } |
| void addGroupMember(Node* node) { gr.append(node); } |
| |
| SubType subType() const { return sub; } |
| virtual QString title() const; |
| virtual QString fullTitle() const; |
| virtual QString subTitle() const; |
| const NodeList &groupMembers() const { return gr; } |
| virtual QString nameForLists() const { return title(); } |
| |
| private: |
| SubType sub; |
| QString tle; |
| QString stle; |
| NodeList gr; |
| }; |
| |
| #ifdef QDOC_QML |
| class QmlClassNode : public FakeNode |
| { |
| public: |
| QmlClassNode(InnerNode* parent, |
| const QString& name, |
| const ClassNode* cn); |
| virtual ~QmlClassNode(); |
| virtual bool isQmlNode() const { return true; } |
| |
| const ClassNode* classNode() const { return cnode; } |
| virtual QString fileBase() const; |
| static void addInheritedBy(const QString& base, Node* sub); |
| static void subclasses(const QString& base, NodeList& subs); |
| static void clear(); |
| |
| public: |
| static bool qmlOnly; |
| static QMultiMap<QString,Node*> inheritedBy; |
| |
| private: |
| const ClassNode* cnode; |
| }; |
| |
| class QmlBasicTypeNode : public FakeNode |
| { |
| public: |
| QmlBasicTypeNode(InnerNode* parent, |
| const QString& name); |
| virtual ~QmlBasicTypeNode() { } |
| virtual bool isQmlNode() const { return true; } |
| }; |
| |
| class QmlPropGroupNode : public FakeNode |
| { |
| public: |
| QmlPropGroupNode(QmlClassNode* parent, |
| const QString& name, |
| bool attached); |
| virtual ~QmlPropGroupNode() { } |
| virtual bool isQmlNode() const { return true; } |
| |
| const QString& element() const { return parent()->name(); } |
| void setDefault() { isdefault = true; } |
| bool isDefault() const { return isdefault; } |
| bool isAttached() const { return att; } |
| |
| private: |
| bool isdefault; |
| bool att; |
| }; |
| |
| class Tree; |
| |
| class QmlPropertyNode : public LeafNode |
| { |
| public: |
| QmlPropertyNode(QmlPropGroupNode* parent, |
| const QString& name, |
| const QString& type, |
| bool attached); |
| virtual ~QmlPropertyNode() { } |
| |
| void setDataType(const QString& dataType) { dt = dataType; } |
| void setStored(bool stored) { sto = toTrool(stored); } |
| void setDesignable(bool designable) { des = toTrool(designable); } |
| void setWritable(bool writable) { wri = toTrool(writable); } |
| |
| const QString &dataType() const { return dt; } |
| QString qualifiedDataType() const { return dt; } |
| bool isStored() const { return fromTrool(sto,true); } |
| bool isDesignable() const { return fromTrool(des,false); } |
| bool isWritable(const Tree* tree) const; |
| bool isAttached() const { return att; } |
| virtual bool isQmlNode() const { return true; } |
| |
| const PropertyNode *correspondingProperty(const Tree *tree) const; |
| |
| const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); } |
| |
| private: |
| enum Trool { Trool_True, Trool_False, Trool_Default }; |
| |
| static Trool toTrool(bool boolean); |
| static bool fromTrool(Trool troolean, bool defaultValue); |
| |
| QString dt; |
| Trool sto; |
| Trool des; |
| Trool wri; |
| bool att; |
| }; |
| #endif |
| |
| class EnumItem |
| { |
| public: |
| EnumItem() { } |
| EnumItem(const QString& name, const QString& value) |
| : nam(name), val(value) { } |
| EnumItem(const QString& name, const QString& value, const Text &txt) |
| : nam(name), val(value), txt(txt) { } |
| |
| const QString& name() const { return nam; } |
| const QString& value() const { return val; } |
| const Text &text() const { return txt; } |
| |
| private: |
| QString nam; |
| QString val; |
| Text txt; |
| }; |
| |
| class TypedefNode; |
| |
| class EnumNode : public LeafNode |
| { |
| public: |
| EnumNode(InnerNode* parent, const QString& name); |
| virtual ~EnumNode() { } |
| |
| void addItem(const EnumItem& item); |
| void setFlagsType(TypedefNode* typedeff); |
| bool hasItem(const QString &name) const { return names.contains(name); } |
| |
| const QList<EnumItem>& items() const { return itms; } |
| Access itemAccess(const QString& name) const; |
| const TypedefNode* flagsType() const { return ft; } |
| QString itemValue(const QString &name) const; |
| |
| private: |
| QList<EnumItem> itms; |
| QSet<QString> names; |
| const TypedefNode* ft; |
| }; |
| |
| class TypedefNode : public LeafNode |
| { |
| public: |
| TypedefNode(InnerNode* parent, const QString& name); |
| virtual ~TypedefNode() { } |
| |
| const EnumNode* associatedEnum() const { return ae; } |
| |
| private: |
| void setAssociatedEnum(const EnumNode* enume); |
| |
| friend class EnumNode; |
| |
| const EnumNode* ae; |
| }; |
| |
| inline void EnumNode::setFlagsType(TypedefNode* typedeff) |
| { |
| ft = typedeff; |
| typedeff->setAssociatedEnum(this); |
| } |
| |
| |
| class Parameter |
| { |
| public: |
| Parameter() {} |
| Parameter(const QString& leftType, |
| const QString& rightType = "", |
| const QString& name = "", |
| const QString& defaultValue = ""); |
| Parameter(const Parameter& p); |
| |
| Parameter& operator=(const Parameter& p); |
| |
| void setName(const QString& name) { nam = name; } |
| |
| bool hasType() const { return lef.length() + rig.length() > 0; } |
| const QString& leftType() const { return lef; } |
| const QString& rightType() const { return rig; } |
| const QString& name() const { return nam; } |
| const QString& defaultValue() const { return def; } |
| |
| QString reconstruct(bool value = false) const; |
| |
| private: |
| QString lef; |
| QString rig; |
| QString nam; |
| QString def; |
| }; |
| |
| class PropertyNode; |
| |
| class FunctionNode : public LeafNode |
| { |
| public: |
| enum Metaness { |
| Plain, |
| Signal, |
| Slot, |
| Ctor, |
| Dtor, |
| MacroWithParams, |
| MacroWithoutParams, |
| Native }; |
| enum Virtualness { NonVirtual, ImpureVirtual, PureVirtual }; |
| |
| FunctionNode(InnerNode* parent, const QString &name); |
| FunctionNode(Type type, InnerNode* parent, const QString &name, bool attached); |
| virtual ~FunctionNode() { } |
| |
| void setReturnType(const QString& returnType) { rt = returnType; } |
| void setParentPath(const QStringList& parentPath) { pp = parentPath; } |
| void setMetaness(Metaness metaness) { met = metaness; } |
| void setVirtualness(Virtualness virtualness); |
| void setConst(bool conste) { con = conste; } |
| void setStatic(bool statique) { sta = statique; } |
| void setOverload(bool overlode); |
| void setReimp(bool r); |
| void addParameter(const Parameter& parameter); |
| inline void setParameters(const QList<Parameter>& parameters); |
| void borrowParameterNames(const FunctionNode* source); |
| void setReimplementedFrom(FunctionNode* from); |
| |
| const QString& returnType() const { return rt; } |
| Metaness metaness() const { return met; } |
| bool isMacro() const { |
| return met == MacroWithParams || met == MacroWithoutParams; |
| } |
| Virtualness virtualness() const { return vir; } |
| bool isConst() const { return con; } |
| bool isStatic() const { return sta; } |
| bool isOverload() const { return ove; } |
| bool isReimp() const { return reimp; } |
| bool isFunction() const { return true; } |
| int overloadNumber() const; |
| int numOverloads() const; |
| const QList<Parameter>& parameters() const { return params; } |
| QStringList parameterNames() const; |
| QString rawParameters(bool names = false, bool values = false) const; |
| const FunctionNode* reimplementedFrom() const { return rf; } |
| const QList<FunctionNode*> &reimplementedBy() const { return rb; } |
| const PropertyNode* associatedProperty() const { return ap; } |
| const QStringList& parentPath() const { return pp; } |
| |
| QStringList reconstructParams(bool values = false) const; |
| QString signature(bool values = false) const; |
| const QString& element() const { return parent()->name(); } |
| bool isAttached() const { return att; } |
| virtual bool isQmlNode() const { |
| return ((type() == QmlSignal) || (type() == QmlMethod)); |
| } |
| virtual bool isInternal() const; |
| |
| void debug() const; |
| |
| private: |
| void setAssociatedProperty(PropertyNode* property); |
| |
| friend class InnerNode; |
| friend class PropertyNode; |
| |
| QString rt; |
| QStringList pp; |
| #ifdef Q_WS_WIN |
| Metaness met; |
| Virtualness vir; |
| #else |
| Metaness met : 4; |
| Virtualness vir : 2; |
| #endif |
| bool con : 1; |
| bool sta : 1; |
| bool ove : 1; |
| bool reimp: 1; |
| bool att: 1; |
| QList<Parameter> params; |
| const FunctionNode* rf; |
| const PropertyNode* ap; |
| QList<FunctionNode*> rb; |
| }; |
| |
| class PropertyNode : public LeafNode |
| { |
| public: |
| enum FunctionRole { Getter, Setter, Resetter, Notifier }; |
| enum { NumFunctionRoles = Notifier + 1 }; |
| |
| PropertyNode(InnerNode* parent, const QString& name); |
| virtual ~PropertyNode() { } |
| |
| void setDataType(const QString& dataType) { dt = dataType; } |
| void addFunction(FunctionNode* function, FunctionRole role); |
| void addSignal(FunctionNode* function, FunctionRole role); |
| void setStored(bool stored) { sto = toTrool(stored); } |
| void setDesignable(bool designable) { des = toTrool(designable); } |
| void setScriptable(bool scriptable) { scr = toTrool(scriptable); } |
| void setWritable(bool writable) { wri = toTrool(writable); } |
| void setUser(bool user) { usr = toTrool(user); } |
| void setOverriddenFrom(const PropertyNode* baseProperty); |
| void setRuntimeDesFunc(const QString& rdf) { runtimeDesFunc = rdf; } |
| void setRuntimeScrFunc(const QString& scrf) { runtimeScrFunc = scrf; } |
| void setConstant() { cst = true; } |
| void setFinal() { fnl = true; } |
| void setRevision(int revision) { rev = revision; } |
| |
| const QString &dataType() const { return dt; } |
| QString qualifiedDataType() const; |
| NodeList functions() const; |
| NodeList functions(FunctionRole role) const { return funcs[(int)role]; } |
| NodeList getters() const { return functions(Getter); } |
| NodeList setters() const { return functions(Setter); } |
| NodeList resetters() const { return functions(Resetter); } |
| NodeList notifiers() const { return functions(Notifier); } |
| bool isStored() const { return fromTrool(sto, storedDefault()); } |
| bool isDesignable() const { return fromTrool(des, designableDefault()); } |
| bool isScriptable() const { return fromTrool(scr, scriptableDefault()); } |
| const QString& runtimeDesignabilityFunction() const { return runtimeDesFunc; } |
| const QString& runtimeScriptabilityFunction() const { return runtimeScrFunc; } |
| bool isWritable() const { return fromTrool(wri, writableDefault()); } |
| bool isUser() const { return fromTrool(usr, userDefault()); } |
| bool isConstant() const { return cst; } |
| bool isFinal() const { return fnl; } |
| const PropertyNode* overriddenFrom() const { return overrides; } |
| |
| bool storedDefault() const { return true; } |
| bool userDefault() const { return false; } |
| bool designableDefault() const { return !setters().isEmpty(); } |
| bool scriptableDefault() const { return true; } |
| bool writableDefault() const { return !setters().isEmpty(); } |
| |
| private: |
| enum Trool { Trool_True, Trool_False, Trool_Default }; |
| |
| static Trool toTrool(bool boolean); |
| static bool fromTrool(Trool troolean, bool defaultValue); |
| |
| QString dt; |
| QString runtimeDesFunc; |
| QString runtimeScrFunc; |
| NodeList funcs[NumFunctionRoles]; |
| Trool sto; |
| Trool des; |
| Trool scr; |
| Trool wri; |
| Trool usr; |
| bool cst; |
| bool fnl; |
| int rev; |
| const PropertyNode* overrides; |
| }; |
| |
| inline void FunctionNode::setParameters(const QList<Parameter> ¶meters) |
| { |
| params = parameters; |
| } |
| |
| inline void PropertyNode::addFunction(FunctionNode* function, FunctionRole role) |
| { |
| funcs[(int)role].append(function); |
| function->setAssociatedProperty(this); |
| } |
| |
| inline void PropertyNode::addSignal(FunctionNode* function, FunctionRole role) |
| { |
| funcs[(int)role].append(function); |
| } |
| |
| inline NodeList PropertyNode::functions() const |
| { |
| NodeList list; |
| for (int i = 0; i < NumFunctionRoles; ++i) |
| list += funcs[i]; |
| return list; |
| } |
| |
| class VariableNode : public LeafNode |
| { |
| public: |
| VariableNode(InnerNode* parent, const QString &name); |
| virtual ~VariableNode() { } |
| |
| void setLeftType(const QString &leftType) { lt = leftType; } |
| void setRightType(const QString &rightType) { rt = rightType; } |
| void setStatic(bool statique) { sta = statique; } |
| |
| const QString &leftType() const { return lt; } |
| const QString &rightType() const { return rt; } |
| QString dataType() const { return lt + rt; } |
| bool isStatic() const { return sta; } |
| |
| private: |
| QString lt; |
| QString rt; |
| bool sta; |
| }; |
| |
| inline VariableNode::VariableNode(InnerNode* parent, const QString &name) |
| : LeafNode(Variable, parent, name), sta(false) |
| { |
| // nothing. |
| } |
| |
| class TargetNode : public LeafNode |
| { |
| public: |
| TargetNode(InnerNode* parent, const QString& name); |
| virtual ~TargetNode() { } |
| |
| virtual bool isInnerNode() const; |
| }; |
| |
| QT_END_NAMESPACE |
| |
| #endif |