Changeset 846 for trunk/tools/qdoc3/node.h

Timestamp:

May 5, 2011, 5:36:53 AM (14 years ago)

Author:

Dmitry A. Kuminov

Message:

trunk: Merged in qt 4.7.2 sources from branches/vendor/nokia/qt.

Location:

trunk

Files:

• . (modified) (1 prop)
• tools/qdoc3/node.h (modified) (39 diffs)

trunk/tools/qdoc3/node.h

@@ -1 +1 @@
 /****************************************************************************
 **
-** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+** Copyright (C) 201 Nokia Corporation and/or its subsidiary(-ies).
 ** All rights reserved.
 ** Contact: Nokia Corporation ([email protected])
@@ -56 +56 @@
 #include "location.h"
 #include "text.h"
+
 
 QT_BEGIN_NAMESPACE
@@ -97 +98 @@
         ExternalPage,
         QmlClass,
-        QmlPropertyGroup
+        QmlPropertyGroup,
+        QmlBasicType
 #else
         ExternalPage
@@ -137 +139 @@
     };
 
+
+
+
+
+
+
+
     virtual ~Node();
 
@@ -145 +154 @@
     void setThreadSafeness(ThreadSafeness safeness) { saf = safeness; }
     void setSince(const QString &since) { sinc = since; }
-    void setRelates(InnerNode *pseudoParent);
+    void setRelates(InnerNodepseudoParent);
     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; }
+
+
 
     virtual bool isInnerNode() const = 0;
     virtual bool isReimp() const { return false; }
     virtual bool isFunction() const { return false; }
+
     Type type() const { return typ; }
     virtual SubType subType() const { return NoSubType; }
-    InnerNode *parent() const { return par; }
-    InnerNode *relates() const { return rel; }
+    InnerNodeparent() const { return par; }
+    InnerNoderelates() const { return rel; }
     const QString& name() const { return nam; }
     QMap<LinkType, QPair<QString,QString> > links() const { return linkMap; }
@@ -165 +177 @@
 
     Access access() const { return acc; }
+
     const Location& location() const { return loc; }
     const Doc& doc() const { return d; }
@@ -173 +186 @@
     QString since() const { return sinc; }
     QString templateStuff() const { return tpl; }
+
+
 
     void clearRelated() { rel = 0; }
 
     virtual QString fileBase() const;
+
+
+
 
  protected:
-    Node(Type type, InnerNode *parent, const QString& name);
+    Node(Type type, InnerNodeparent, const QString& name);
 
  private:
@@ -186 +204 @@
     Type typ;
     Access acc;
+
+
     Status sta;
-    ThreadSafeness saf;
 #else
     Type typ : 4;
     Access acc : 2;
+
+
     Status sta : 3;
-    ThreadSafeness saf : 2;
 #endif
-    InnerNode *par;
-    InnerNode *rel;
+    InnerNodepar;
+    InnerNoderel;
     QString nam;
     Location loc;
@@ -204 +224 @@
     QString sinc;
     QString tpl;
+
 };
 
@@ -209 +230 @@
 class EnumNode;
 
-typedef QList<Node *> NodeList;
+typedef QList<Node*> NodeList;
 
 class InnerNode : public Node
@@ -216 +237 @@
     virtual ~InnerNode();
 
-    Node *findNode(const QString& name);
-    Node *findNode(const QString& name, Type type);
-    FunctionNode *findFunctionNode(const QString& name);
-    FunctionNode *findFunctionNode(const FunctionNode *clone);
+    NodefindNode(const QString& name);
+    NodefindNode(const QString& name, Type type);
+    FunctionNodefindFunctionNode(const QString& name);
+    FunctionNodeclone);
     void addInclude(const QString &include);
     void setIncludes(const QStringList &includes);
-    void setOverload(const FunctionNode *func, bool overlode);
+    void setOverload(const FunctionNodefunc, bool overlode);
     void normalizeOverloads();
     void makeUndocumentedChildrenInternal();
@@ -229 +250 @@
 
     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 NodefindNode(const QString& name) const;
+    const NodefindNode(const QString& name, Type type) const;
+    const FunctionNodefindFunctionNode(const QString& name) const;
+    const FunctionNodeclone) const;
+    const EnumNodefindEnumNodeForValue(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 overloadNumber(const FunctionNodefunc) const;
     int numOverloads(const QString& funcName) const;
     NodeList overloads(const QString &funcName) const;
@@ -244 +265 @@
     QStringList primaryKeys();
     QStringList secondaryKeys();
+
+
+
+
 
  protected:
-    InnerNode(Type type, InnerNode *parent, const QString& name);
+    InnerNode(Type type, InnerNodeparent, 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);
-
+    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, Node*> childMap;
+    QMap<QString, Node*> primaryFunctionMap;
     QMap<QString, NodeList> secondaryFunctionMap;
 };
@@ -280 +306 @@
 {
  public:
-    NamespaceNode(InnerNode *parent, const QString& name);
+    NamespaceNode(InnerNodeparent, const QString& name);
     virtual ~NamespaceNode() { }
 };
@@ -295 +321 @@
         node(node0),
         dataTypeWithTemplateArgs(dataTypeWithTemplateArgs0) { }
+
 
     Node::Access        access;
@@ -301 +328 @@
 };
 
+
+
 class ClassNode : public InnerNode
 {
  public:
-    ClassNode(InnerNode *parent, const QString& name);
+    ClassNode(InnerNodeparent, const QString& name);
     virtual ~ClassNode() { }
 
     void addBaseClass(Access access, 
-                      ClassNode *node, 
+                      ClassNodenode, 
                       const QString &dataTypeWithTemplateArgs = "");
     void fixBaseClasses();
 
-    const QList<RelatedClass> &baseClasses() const { return bas; }
-    const QList<RelatedClass> &derivedClasses() const { return der; }
+    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; }
@@ -322 +352 @@
     QString qmlElement() const { return qmlelement; }
     void setQmlElement(const QString& value) { qmlelement = value; }
-
- private:
-    QList<RelatedClass> bas;
-    QList<RelatedClass> der;
+    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;
+
     QString sname;
     QString qmlelement;
@@ -335 +370 @@
  public:
 
-    FakeNode(InnerNode *parent, const QString& name, SubType subType);
+    FakeNode(InnerNodeparent, 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); }
+    void addGroupMember(Nodenode) { gr.append(node); }
 
     SubType subType() const { return sub; }
-    QString title() const { return tle; }
-    QString fullTitle() const;
-    QString subTitle() const;
+    
+    QString fullTitle() const;
+    QString subTitle() const;
     const NodeList &groupMembers() const { return gr; }
     virtual QString nameForLists() const { return title(); }
@@ -360 +395 @@
 {
  public:
-    QmlClassNode(InnerNode *parent, 
+    QmlClassNode(InnerNodeparent, 
                  const QString& name, 
                  const ClassNode* cn);
-    virtual ~QmlClassNode() { }
+    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;
-
- private:
-    const ClassNode* cnode;
+    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; }
 };
 
@@ -381 +431 @@
                      bool attached);
     virtual ~QmlPropGroupNode() { }
+
 
     const QString& element() const { return parent()->name(); }
@@ -391 +442 @@
     bool    att;
 };
+
+
 
 class QmlPropertyNode : public LeafNode
@@ -410 +463 @@
     bool isStored() const { return fromTrool(sto,true); }
     bool isDesignable() const { return fromTrool(des,false); }
-    bool isWritable() const { return fromTrool(wri,true); }
+    bool isWritable(
     bool isAttached() const { return att; }
+
 
     const QString& element() const { return static_cast<QmlPropGroupNode*>(parent())->element(); }
@@ -453 +507 @@
 {
  public:
-    EnumNode(InnerNode *parent, const QString& name);
+    EnumNode(InnerNodeparent, const QString& name);
     virtual ~EnumNode() { }
 
     void addItem(const EnumItem& item);
-    void setFlagsType(TypedefNode *typedeff);
+    void setFlagsType(TypedefNodetypedeff);
     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; }
+    const TypedefNodeflagsType() const { return ft; }
     QString itemValue(const QString &name) const;
 
@@ -468 +522 @@
     QList<EnumItem> itms;
     QSet<QString> names;
-    const TypedefNode *ft;
+    const TypedefNodeft;
 };
 
@@ -474 +528 @@
 {
  public:
-    TypedefNode(InnerNode *parent, const QString& name);
+    TypedefNode(InnerNodeparent, const QString& name);
     virtual ~TypedefNode() { }
 
-    const EnumNode *associatedEnum() const { return ae; }
-
- private:
-    void setAssociatedEnum(const EnumNode *enume);
+    const EnumNodeassociatedEnum() const { return ae; }
+
+ private:
+    void setAssociatedEnum(const EnumNodeenume);
 
     friend class EnumNode;
 
-    const EnumNode *ae;
-};
-
-inline void EnumNode::setFlagsType(TypedefNode *typedeff)
+    const EnumNodeae;
+};
+
+inline void EnumNode::setFlagsType(TypedefNodetypedeff)
 {
     ft = typedeff;
@@ -539 +593 @@
     enum Virtualness { NonVirtual, ImpureVirtual, PureVirtual };
 
-    FunctionNode(InnerNode *parent, const QString &name);
-    FunctionNode(Type type, InnerNode *parent, const QString &name, bool attached);
+    FunctionNode(InnerNodeparent, const QString &name);
+    FunctionNode(Type type, InnerNodeparent, const QString &name, bool attached);
     virtual ~FunctionNode() { }
 
@@ -546 +600 @@
     void setParentPath(const QStringList& parentPath) { pp = parentPath; }
     void setMetaness(Metaness metaness) { met = metaness; }
-    void setVirtualness(Virtualness virtualness) { vir = virtualness; }
+    void setVirtualness(Virtualness virtualness)
     void setConst(bool conste) { con = conste; }
     void setStatic(bool statique) { sta = statique; }
@@ -553 +607 @@
     void addParameter(const Parameter& parameter);
     inline void setParameters(const QList<Parameter>& parameters);
-    void borrowParameterNames(const FunctionNode *source);
-    void setReimplementedFrom(FunctionNode *from);
+    void borrowParameterNames(const FunctionNodesource);
+    void setReimplementedFrom(FunctionNodefrom);
 
     const QString& returnType() const { return rt; }
@@ -571 +625 @@
     const QList<Parameter>& parameters() const { return params; }
     QStringList parameterNames() const;
-    const FunctionNode *reimplementedFrom() const { return rf; }
-    const QList<FunctionNode *> &reimplementedBy() const { return rb; }
-    const PropertyNode *associatedProperty() const { return ap; }
+    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; }
 
@@ -580 +635 @@
     const QString& element() const { return parent()->name(); }
     bool isAttached() const { return att; }
+
+
+
 
     void debug() const;
 
  private:
-    void setAssociatedProperty(PropertyNode *property);
+    void setAssociatedProperty(PropertyNodeproperty);
 
     friend class InnerNode;
@@ -604 +662 @@
     bool att: 1;
     QList<Parameter> params;
-    const FunctionNode *rf;
-    const PropertyNode *ap;
-    QList<FunctionNode *> rb;
+    const FunctionNoderf;
+    const PropertyNodeap;
+    QList<FunctionNode*> rb;
 };
 
@@ -615 +673 @@
     enum { NumFunctionRoles = Notifier + 1 };
 
-    PropertyNode(InnerNode *parent, const QString& name);
+    PropertyNode(InnerNodeparent, 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 addFunction(FunctionNodefunction, FunctionRole role);
+    void addSignal(FunctionNodefunction, FunctionRole role);
     void setStored(bool stored) { sto = toTrool(stored); }
     void setDesignable(bool designable) { des = toTrool(designable); }
+
     void setWritable(bool writable) { wri = toTrool(writable); }
-    void setOverriddenFrom(const PropertyNode *baseProperty);
+    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; }
 
     const QString &dataType() const { return dt; }
@@ -636 +700 @@
     bool isStored() const { return fromTrool(sto, storedDefault()); }
     bool isDesignable() const { return fromTrool(des, designableDefault()); }
+
+
+
     bool isWritable() const { return fromTrool(wri, writableDefault()); }
-    const PropertyNode *overriddenFrom() const { return overrides; }
+    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:
@@ -645 +721 @@
     static bool fromTrool(Trool troolean, bool defaultValue);
 
-    bool storedDefault() const { return true; }
-    bool designableDefault() const { return !setters().isEmpty(); }
-    bool writableDefault() const { return !setters().isEmpty(); }
-
     QString dt;
+
+
     NodeList funcs[NumFunctionRoles];
     Trool sto;
     Trool des;
+
     Trool wri;
-    const PropertyNode *overrides;
+    Trool usr;
+    bool cst;
+    bool fnl;
+    const PropertyNode* overrides;
 };
 
@@ -662 +740 @@
 }
 
-inline void PropertyNode::addFunction(FunctionNode *function, FunctionRole role)
+inline void PropertyNode::addFunction(FunctionNodefunction, FunctionRole role)
 {
     funcs[(int)role].append(function);
@@ -668 +746 @@
 }
 
-inline void PropertyNode::addSignal(FunctionNode *function, FunctionRole role)
+inline void PropertyNode::addSignal(FunctionNodefunction, FunctionRole role)
 {
     funcs[(int)role].append(function);
@@ -684 +762 @@
 {
  public:
-    VariableNode(InnerNode *parent, const QString &name);
+    VariableNode(InnerNodeparent, const QString &name);
     virtual ~VariableNode() { }
 
@@ -702 +780 @@
 };
 
-inline VariableNode::VariableNode(InnerNode *parent, const QString &name)
+inline VariableNode::VariableNode(InnerNodeparent, const QString &name)
     : LeafNode(Variable, parent, name), sta(false)
 {
+
 }
 
@@ -710 +789 @@
 {
  public:
-    TargetNode(InnerNode *parent, const QString& name);
+    TargetNode(InnerNodeparent, const QString& name);
     virtual ~TargetNode() { }