diff options
Diffstat (limited to 'src/tools/qdoc/qdocdatabase.h')
-rw-r--r-- | src/tools/qdoc/qdocdatabase.h | 398 |
1 files changed, 286 insertions, 112 deletions
diff --git a/src/tools/qdoc/qdocdatabase.h b/src/tools/qdoc/qdocdatabase.h index 4decba5f79..a53adc86fc 100644 --- a/src/tools/qdoc/qdocdatabase.h +++ b/src/tools/qdoc/qdocdatabase.h @@ -45,19 +45,21 @@ #include <qstring.h> #include <qmap.h> #include "tree.h" +#include "config.h" +#include "text.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 +67,146 @@ 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_; } + Tree* findTree(const QString& t) { return forest_.value(t); } + 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, + Node::Genus genus) { + foreach (Tree* t, searchOrder()) { + const Node* n = t->findNode(path, relative, findFlags, genus); + if (n) + return n; + relative = 0; + } + return 0; + } + + Node* findNodeByNameAndType(const QStringList& path, Node::Type type) { + foreach (Tree* t, searchOrder()) { + Node* n = t->findNodeByNameAndType(path, type); + if (n) + return n; + } + return 0; + } + ClassNode* findClassNode(const QStringList& path) { + foreach (Tree* t, searchOrder()) { + ClassNode* n = t->findClassNode(path); + if (n) + return n; + } + return 0; + } + + Node* findNodeForInclude(const QStringList& path) { + foreach (Tree* t, searchOrder()) { + Node* n = t->findNodeForInclude(path); + if (n) + return n; + } + return 0; + } + + InnerNode* findRelatesNode(const QStringList& path) { + foreach (Tree* t, searchOrder()) { + InnerNode* n = t->findRelatesNode(path); + if (n) + return n; + } + return 0; + } + + const Node* findFunctionNode(const QString& target, + const Node* relative, + Node::Genus genus) { + foreach (Tree* t, searchOrder()) { + const Node* n = t->findFunctionNode(target, relative, genus); + if (n) + return n; + relative = 0; + } + return 0; + } + const Node* findNodeForTarget(QStringList& targetPath, + const Node* relative, + Node::Genus genus, + QString& ref); + + const Node* findTypeNode(const QStringList& path, const Node* relative) + { + foreach (Tree* t, searchOrder()) { + int flags = SearchBaseClasses | SearchEnumValues | NonFunction; + const Node* n = t->findNode(path, relative, flags, Node::DontCare); + if (n) + return n; + relative = 0; + } + return 0; + } + + const DocNode* findDocNodeByTitle(const QString& title) + { + foreach (Tree* t, searchOrder()) { + const DocNode* n = t->findDocNodeByTitle(title); + if (n) + return n; + } + 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); + + private: + QDocDatabase* qdb_; + Tree* primaryTree_; + int currentIndex_; + QMap<QString, Tree*> forest_; + QVector<Tree*> searchOrder_; + QVector<Tree*> indexSearchOrder_; + QVector<QString> moduleNames_; +}; class QDocDatabase { @@ -89,100 +217,136 @@ class QDocDatabase static void destroyQdocDB(); ~QDocDatabase(); - const DocNodeMap& groups() const { return groups_; } - const DocNodeMap& modules() const { return modules_; } - const DocNodeMap& qmlModules() const { return qmlModules_; } - - DocNode* getGroup(const QString& name); - DocNode* findGroup(const QString& name); - DocNode* findModule(const QString& name); - QmlModuleNode* findQmlModule(const QString& name); - - DocNode* addGroup(const QString& name); - DocNode* addModule(const QString& name); - QmlModuleNode* addQmlModule(const QString& 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; - - 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(); - - // 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); - - /* 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 resolveQmlInheritance(InnerNode* root); - void resolveIssues(); - void fixInheritance() { tree_->fixInheritance(); } - void resolveProperties() { tree_->resolveProperties(); } + Tree* findTree(const QString& t) { return forest_.findTree(t); } + const CNMap& groups() { return primaryTree()->groups(); } + const CNMap& modules() { return primaryTree()->modules(); } + const CNMap& qmlModules() { return primaryTree()->qmlModules(); } + + 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); } - 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); } + 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); } - NameCollisionNode* findCollisionNode(const QString& name) const { - return tree_->findCollisionNode(name); + 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(); } + + QmlClassNode* findQmlType(const QString& name); + QmlClassNode* findQmlType(const QString& qmid, const QString& name); + QmlClassNode* findQmlType(const ImportRec& import, const QString& name); - 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); + 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(); + NodeMap& getMainClasses(); + NodeMap& getCompatibilityClasses(); + NodeMap& getObsoleteClasses(); + NodeMap& getClassesWithObsoleteMembers(); + NodeMap& getObsoleteQmlTypes(); + NodeMap& getQmlTypesWithObsoleteMembers(); + NodeMap& getNamespaces(); + NodeMap& getServiceClasses(); + NodeMap& getQmlBasicTypes(); + NodeMap& getQmlTypes(); + NodeMapMap& getFunctionIndex(); + TextToNodeMap& getLegaleseTexts(); + const NodeMap& getClassMap(const QString& key); + const NodeMap& getQmlTypeMap(const QString& key); + const NodeMultiMap& getSinceMap(const QString& key); + + /******************************************************************* + Many of these will be either eliminated or replaced. + ********************************************************************/ + void resolveInheritance() { primaryTree()->resolveInheritance(); } + void resolveQmlInheritance(InnerNode* root); + void resolveIssues(); + void fixInheritance() { primaryTree()->fixInheritance(); } + void resolveProperties() { primaryTree()->resolveProperties(); } + + void resolveTargets() { + primaryTree()->resolveTargets(primaryTreeRoot()); + } + void insertTarget(const QString& name, + const QString& title, + TargetRec::Type type, + Node* node, + int priority) { + primaryTree()->insertTarget(name, title, type, node, priority); + } + /******************************************************************* + 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); + } + FunctionNode* findNodeInOpenNamespace(const QStringList& parentPath, const FunctionNode* clone); + Node* findNodeInOpenNamespace(QStringList& path, Node::Type type); + const Node* checkForCollision(const QString& name) { + return primaryTree()->checkForCollision(name); } - Node* findNodeByNameAndType(const QStringList& path, Node::Type type, Node::SubType subtype){ - return tree_->findNodeByNameAndType(path, type, subtype, 0); + /*******************************************************************/ + + /******************************************************************* + The functions declared below handle the parameters in '[' ']'. + ********************************************************************/ + const Node* findNodeForAtom(const Atom* atom, const Node* relative, QString& ref); + /*******************************************************************/ + + /******************************************************************* + The functions declared below are called for all trees. + ********************************************************************/ + ClassNode* findClassNode(const QStringList& path) { return forest_.findClassNode(path); } + Node* findNodeForInclude(const QStringList& path) { return forest_.findNodeForInclude(path); } + InnerNode* findRelatesNode(const QStringList& path) { return forest_.findRelatesNode(path); } + const Node* findFunctionNode(const QString& target, const Node* relative, Node::Genus genus) { + return forest_.findFunctionNode(target, relative, genus); + } + const Node* findTypeNode(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); } - NameCollisionNode* checkForCollision(const QString& name) const { - return tree_->checkForCollision(name); + Node* findNodeByNameAndType(const QStringList& path, Node::Type type) { + return forest_.findNodeByNameAndType(path, type); } - void addBaseClass(ClassNode* subclass, - Node::Access access, - const QStringList& basePath, - const QString& dataTypeWithTemplateArgs, - InnerNode* parent) { - tree_->addBaseClass(subclass, access, basePath, dataTypeWithTemplateArgs, parent); + + private: + const Node* findNodeForTarget(QStringList& targetPath, + const Node* relative, + Node::Genus genus, + QString& ref) { + return forest_.findNodeForTarget(targetPath, relative, genus, ref); } + + /*******************************************************************/ + public: 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,48 @@ 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 setLocalSearch() { forest_.searchOrder_ = QVector<Tree*>(1, primaryTree()); } + void setSearchOrder(const QVector<Tree*>& searchOrder) { forest_.searchOrder_ = 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); + const Node* findNode(const QStringList& path, + const Node* relative, + int findFlags, + Node::Genus genus) { + return forest_.findNode(path, relative, findFlags, genus); } + 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_; @@ -239,14 +414,13 @@ class QDocDatabase NodeMap qmlTypesWithObsoleteMembers_; NodeMap namespaceIndex_; NodeMap serviceClasses_; + NodeMap qmlBasicTypes_; NodeMap qmlClasses_; NodeMapMap newClassMaps_; NodeMapMap newQmlTypeMaps_; NodeMultiMapMap newSinceMaps_; NodeMapMap funcIndex_; TextToNodeMap legaleseTexts_; - DocNodeMultiMap docNodesByTitle_; - TargetRecMultiMap targetRecMultiMap_; QSet<QString> openNamespaces_; }; |