diff options
Diffstat (limited to 'src/tools/qdoc/qdocdatabase.h')
| -rw-r--r-- | src/tools/qdoc/qdocdatabase.h | 370 |
1 files changed, 269 insertions, 101 deletions
diff --git a/src/tools/qdoc/qdocdatabase.h b/src/tools/qdoc/qdocdatabase.h index 4decba5f79..7bbff89fa3 100644 --- a/src/tools/qdoc/qdocdatabase.h +++ b/src/tools/qdoc/qdocdatabase.h @@ -45,19 +45,20 @@ #include <qstring.h> #include <qmap.h> #include "tree.h" +#include "config.h" +#include <qdebug.h> QT_BEGIN_NAMESPACE -typedef QMap<QString, DocNode*> DocNodeMap; -typedef QMap<QString, QmlClassNode*> QmlTypeMap; typedef QMap<QString, NodeMap> NodeMapMap; typedef QMap<QString, NodeMultiMap> NodeMultiMapMap; typedef QMultiMap<QString, Node*> QDocMultiMap; typedef QMap<Text, const Node*> TextToNodeMap; -typedef QMultiMap<QString, DocNode*> DocNodeMultiMap; +typedef QList<CollectionNode*> CollectionList; class Atom; class Generator; +class QDocDatabase; enum FindFlag { SearchBaseClasses = 0x1, @@ -65,20 +66,159 @@ enum FindFlag { NonFunction = 0x4 }; -struct TargetRec +class QDocForest { public: - enum Type { Unknown, Target, Keyword, Contents, Class, Function, Page, Subtitle }; - TargetRec() : node_(0), priority_(INT_MAX), type_(Unknown) { } - bool isEmpty() const { return ref_.isEmpty(); } - //void debug(int idx, const QString& key); - Node* node_; - QString ref_; - int priority_; - Type type_; -}; -typedef QMultiMap<QString, TargetRec> TargetRecMultiMap; + friend class QDocDatabase; + QDocForest(QDocDatabase* qdb) + : qdb_(qdb), primaryTree_(0), currentIndex_(0) { } + ~QDocForest(); + + NamespaceNode* firstRoot(); + NamespaceNode* nextRoot(); + Tree* firstTree(); + Tree* nextTree(); + Tree* primaryTree() { return primaryTree_; } + NamespaceNode* primaryTreeRoot() { return (primaryTree_ ? primaryTree_->root() : 0); } + bool isEmpty() { return searchOrder().isEmpty(); } + bool done() { return (currentIndex_ >= searchOrder().size()); } + const QVector<Tree*>& searchOrder(); + const QVector<Tree*>& indexSearchOrder(); + void setSearchOrder(); + + const Node* findNode(const QStringList& path, const Node* relative, int findFlags) { + foreach (Tree* t, searchOrder()) { + const Node* n = t->findNode(path, relative, findFlags); + if (n) + return n; + relative = 0; + } + //qDebug() << "FAILED SEARCH 1" << path; + return 0; + } + + Node* findNodeByNameAndType(const QStringList& path, + Node::Type type, + Node::SubType subtype, + bool acceptCollision = false) { + foreach (Tree* t, searchOrder()) { + Node* n = t->findNodeByNameAndType(path, type, subtype, acceptCollision); + if (n) + return n; + } + //qDebug() << "FAILED SEARCH 2" << path << type << subtype; + return 0; + } + ClassNode* findClassNode(const QStringList& path) { + foreach (Tree* t, searchOrder()) { + ClassNode* n = t->findClassNode(path); + if (n) + return n; + } + //qDebug() << "FAILED SEARCH 3" << path; + return 0; + } + + InnerNode* findRelatesNode(const QStringList& path) { + foreach (Tree* t, searchOrder()) { + InnerNode* n = t->findRelatesNode(path); + if (n) + return n; + } + //qDebug() << "FAILED SEARCH 4" << path; + return 0; + } + + const Node* resolveFunctionTarget(const QString& target, const Node* relative) { + foreach (Tree* t, searchOrder()) { + const Node* n = t->resolveFunctionTarget(target, relative); + if (n) + return n; + relative = 0; + } + return 0; + } + const Node* resolveTarget(const QString& target, const Node* relative); + + const Node* resolveType(const QStringList& path, const Node* relative) + { + foreach (Tree* t, searchOrder()) { + const Node* n = resolveTypeHelper(path, relative, t); + if (n) + return n; + relative = 0; + } + //qDebug() << "FAILED SEARCH 5" << path; + return 0; + } + + QString findTarget(const QString& target, const Node* node) + { + foreach (Tree* t, searchOrder()) { + QString ref = t->findTarget(target, node); + if (!ref.isEmpty()) + return ref; + } + //qDebug() << "FAILED SEARCH 7" << target; + return QString(); + } + + const Node* findUnambiguousTarget(const QString& target, QString& ref) + { + foreach (Tree* t, searchOrder()) { + const Node* n = t->findUnambiguousTarget(target, ref); + if (n) + return n; + } + //qDebug() << "FAILED SEARCH 8" << target; + return 0; + } + + const DocNode* findDocNodeByTitle(const QString& title) + { + foreach (Tree* t, searchOrder()) { + const DocNode* n = t->findDocNodeByTitle(title); + if (n) + return n; + } + //qDebug() << "FAILED SEARCH 9" << title; + return 0; + } + + QmlClassNode* lookupQmlType(const QString& name) + { + foreach (Tree* t, searchOrder()) { + QmlClassNode* qcn = t->lookupQmlType(name); + if (qcn) + return qcn; + } + return 0; + } + void mergeCollectionMaps(Node::Type nt, CNMultiMap& cnmm); + void getCorrespondingCollections(CollectionNode* cn, CollectionList& cl) + { + foreach (Tree* t, searchOrder()) { + CollectionNode* ccn = t->getCorrespondingCollection(cn); + if (ccn) + cl.append(ccn); + } + } + + private: + void newPrimaryTree(const QString& module); + NamespaceNode* newIndexTree(const QString& module); + const Node* resolveTypeHelper(const QStringList& path, const Node* relative, Tree* t); + + private: + QDocDatabase* qdb_; + Tree* primaryTree_; + int currentIndex_; + QMap<QString, Tree*> forest_; + QVector<Tree*> searchOrder_; + QVector<Tree*> indexSearchOrder_; + QVector<QString> moduleNames_; +}; class QDocDatabase { @@ -89,100 +229,124 @@ class QDocDatabase static void destroyQdocDB(); ~QDocDatabase(); - const DocNodeMap& groups() const { return groups_; } - const DocNodeMap& modules() const { return modules_; } - const DocNodeMap& qmlModules() const { return qmlModules_; } + const CNMap& groups() { return primaryTree()->groups(); } + const CNMap& modules() { return primaryTree()->modules(); } + const CNMap& qmlModules() { return primaryTree()->qmlModules(); } - DocNode* getGroup(const QString& name); - DocNode* findGroup(const QString& name); - DocNode* findModule(const QString& name); - QmlModuleNode* findQmlModule(const QString& name); + GroupNode* getGroup(const QString& name) { return primaryTree()->getGroup(name); } + GroupNode* findGroup(const QString& name) { return primaryTree()->findGroup(name); } + ModuleNode* findModule(const QString& name) { return primaryTree()->findModule(name); } + QmlModuleNode* findQmlModule(const QString& name) { return primaryTree()->findQmlModule(name); } - DocNode* addGroup(const QString& name); - DocNode* addModule(const QString& name); - QmlModuleNode* addQmlModule(const QString& name); + GroupNode* addGroup(const QString& name) { return primaryTree()->addGroup(name); } + ModuleNode* addModule(const QString& name) { return primaryTree()->addModule(name); } + QmlModuleNode* addQmlModule(const QString& name) { return primaryTree()->addQmlModule(name); } - DocNode* addToGroup(const QString& name, Node* node); - DocNode* addToModule(const QString& name, Node* node); - void addToQmlModule(const QString& name, Node* node); - - QmlClassNode* findQmlType(const QString& qmid, const QString& name) const; - QmlClassNode* findQmlType(const ImportRec& import, const QString& name) const; + GroupNode* addToGroup(const QString& name, Node* node) { + return primaryTree()->addToGroup(name, node); + } + ModuleNode* addToModule(const QString& name, Node* node) { + return primaryTree()->addToModule(name, node); + } + QmlModuleNode* addToQmlModule(const QString& name, Node* node) { + return primaryTree()->addToQmlModule(name, node); + } + void addExampleNode(ExampleNode* n) { primaryTree()->addExampleNode(n); } + ExampleNodeMap& exampleNodeMap() { return primaryTree()->exampleNodeMap(); } - void findAllClasses(const InnerNode *node); - void findAllFunctions(const InnerNode *node); - void findAllLegaleseTexts(const InnerNode *node); - void findAllNamespaces(const InnerNode *node); - void findAllObsoleteThings(const InnerNode* node); - void findAllSince(const InnerNode *node); - void buildCollections(); + QmlClassNode* findQmlType(const QString& name); + QmlClassNode* findQmlType(const QString& qmid, const QString& name); + QmlClassNode* findQmlType(const ImportRec& import, const QString& name); + private: + void findAllClasses(InnerNode *node); + void findAllFunctions(InnerNode *node); + void findAllLegaleseTexts(InnerNode *node); + void findAllNamespaces(InnerNode *node); + void findAllObsoleteThings(InnerNode* node); + void findAllSince(InnerNode *node); + + public: // special collection access functions - NodeMap& getCppClasses() { return nonCompatClasses_; } - NodeMap& getMainClasses() { return mainClasses_; } - NodeMap& getCompatibilityClasses() { return compatClasses_; } - NodeMap& getObsoleteClasses() { return obsoleteClasses_; } - NodeMap& getClassesWithObsoleteMembers() { return classesWithObsoleteMembers_; } - NodeMap& getObsoleteQmlTypes() { return obsoleteQmlTypes_; } - NodeMap& getQmlTypesWithObsoleteMembers() { return qmlTypesWithObsoleteMembers_; } - NodeMap& getNamespaces() { return namespaceIndex_; } - NodeMap& getServiceClasses() { return serviceClasses_; } - NodeMap& getQmlTypes() { return qmlClasses_; } - NodeMapMap& getFunctionIndex() { return funcIndex_; } - TextToNodeMap& getLegaleseTexts() { return legaleseTexts_; } - const NodeMap& getClassMap(const QString& key) const; - const NodeMap& getQmlTypeMap(const QString& key) const; - const NodeMultiMap& getSinceMap(const QString& key) const; - - const Node* resolveTarget(const QString& target, const Node* relative, const Node* self=0); - const Node* findNodeForTarget(const QString& target, const Node* relative); - void insertTarget(const QString& name, TargetRec::Type type, Node* node, int priority); + NodeMap& getCppClasses(); + NodeMap& getMainClasses(); + NodeMap& getCompatibilityClasses(); + NodeMap& getObsoleteClasses(); + NodeMap& getClassesWithObsoleteMembers(); + NodeMap& getObsoleteQmlTypes(); + NodeMap& getQmlTypesWithObsoleteMembers(); + NodeMap& getNamespaces(); + NodeMap& getServiceClasses(); + NodeMap& getQmlTypes(); + NodeMapMap& getFunctionIndex(); + TextToNodeMap& getLegaleseTexts(); + const NodeMap& getClassMap(const QString& key); + const NodeMap& getQmlTypeMap(const QString& key); + const NodeMultiMap& getSinceMap(const QString& key); /* convenience functions Many of these will be either eliminated or replaced. */ - QString refForAtom(const Atom* atom); - Tree* tree() { return tree_; } - NamespaceNode* treeRoot() { return tree_->root(); } - void resolveInheritance() { tree_->resolveInheritance(); } + void resolveInheritance() { primaryTree()->resolveInheritance(); } void resolveQmlInheritance(InnerNode* root); void resolveIssues(); - void fixInheritance() { tree_->fixInheritance(); } - void resolveProperties() { tree_->resolveProperties(); } + void fixInheritance() { primaryTree()->fixInheritance(); } + void resolveProperties() { primaryTree()->resolveProperties(); } - const Node* findNode(const QStringList& path) { return tree_->findNode(path); } - ClassNode* findClassNode(const QStringList& path) { return tree_->findClassNode(path); } - NamespaceNode* findNamespaceNode(const QStringList& path) { return tree_->findNamespaceNode(path); } - - NameCollisionNode* findCollisionNode(const QString& name) const { - return tree_->findCollisionNode(name); + void resolveTargets() { + primaryTree()->resolveTargets(primaryTreeRoot()); + } + void insertTarget(const QString& name, TargetRec::Type type, Node* node, int priority) { + primaryTree()->insertTarget(name, type, node, priority); } - const DocNode* findDocNodeByTitle(const QString& title, const Node* relative = 0) const; - const Node *findUnambiguousTarget(const QString &target, QString& ref, const Node* relative); - QString findTarget(const QString &target, const Node *node) const; - void resolveTargets(InnerNode* root); - + /******************************************************************* + The functions declared below are called for the current tree only. + ********************************************************************/ FunctionNode* findFunctionNode(const QStringList& parentPath, const FunctionNode* clone) { - return tree_->findFunctionNode(parentPath, clone); + return primaryTree()->findFunctionNode(parentPath, clone); } - Node* findNodeByNameAndType(const QStringList& path, Node::Type type, Node::SubType subtype){ - return tree_->findNodeByNameAndType(path, type, subtype, 0); + FunctionNode* findNodeInOpenNamespace(const QStringList& parentPath, const FunctionNode* clone); + Node* findNodeInOpenNamespace(QStringList& path, Node::Type type, Node::SubType subtype); + NameCollisionNode* findCollisionNode(const QString& name) { + return primaryTree()->findCollisionNode(name); } - NameCollisionNode* checkForCollision(const QString& name) const { - return tree_->checkForCollision(name); + NameCollisionNode* checkForCollision(const QString& name) { + return primaryTree()->checkForCollision(name); } - void addBaseClass(ClassNode* subclass, - Node::Access access, - const QStringList& basePath, - const QString& dataTypeWithTemplateArgs, - InnerNode* parent) { - tree_->addBaseClass(subclass, access, basePath, dataTypeWithTemplateArgs, parent); + /*******************************************************************/ + + /******************************************************************* + The functions declared below are called for all trees. + ********************************************************************/ + ClassNode* findClassNode(const QStringList& path) { return forest_.findClassNode(path); } + InnerNode* findRelatesNode(const QStringList& path) { return forest_.findRelatesNode(path); } + QString findTarget(const QString& target, const Node* node) { + return forest_.findTarget(target, node); } + const Node* resolveTarget(const QString& target, const Node* relative) { + return forest_.resolveTarget(target, relative); + } + const Node* resolveFunctionTarget(const QString& target, const Node* relative) { + return forest_.resolveFunctionTarget(target, relative); + } + const Node* resolveType(const QString& type, const Node* relative); + const Node* findNodeForTarget(const QString& target, const Node* relative); + const DocNode* findDocNodeByTitle(const QString& title) { + return forest_.findDocNodeByTitle(title); + } + const Node* findUnambiguousTarget(const QString& target, QString& ref) { + return forest_.findUnambiguousTarget(target, ref); + } + Node* findNodeByNameAndType(const QStringList& path, Node::Type type, Node::SubType subtype){ + return forest_.findNodeByNameAndType(path, type, subtype, false); + } + /*******************************************************************/ + void addPropertyFunction(PropertyNode* property, const QString& funcName, PropertyNode::FunctionRole funcRole) { - tree_->addPropertyFunction(property, funcName, funcRole); + primaryTree()->addPropertyFunction(property, funcName, funcRole); } void setVersion(const QString& v) { version_ = v; } @@ -198,37 +362,43 @@ class QDocDatabase void clearOpenNamespaces() { openNamespaces_.clear(); } void insertOpenNamespace(const QString& path) { openNamespaces_.insert(path); } - FunctionNode* findNodeInOpenNamespace(const QStringList& parentPath, const FunctionNode* clone); - Node* findNodeInOpenNamespace(QStringList& path, Node::Type type, Node::SubType subtype); void setShowInternal(bool value) { showInternal_ = value; } - /* debugging functions */ - void printModules() const; - void printQmlModules() const; + // Try to make this function private. + QDocForest& forest() { return forest_; } + NamespaceNode* primaryTreeRoot() { return forest_.primaryTreeRoot(); } + void newPrimaryTree(const QString& module) { forest_.newPrimaryTree(module); } + NamespaceNode* newIndexTree(const QString& module) { return forest_.newIndexTree(module); } + const QVector<Tree*>& searchOrder() { return forest_.searchOrder(); } + void setSearchOrder() { forest_.setSearchOrder(); } + void mergeCollections(Node::Type nt, CNMap& cnm, const Node* relative); + void mergeCollections(CollectionNode* cn); private: friend class QDocIndexFiles; friend class QDocTagFiles; const Node* findNode(const QStringList& path, const Node* relative, int findFlags) { - return tree_->findNode(path, relative, findFlags); + return forest_.findNode(path, relative, findFlags); } + void processForest(void (QDocDatabase::*) (InnerNode*)); + static void initializeDB(); private: QDocDatabase(); - QDocDatabase(QDocDatabase const& ) { }; // copy constructor is private - QDocDatabase& operator=(QDocDatabase const& ); // assignment operator is private + QDocDatabase(QDocDatabase const& ) : showInternal_(false), forest_(this) { } + QDocDatabase& operator=(QDocDatabase const& ); + Tree* primaryTree() { return forest_.primaryTree(); } + + public: + static bool debug; private: static QDocDatabase* qdocDB_; + static NodeMap typeNodeMap_; bool showInternal_; QString version_; - QDocMultiMap masterMap_; - Tree* tree_; - DocNodeMap groups_; - DocNodeMap modules_; - DocNodeMap qmlModules_; - QmlTypeMap qmlTypeMap_; + QDocForest forest_; NodeMap nonCompatClasses_; NodeMap mainClasses_; @@ -245,8 +415,6 @@ class QDocDatabase NodeMultiMapMap newSinceMaps_; NodeMapMap funcIndex_; TextToNodeMap legaleseTexts_; - DocNodeMultiMap docNodesByTitle_; - TargetRecMultiMap targetRecMultiMap_; QSet<QString> openNamespaces_; }; |