QDoc: Clean up whitespace

Ensure that QDoc conforms to Qt style, whitespace edition.
For the most part, the change involves moving the pointer operators.
Also remove whitespace following an opening parenthesis, or
immediately preceding a closing one. In some cases, adjust the
following line accordingly in methods that span multiple lines.

Change-Id: I56ae125a2acf09c669c0a73dc814d05f13575f39
Reviewed-by: Martin Smith <martin.smith@qt.io>

1 files changed, 90 insertions, 90 deletions

diff --git a/src/qdoc/tree.h b/src/qdoc/tree.h
index 865ee2266..b5b01eaf8 100644
--- a/src/qdoc/tree.h
+++ b/src/qdoc/tree.h
@@ -47,10 +47,10 @@ struct TargetRec
   public:
     enum TargetType { Unknown, Target, Keyword, Contents, Class, Function, Page, Subtitle };
 
-    TargetRec(const QString& name,
-              const QString& title,
+    TargetRec(const QString &name,
+              const QString &title,
               TargetRec::TargetType type,
-              Node* node,
+              Node *node,
               int priority)
     : node_(node), ref_(name), title_(title), priority_(priority), type_(type) {
         // Discard the dedicated ref for keywords - they always
@@ -62,7 +62,7 @@ struct TargetRec
     bool isEmpty() const { return ref_.isEmpty(); }
     Node::Genus genus() { return (node_ ? node_->genus() : Node::DontCare); }
 
-    Node* node_;
+    Node *node_;
     QString ref_;
     QString title_;
     int priority_;
@@ -72,21 +72,21 @@ struct TargetRec
 struct TargetLoc
 {
   public:
-  TargetLoc(const Node* loc, const QString& t, const QString& fileName, const QString& text, bool broken)
+  TargetLoc(const Node *loc, const QString &t, const QString &fileName, const QString &text, bool broken)
   : loc_(loc), target_(t), fileName_(fileName), text_(text), broken_(broken) { }
-    const Node*   loc_;
+    const Node *loc_;
     QString target_;
     QString fileName_;
     QString text_;
-    bool    broken_;
+    bool broken_;
 };
 
-typedef QMultiMap<QString, TargetRec*> TargetMap;
-typedef QMultiMap<QString, PageNode*> PageNodeMultiMap;
-typedef QMap<QString, QmlTypeNode*> QmlTypeMap;
-typedef QMultiMap<QString, const ExampleNode*> ExampleNodeMap;
-typedef QVector<TargetLoc*> TargetList;
-typedef QMap<QString, TargetList*> TargetListMap;
+typedef QMultiMap<QString, TargetRec *> TargetMap;
+typedef QMultiMap<QString, PageNode *> PageNodeMultiMap;
+typedef QMap<QString, QmlTypeNode *> QmlTypeMap;
+typedef QMultiMap<QString, const ExampleNode *> ExampleNodeMap;
+typedef QVector<TargetLoc *> TargetList;
+typedef QMap<QString, TargetList *> TargetListMap;
 
 class Tree
 {
@@ -95,9 +95,9 @@ class Tree
 
  private: // Note the constructor and destructor are private.
     typedef QMap<PropertyNode::FunctionRole, QString> RoleMap;
-    typedef QMap<PropertyNode*, RoleMap> PropertyMap;
+    typedef QMap<PropertyNode *, RoleMap> PropertyMap;
 
-    Tree(const QString& camelCaseModuleName, QDocDatabase* qdb);
+    Tree(const QString &camelCaseModuleName, QDocDatabase *qdb);
     ~Tree();
 
  public: // Of necessity, a few public functions remain.
@@ -116,55 +116,55 @@ class Tree
 
  private: // The rest of the class is private.
     Aggregate *findAggregate(const QString &name);
-    Node* findNodeForInclude(const QStringList& path) const;
-    ClassNode* findClassNode(const QStringList& path, const Node* start = nullptr) const;
-    NamespaceNode* findNamespaceNode(const QStringList& path) const;
+    Node *findNodeForInclude(const QStringList &path) const;
+    ClassNode *findClassNode(const QStringList &path, const Node *start = nullptr) const;
+    NamespaceNode *findNamespaceNode(const QStringList &path) const;
     const FunctionNode *findFunctionNode(const QStringList &path,
                                          const Parameters &parameters,
                                          const Node *relative,
                                          Node::Genus genus) const;
-    Node* findNodeRecursive(const QStringList& path,
+    Node *findNodeRecursive(const QStringList &path,
                             int pathIndex,
-                            const Node* start,
+                            const Node *start,
                             bool (Node::*) () const) const;
 #if 0
-    Node* findNodeRecursive(const QStringList& path,
+    Node *findNodeRecursive(const QStringList &path,
                             int pathIndex,
-                            const Node* start,
+                            const Node *start,
                             Node::NodeType type) const;
 #endif
-    const Node* findNodeForTarget(const QStringList& path,
-                                  const QString& target,
-                                  const Node* node,
+    const Node *findNodeForTarget(const QStringList &path,
+                                  const QString &target,
+                                  const Node *node,
                                   int flags,
                                   Node::Genus genus,
-                                  QString& ref) const;
-    const Node* matchPathAndTarget(const QStringList& path,
+                                  QString &ref) const;
+    const Node *matchPathAndTarget(const QStringList &path,
                                    int idx,
-                                   const QString& target,
-                                   const Node* node,
+                                   const QString &target,
+                                   const Node *node,
                                    int flags,
                                    Node::Genus genus,
-                                   QString& ref) const;
+                                   QString &ref) const;
 
-    const Node* findNode(const QStringList &path,
+    const Node *findNode(const QStringList &path,
                          const Node *relative,
                          int flags,
                          Node::Genus genus) const;
 
-    QmlTypeNode* findQmlTypeNode(const QStringList& path);
+    QmlTypeNode *findQmlTypeNode(const QStringList &path);
 
-    Node* findNodeByNameAndType(const QStringList& path, bool (Node::*isMatch) () const) const;
-    Aggregate* findRelatesNode(const QStringList& path);
-    QString getRef(const QString& target, const Node* node) const;
-    void insertTarget(const QString& name,
-                      const QString& title,
+    Node *findNodeByNameAndType(const QStringList &path, bool (Node::*isMatch) () const) const;
+    Aggregate *findRelatesNode(const QStringList &path);
+    QString getRef(const QString &target, const Node *node) const;
+    void insertTarget(const QString &name,
+                      const QString &title,
                       TargetRec::TargetType type,
-                      Node* node,
+                      Node *node,
                       int priority);
-    void resolveTargets(Aggregate* root);
-    const Node* findUnambiguousTarget(const QString& target, Node::Genus genus, QString& ref) const;
-    const PageNode* findPageNodeByTitle(const QString& title) const;
+    void resolveTargets(Aggregate *root);
+    const Node *findUnambiguousTarget(const QString &target, Node::Genus genus, QString &ref) const;
+    const PageNode *findPageNodeByTitle(const QString &title) const;
 
     void addPropertyFunction(PropertyNode *property,
                              const QString &funcName,
@@ -180,49 +180,49 @@ class Tree
     const NamespaceNode *root() const { return &root_; }
 
     ClassList allBaseClasses(const ClassNode *classe) const;
-    QString refForAtom(const Atom* atom);
-
-    CNMap* getCollectionMap(Node::NodeType type);
-    const CNMap& groups() const { return groups_; }
-    const CNMap& modules() const { return modules_; }
-    const CNMap& qmlModules() const { return qmlModules_; }
-    const CNMap& jsModules() const { return jsModules_; }
-
-    CollectionNode* getCollection(const QString& name, Node::NodeType type);
-    CollectionNode* findCollection(const QString& name, Node::NodeType type);
-
-    CollectionNode* findGroup(const QString& name) { return findCollection(name, Node::Group); }
-    CollectionNode* findModule(const QString& name) { return findCollection(name, Node::Module); }
-    CollectionNode* findQmlModule(const QString& name) { return findCollection(name, Node::QmlModule); }
-    CollectionNode* findJsModule(const QString& name) { return findCollection(name, Node::JsModule); }
-
-    CollectionNode* addGroup(const QString& name) { return findGroup(name); }
-    CollectionNode* addModule(const QString& name) { return findModule(name); }
-    CollectionNode* addQmlModule(const QString& name) { return findQmlModule(name); }
-    CollectionNode* addJsModule(const QString& name) { return findJsModule(name); }
-
-    CollectionNode* addToGroup(const QString& name, Node* node);
-    CollectionNode* addToModule(const QString& name, Node* node);
-    CollectionNode* addToQmlModule(const QString& name, Node* node);
-    CollectionNode* addToJsModule(const QString& name, Node* node);
-
-    QmlTypeNode* lookupQmlType(const QString& name) const { return qmlTypeMap_.value(name); }
-    Aggregate* lookupQmlBasicType(const QString& name) const { return qmlTypeMap_.value(name); }
-    void insertQmlType(const QString& key, QmlTypeNode* n);
-    void addExampleNode(ExampleNode* n) { exampleNodeMap_.insert(n->title(), n); }
-    ExampleNodeMap& exampleNodeMap() { return exampleNodeMap_; }
-    void setIndexFileName(const QString& t) { indexFileName_ = t; }
+    QString refForAtom(const Atom *atom);
+
+    CNMap *getCollectionMap(Node::NodeType type);
+    const CNMap &groups() const { return groups_; }
+    const CNMap &modules() const { return modules_; }
+    const CNMap &qmlModules() const { return qmlModules_; }
+    const CNMap &jsModules() const { return jsModules_; }
+
+    CollectionNode *getCollection(const QString &name, Node::NodeType type);
+    CollectionNode *findCollection(const QString &name, Node::NodeType type);
+
+    CollectionNode *findGroup(const QString &name) { return findCollection(name, Node::Group); }
+    CollectionNode *findModule(const QString &name) { return findCollection(name, Node::Module); }
+    CollectionNode *findQmlModule(const QString &name) { return findCollection(name, Node::QmlModule); }
+    CollectionNode *findJsModule(const QString &name) { return findCollection(name, Node::JsModule); }
+
+    CollectionNode *addGroup(const QString &name) { return findGroup(name); }
+    CollectionNode *addModule(const QString &name) { return findModule(name); }
+    CollectionNode *addQmlModule(const QString &name) { return findQmlModule(name); }
+    CollectionNode *addJsModule(const QString &name) { return findJsModule(name); }
+
+    CollectionNode *addToGroup(const QString &name, Node *node);
+    CollectionNode *addToModule(const QString &name, Node *node);
+    CollectionNode *addToQmlModule(const QString &name, Node *node);
+    CollectionNode *addToJsModule(const QString &name, Node *node);
+
+    QmlTypeNode *lookupQmlType(const QString &name) const { return qmlTypeMap_.value(name); }
+    Aggregate *lookupQmlBasicType(const QString &name) const { return qmlTypeMap_.value(name); }
+    void insertQmlType(const QString &key, QmlTypeNode *n);
+    void addExampleNode(ExampleNode *n) { exampleNodeMap_.insert(n->title(), n); }
+    ExampleNodeMap &exampleNodeMap() { return exampleNodeMap_; }
+    void setIndexFileName(const QString &t) { indexFileName_ = t; }
 
     bool treeHasBeenAnalyzed() const { return treeHasBeenAnalyzed_; }
     bool docsHaveBeenGenerated() const { return docsHaveBeenGenerated_; }
     void setTreeHasBeenAnalyzed() { treeHasBeenAnalyzed_ = true; }
     void setdocsHaveBeenGenerated() { docsHaveBeenGenerated_ = true; }
-    QString getNewLinkTarget(const Node* locNode,
-                             const Node* t,
-                             const QString& fileName,
-                             QString& text,
+    QString getNewLinkTarget(const Node *locNode,
+                             const Node *t,
+                             const QString &fileName,
+                             QString &text,
                              bool broken);
-    TargetList* getTargetList(const QString& module);
+    TargetList* getTargetList(const QString &module);
     QStringList getTargetListKeys() { return targetListMap_->keys(); }
     FunctionNode *findFunctionNodeForTag(const QString &tag, Aggregate *parent = nullptr);
     FunctionNode *findMacroNode(const QString &t, const Aggregate *parent = nullptr);
@@ -235,21 +235,21 @@ private:
     QString physicalModuleName_;
     QString indexFileName_;
     QString indexTitle_;
-    QDocDatabase* qdb_;
+    QDocDatabase *qdb_;
     NamespaceNode root_;
     PropertyMap unresolvedPropertyMap;
-    PageNodeMultiMap        pageNodesByTitle_;
-    TargetMap               nodesByTargetRef_;
-    TargetMap               nodesByTargetTitle_;
-    CNMap                   groups_;
-    CNMap                   modules_;
-    CNMap                   qmlModules_;
-    CNMap                   jsModules_;
-    QmlTypeMap              qmlTypeMap_;
-    ExampleNodeMap          exampleNodeMap_;
-    TargetListMap*          targetListMap_;
+    PageNodeMultiMap pageNodesByTitle_;
+    TargetMap nodesByTargetRef_;
+    TargetMap nodesByTargetTitle_;
+    CNMap groups_;
+    CNMap modules_;
+    CNMap qmlModules_;
+    CNMap jsModules_;
+    QmlTypeMap qmlTypeMap_;
+    ExampleNodeMap exampleNodeMap_;
+    TargetListMap *targetListMap_;
     NodeList proxies_;
-    NodeMap                 dontDocumentMap_;
+    NodeMap dontDocumentMap_;
 };
 
 QT_END_NAMESPACE