CppTools: move locators ownership to ModelManager

Move locator and find filters ownership and initialization to ModelManager. Initialize builtin filters by default and provide methods to set them from plugins. Change-Id: I4cc82ecff3415329a5f97b1be9dcc45e6103bf5a Reviewed-by: Nikolai Kosjar <nikolai.kosjar@qt.io>
2017-09-29 14:41:09 +02:00
parent 58494877fd
commit 7666db896d
4 changed files with 131 additions and 46 deletions
--- a/src/plugins/cpptools/cppmodelmanager.cpp
+++ b/src/plugins/cpptools/cppmodelmanager.cpp
@@ -28,9 +28,15 @@
 #include "abstracteditorsupport.h"
 #include "baseeditordocumentprocessor.h"
 #include "builtinindexingsupport.h"
+#include "cppclassesfilter.h"
 #include "cppcodemodelinspectordumper.h"
+#include "cppcurrentdocumentfilter.h"
 #include "cppfindreferences.h"
+#include "cppfunctionsfilter.h"
+#include "cppincludesfilter.h"
 #include "cppindexingsupport.h"
+#include "cpplocatordata.h"
+#include "cpplocatorfilter.h"
 #include "cppmodelmanagersupportinternal.h"
 #include "cpprefactoringchanges.h"
 #include "cpprefactoringengine.h"
@@ -40,10 +46,12 @@
 #include "cpptoolsreuse.h"
 #include "editordocumenthandle.h"
 #include "symbolfinder.h"
+#include "symbolsfindfilter.h"
 #include "followsymbolinterface.h"

 #include <coreplugin/documentmanager.h>
 #include <coreplugin/icore.h>
+#include <coreplugin/vcsmanager.h>
 #include <coreplugin/progressmanager/progressmanager.h>
 #include <coreplugin/editormanager/editormanager.h>
 #include <texteditor/textdocument.h>
@@ -124,7 +132,6 @@ using REType = RefactoringEngineType;

 namespace Internal {

-static QMutex m_instanceMutex;
 static CppModelManager *m_instance;

 class CppModelManagerPrivate
@@ -171,6 +178,14 @@ public:
    // Refactoring
    using REHash = QMap<REType, RefactoringEngineInterface *>;
    REHash m_refactoringEngines;
+
+    CppLocatorData m_locatorData;
+    std::unique_ptr<Core::ILocatorFilter> m_locatorFilter;
+    std::unique_ptr<Core::ILocatorFilter> m_classesFilter;
+    std::unique_ptr<Core::ILocatorFilter> m_includesFilter;
+    std::unique_ptr<Core::ILocatorFilter> m_functionsFilter;
+    std::unique_ptr<Core::IFindFilter> m_symbolsFindFilter;
+    std::unique_ptr<Core::ILocatorFilter> m_currentDocumentFilter;
 };

 } // namespace Internal
@@ -335,6 +350,50 @@ void CppModelManager::removeRefactoringEngine(RefactoringEngineType type)
    instance()->d->m_refactoringEngines.remove(type);
 }

+template<class FilterClass>
+static void setFilter(std::unique_ptr<FilterClass> &filter,
+                      std::unique_ptr<FilterClass> &&newFilter)
+{
+    if (!ExtensionSystem::PluginManager::instance())
+        return;
+    if (filter)
+        ExtensionSystem::PluginManager::removeObject(filter.get());
+    if (!newFilter)
+        return;
+    filter = std::move(newFilter);
+    ExtensionSystem::PluginManager::addObject(filter.get());
+}
+
+void CppModelManager::setLocatorFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+{
+    setFilter(d->m_locatorFilter, std::move(filter));
+}
+
+void CppModelManager::setClassesFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+{
+    setFilter(d->m_classesFilter, std::move(filter));
+}
+
+void CppModelManager::setIncludesFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+{
+    setFilter(d->m_includesFilter, std::move(filter));
+}
+
+void CppModelManager::setFunctionsFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+{
+    setFilter(d->m_functionsFilter, std::move(filter));
+}
+
+void CppModelManager::setSymbolsFindFilter(std::unique_ptr<Core::IFindFilter> &&filter)
+{
+    setFilter(d->m_symbolsFindFilter, std::move(filter));
+}
+
+void CppModelManager::setCurrentDocumentFilter(std::unique_ptr<Core::ILocatorFilter> &&filter)
+{
+    setFilter(d->m_currentDocumentFilter, std::move(filter));
+}
+
 FollowSymbolInterface &CppModelManager::followSymbolInterface() const
 {
    return d->m_activeModelManagerSupport->followSymbolInterface();
@@ -369,16 +428,58 @@ void CppModelManager::updateModifiedSourceFiles()

 CppModelManager *CppModelManager::instance()
 {
-    if (m_instance)
-        return m_instance;
-
-    QMutexLocker locker(&m_instanceMutex);
-    if (!m_instance)
-        m_instance = new CppModelManager;
-
+    QTC_ASSERT(m_instance, return nullptr;);
    return m_instance;
 }

+void CppModelManager::resetFilters()
+{
+    setLocatorFilter();
+    setClassesFilter();
+    setIncludesFilter();
+    setFunctionsFilter();
+    setSymbolsFindFilter();
+    setCurrentDocumentFilter();
+}
+
+void CppModelManager::createCppModelManager(Internal::CppToolsPlugin *parent,
+                                            Internal::StringTable &stringTable)
+{
+    QTC_ASSERT(!m_instance, return;);
+    m_instance = new CppModelManager();
+    m_instance->initCppTools(stringTable);
+    m_instance->setParent(parent);
+}
+
+void CppModelManager::initCppTools(Internal::StringTable &stringTable)
+{
+    // Objects
+    connect(Core::VcsManager::instance(), &Core::VcsManager::repositoryChanged,
+            this, &CppModelManager::updateModifiedSourceFiles);
+    connect(Core::DocumentManager::instance(), &Core::DocumentManager::filesChangedInternally,
+            [this](const QStringList &files) {
+        updateSourceFiles(files.toSet());
+    });
+
+    connect(this, &CppModelManager::documentUpdated,
+            &d->m_locatorData, &CppLocatorData::onDocumentUpdated);
+
+    connect(this, &CppModelManager::aboutToRemoveFiles,
+            &d->m_locatorData, &CppLocatorData::onAboutToRemoveFiles);
+
+    ExtensionSystem::PluginManager *pluginManager = ExtensionSystem::PluginManager::instance();
+    QTC_ASSERT(pluginManager, return;);
+
+    // Set up builtin filters
+    setLocatorFilter(std::make_unique<CppLocatorFilter>(&d->m_locatorData));
+    setClassesFilter(std::make_unique<CppClassesFilter>(&d->m_locatorData));
+    setIncludesFilter(std::make_unique<CppIncludesFilter>());
+    setFunctionsFilter(std::make_unique<CppFunctionsFilter>(&d->m_locatorData));
+    setSymbolsFindFilter(std::make_unique<SymbolsFindFilter>(this));
+    setCurrentDocumentFilter(
+                std::make_unique<Internal::CppCurrentDocumentFilter>(this, stringTable));
+}
+
 void CppModelManager::initializeBuiltinModelManagerSupport()
 {
    d->m_builtinModelManagerSupport
@@ -388,8 +489,8 @@ void CppModelManager::initializeBuiltinModelManagerSupport()
            &d->m_activeModelManagerSupport->refactoringEngineInterface();
 }

-CppModelManager::CppModelManager(QObject *parent)
-    : CppModelManagerBase(parent), d(new CppModelManagerPrivate)
+CppModelManager::CppModelManager()
+    : CppModelManagerBase(nullptr), d(new CppModelManagerPrivate)
 {
    d->m_indexingSupporter = 0;
    d->m_enableGC = true;
@@ -438,6 +539,7 @@ CppModelManager::CppModelManager(QObject *parent)
 CppModelManager::~CppModelManager()
 {
    delete d->m_internalIndexingSupport;
+    resetFilters();
    delete d;
 }