Utils: Streamline TreeModel API

The LeveledTreeModel case is general enough to cover
the UniformTreeModel case, so merge them and rename to
TreeModel. The former TreeModel is now BaseTreeModel.

BaseTreeModels should not be instantiated directly,
a tree model with non-uniform basic items is available
as TreeModel<>.

Done-with: Eike Ziller <eike.ziller@qt.io>
Change-Id: I64a65617ab68c0cde39cf65f4bc092ef808ee6fb
Reviewed-by: Christian Stenger <christian.stenger@qt.io>

14 files changed, 41 insertions, 41 deletions

diff --git a/src/plugins/debugger/breakhandler.cpp b/src/plugins/debugger/breakhandler.cpp
index 775f493bc2..d018fbe9dc 100644
--- a/src/plugins/debugger/breakhandler.cpp
+++ b/src/plugins/debugger/breakhandler.cpp
@@ -947,7 +947,7 @@ static bool isSimilarTo(const BreakpointParameters &params, const BreakpointResp
 Breakpoint BreakHandler::findSimilarBreakpoint(const BreakpointResponse &needle) const
 {
     // Search a breakpoint we might refer to.
-    return Breakpoint(findFirstLevelItem([needle](BreakpointItem *b) {
+    return Breakpoint(findItemAtLevel<1>([needle](BreakpointItem *b) {
         if (b->m_response.id.isValid() && b->m_response.id.majorPart() == needle.id.majorPart())
             return true;
         return isSimilarTo(b->m_params, needle);
@@ -956,21 +956,21 @@ Breakpoint BreakHandler::findSimilarBreakpoint(const BreakpointResponse &needle)
 
 Breakpoint BreakHandler::findBreakpointByResponseId(const BreakpointResponseId &id) const
 {
-    return Breakpoint(findFirstLevelItem([id](BreakpointItem *b) {
+    return Breakpoint(findItemAtLevel<1>([id](BreakpointItem *b) {
         return b->m_response.id.majorPart() == id.majorPart();
     }));
 }
 
 Breakpoint BreakHandler::findBreakpointByFunction(const QString &functionName) const
 {
-    return Breakpoint(findFirstLevelItem([functionName](BreakpointItem *b) {
+    return Breakpoint(findItemAtLevel<1>([functionName](BreakpointItem *b) {
         return b->m_params.functionName == functionName;
     }));
 }
 
 Breakpoint BreakHandler::findBreakpointByAddress(quint64 address) const
 {
-    return Breakpoint(findFirstLevelItem([address](BreakpointItem *b) {
+    return Breakpoint(findItemAtLevel<1>([address](BreakpointItem *b) {
         return b->m_params.address == address || b->m_params.address == address;
     }));
 }
@@ -978,14 +978,14 @@ Breakpoint BreakHandler::findBreakpointByAddress(quint64 address) const
 Breakpoint BreakHandler::findBreakpointByFileAndLine(const QString &fileName,
     int lineNumber, bool useMarkerPosition)
 {
-    return Breakpoint(findFirstLevelItem([=](BreakpointItem *b) {
+    return Breakpoint(findItemAtLevel<1>([=](BreakpointItem *b) {
         return b->isLocatedAt(fileName, lineNumber, useMarkerPosition);
     }));
 }
 
 Breakpoint BreakHandler::breakpointById(BreakpointModelId id) const
 {
-    return Breakpoint(findFirstLevelItem([id](BreakpointItem *b) { return b->m_id == id; }));
+    return Breakpoint(findItemAtLevel<1>([id](BreakpointItem *b) { return b->m_id == id; }));
 }
 
 QVariant BreakHandler::data(const QModelIndex &idx, int role) const
@@ -1005,7 +1005,7 @@ void BreakHandler::deletionHelper(BreakpointModelId id)
 
 Breakpoint BreakHandler::findWatchpoint(const BreakpointParameters &params) const
 {
-    return Breakpoint(findFirstLevelItem([params](BreakpointItem *b) {
+    return Breakpoint(findItemAtLevel<1>([params](BreakpointItem *b) {
         return b->m_params.isWatchpoint()
                 && b->m_params.address == params.address
                 && b->m_params.size == params.size
@@ -1017,7 +1017,7 @@ Breakpoint BreakHandler::findWatchpoint(const BreakpointParameters &params) cons
 void BreakHandler::saveBreakpoints()
 {
     QList<QVariant> list;
-    forFirstLevelItems([&list](BreakpointItem *b) {
+    forItemsAtLevel<1>([&list](BreakpointItem *b) {
         const BreakpointParameters &params = b->m_params;
         QMap<QString, QVariant> map;
         if (params.type != BreakpointByFileAndLine)
@@ -1121,12 +1121,12 @@ void BreakHandler::loadBreakpoints()
 
 void BreakHandler::updateMarkers()
 {
-    forFirstLevelItems([](BreakpointItem *b) { b->updateMarker(); });
+    forItemsAtLevel<1>([](BreakpointItem *b) { b->updateMarker(); });
 }
 
 Breakpoint BreakHandler::findBreakpointByIndex(const QModelIndex &index) const
 {
-    return Breakpoint(firstLevelItemForIndex(index));
+    return Breakpoint(itemForIndexAtLevel<1>(index));
 }
 
 Breakpoints BreakHandler::findBreakpointsByIndex(const QList<QModelIndex> &list) const
@@ -1736,7 +1736,7 @@ void BreakHandler::breakByFunction(const QString &functionName)
 {
     // One breakpoint per function is enough for now. This does not handle
     // combinations of multiple conditions and ignore counts, though.
-    bool found = findFirstLevelItem([functionName](BreakpointItem *b) {
+    bool found = findItemAtLevel<1>([functionName](BreakpointItem *b) {
         const BreakpointParameters &params = b->m_params;
         return params.functionName == functionName
                 && params.condition.isEmpty()
@@ -1828,7 +1828,7 @@ void BreakHandler::changeLineNumberFromMarkerHelper(BreakpointModelId id)
 Breakpoints BreakHandler::allBreakpoints() const
 {
     Breakpoints items;
-    forFirstLevelItems([&items](BreakpointItem *b) { items.append(Breakpoint(b)); });
+    forItemsAtLevel<1>([&items](BreakpointItem *b) { items.append(Breakpoint(b)); });
     return items;
 }
 
@@ -1840,7 +1840,7 @@ Breakpoints BreakHandler::unclaimedBreakpoints() const
 Breakpoints BreakHandler::engineBreakpoints(DebuggerEngine *engine) const
 {
     Breakpoints items;
-    forFirstLevelItems([&items, engine](BreakpointItem *b) {
+    forItemsAtLevel<1>([&items, engine](BreakpointItem *b) {
         if (b->m_engine == engine)
             items.append(Breakpoint(b));
     });
@@ -1850,7 +1850,7 @@ Breakpoints BreakHandler::engineBreakpoints(DebuggerEngine *engine) const
 QStringList BreakHandler::engineBreakpointPaths(DebuggerEngine *engine) const
 {
     QSet<QString> set;
-    forFirstLevelItems([&set, engine](BreakpointItem *b) {
+    forItemsAtLevel<1>([&set, engine](BreakpointItem *b) {
         if (b->m_engine == engine) {
             if (b->m_params.type == BreakpointByFileAndLine)
                 set.insert(QFileInfo(b->m_params.fileName).dir().path());
@@ -1990,7 +1990,7 @@ bool BreakHandler::contextMenuEvent(const ItemViewEvent &ev)
               [this] { deleteAllBreakpoints(); });
 
     // Delete by file: Find indices of breakpoints of the same file.
-    BreakpointItem *item = firstLevelItemForIndex(ev.index());
+    BreakpointItem *item = itemForIndexAtLevel<1>(ev.index());
     Breakpoints breakpointsInFile;
     QString file;
     if (item) {
diff --git a/src/plugins/debugger/breakhandler.h b/src/plugins/debugger/breakhandler.h
index 82426abbd0..e31fc81fa1 100644
--- a/src/plugins/debugger/breakhandler.h
+++ b/src/plugins/debugger/breakhandler.h
@@ -159,7 +159,7 @@ inline uint qHash(const Debugger::Internal::Breakpoint &b) { return b.hash(); }
 
 typedef QList<Breakpoint> Breakpoints;
 
-using BreakModel = Utils::LeveledTreeModel<Utils::TypedTreeItem<BreakpointItem>, BreakpointItem, LocationItem>;
+using BreakModel = Utils::TreeModel<Utils::TypedTreeItem<BreakpointItem>, BreakpointItem, LocationItem>;
 
 class BreakHandler : public BreakModel
 {
diff --git a/src/plugins/debugger/console/consoleitemmodel.cpp b/src/plugins/debugger/console/consoleitemmodel.cpp
index fc65764c71..fe72ddc315 100644
--- a/src/plugins/debugger/console/consoleitemmodel.cpp
+++ b/src/plugins/debugger/console/consoleitemmodel.cpp
@@ -38,7 +38,7 @@ namespace Internal {
 ///////////////////////////////////////////////////////////////////////
 
 ConsoleItemModel::ConsoleItemModel(QObject *parent) :
-    Utils::TreeModel(new ConsoleItem, parent),
+    Utils::TreeModel<>(new ConsoleItem, parent),
     m_maxSizeOfFileName(0)
 {
     clear();
@@ -46,7 +46,7 @@ ConsoleItemModel::ConsoleItemModel(QObject *parent) :
 
 void ConsoleItemModel::clear()
 {
-    Utils::TreeModel::clear();
+    Utils::TreeModel<>::clear();
     appendItem(new ConsoleItem(ConsoleItem::InputType));
     emit selectEditableRow(index(0, 0, QModelIndex()), QItemSelectionModel::ClearAndSelect);
 }
diff --git a/src/plugins/debugger/console/consoleitemmodel.h b/src/plugins/debugger/console/consoleitemmodel.h
index 03f0203f01..023b69ec32 100644
--- a/src/plugins/debugger/console/consoleitemmodel.h
+++ b/src/plugins/debugger/console/consoleitemmodel.h
@@ -37,7 +37,7 @@ QT_END_NAMESPACE
 namespace Debugger {
 namespace Internal {
 
-class ConsoleItemModel : public Utils::TreeModel
+class ConsoleItemModel : public Utils::TreeModel<>
 {
     Q_OBJECT
 public:
diff --git a/src/plugins/debugger/debuggeroptionspage.cpp b/src/plugins/debugger/debuggeroptionspage.cpp
index 359451bb3a..701a84c671 100644
--- a/src/plugins/debugger/debuggeroptionspage.cpp
+++ b/src/plugins/debugger/debuggeroptionspage.cpp
@@ -99,7 +99,7 @@ public:
 // DebuggerItemModel
 // --------------------------------------------------------------------------
 
-class DebuggerItemModel : public LeveledTreeModel<TreeItem, StaticTreeItem, DebuggerTreeItem>
+class DebuggerItemModel : public TreeModel<TreeItem, StaticTreeItem, DebuggerTreeItem>
 {
     Q_DECLARE_TR_FUNCTIONS(Debugger::DebuggerOptionsPage)
 
@@ -139,7 +139,7 @@ void DebuggerItemModel::addDebugger(const DebuggerItem &item, bool changed)
 void DebuggerItemModel::updateDebugger(const DebuggerItem &item)
 {
     auto matcher = [item](DebuggerTreeItem *n) { return n->m_item.m_id == item.id(); };
-    DebuggerTreeItem *treeItem = findSecondLevelItem(matcher);
+    DebuggerTreeItem *treeItem = findItemAtLevel<2>(matcher);
     QTC_ASSERT(treeItem, return);
 
     TreeItem *parent = treeItem->parent();
@@ -178,7 +178,7 @@ void DebuggerItemModel::apply()
     foreach (const QVariant &id, m_removedItems)
         DebuggerItemManager::deregisterDebugger(id);
 
-    forSecondLevelItems([](DebuggerTreeItem *item) {
+    forItemsAtLevel<2>([](DebuggerTreeItem *item) {
         item->m_changed = false;
         DebuggerItemManager::updateOrAddDebugger(item->m_item);
     });
diff --git a/src/plugins/debugger/debuggertooltipmanager.cpp b/src/plugins/debugger/debuggertooltipmanager.cpp
index a34a0b41c0..d3e179f1c9 100644
--- a/src/plugins/debugger/debuggertooltipmanager.cpp
+++ b/src/plugins/debugger/debuggertooltipmanager.cpp
@@ -212,8 +212,8 @@ public:
 
 ToolTipWatchItem::ToolTipWatchItem(TreeItem *item)
 {
-    const TreeModel *model = item->model();
-    QModelIndex idx = model->indexForItem(item);
+    const QAbstractItemModel *model = item->model();
+    QModelIndex idx = item->index();
     name = model->data(idx.sibling(idx.row(), 0), Qt::DisplayRole).toString();
     value = model->data(idx.sibling(idx.row(), 1), Qt::DisplayRole).toString();
     type = model->data(idx.sibling(idx.row(), 2), Qt::DisplayRole).toString();
@@ -231,7 +231,7 @@ ToolTipWatchItem::ToolTipWatchItem(TreeItem *item)
 //
 /////////////////////////////////////////////////////////////////////////
 
-class ToolTipModel : public UniformTreeModel<ToolTipWatchItem>
+class ToolTipModel : public TreeModel<ToolTipWatchItem>
 {
 public:
     ToolTipModel()
diff --git a/src/plugins/debugger/moduleshandler.cpp b/src/plugins/debugger/moduleshandler.cpp
index b388322ce3..398152b9e4 100644
--- a/src/plugins/debugger/moduleshandler.cpp
+++ b/src/plugins/debugger/moduleshandler.cpp
@@ -250,7 +250,7 @@ QAbstractItemModel *ModulesHandler::model() const
 ModuleItem *ModulesHandler::moduleFromPath(const QString &modulePath) const
 {
     // Recent modules are more likely to be unloaded first.
-    return m_model->findFirstLevelItem([modulePath](ModuleItem *item) {
+    return m_model->findItemAtLevel<1>([modulePath](ModuleItem *item) {
         return item->module.modulePath == modulePath;
     });
 }
@@ -263,7 +263,7 @@ void ModulesHandler::removeAll()
 Modules ModulesHandler::modules() const
 {
     Modules mods;
-    m_model->forFirstLevelItems([&mods](ModuleItem *item) { mods.append(item->module); });
+    m_model->forItemsAtLevel<1>([&mods](ModuleItem *item) { mods.append(item->module); });
     return mods;
 }
 
@@ -302,13 +302,13 @@ void ModulesHandler::updateModule(const Module &module)
 
 void ModulesHandler::beginUpdateAll()
 {
-    m_model->forFirstLevelItems([](ModuleItem *item) { item->updated = false; });
+    m_model->forItemsAtLevel<1>([](ModuleItem *item) { item->updated = false; });
 }
 
 void ModulesHandler::endUpdateAll()
 {
     QList<TreeItem *> toDestroy;
-    m_model->forFirstLevelItems([&toDestroy](ModuleItem *item) {
+    m_model->forItemsAtLevel<1>([&toDestroy](ModuleItem *item) {
         if (!item->updated)
             toDestroy.append(item);
     });
diff --git a/src/plugins/debugger/moduleshandler.h b/src/plugins/debugger/moduleshandler.h
index bdb425e0eb..2be31da5ff 100644
--- a/src/plugins/debugger/moduleshandler.h
+++ b/src/plugins/debugger/moduleshandler.h
@@ -110,7 +110,7 @@ typedef QVector<Module> Modules;
 //
 //////////////////////////////////////////////////////////////////
 
-using ModulesModel = Utils::LeveledTreeModel<Utils::TypedTreeItem<ModuleItem>, ModuleItem>;
+using ModulesModel = Utils::TreeModel<Utils::TypedTreeItem<ModuleItem>, ModuleItem>;
 
 class ModulesHandler : public QObject
 {
diff --git a/src/plugins/debugger/registerhandler.cpp b/src/plugins/debugger/registerhandler.cpp
index 41b92dff90..9ab72f0801 100644
--- a/src/plugins/debugger/registerhandler.cpp
+++ b/src/plugins/debugger/registerhandler.cpp
@@ -677,8 +677,8 @@ bool RegisterHandler::contextMenuEvent(const ItemViewEvent &ev)
     const bool actionsEnabled = m_engine->debuggerActionsEnabled();
     const DebuggerState state = m_engine->state();
 
-    RegisterItem *registerItem = firstLevelItemForIndex(ev.index());
-    RegisterSubItem *registerSubItem = secondLevelItemForIndex(ev.index());
+    RegisterItem *registerItem = itemForIndexAtLevel<1>(ev.index());
+    RegisterSubItem *registerSubItem = itemForIndexAtLevel<2>(ev.index());
 
     const quint64 address = registerItem ? registerItem->addressValue() : 0;
     const QString registerName = registerItem ? registerItem->m_reg.name : QString();
diff --git a/src/plugins/debugger/registerhandler.h b/src/plugins/debugger/registerhandler.h
index 0579378431..45675bf90d 100644
--- a/src/plugins/debugger/registerhandler.h
+++ b/src/plugins/debugger/registerhandler.h
@@ -101,7 +101,7 @@ public:
 class RegisterSubItem;
 class RegisterItem;
 using RegisterRootItem = Utils::TypedTreeItem<RegisterItem>;
-using RegisterModel = Utils::LeveledTreeModel<RegisterRootItem, RegisterItem, RegisterSubItem>;
+using RegisterModel = Utils::TreeModel<RegisterRootItem, RegisterItem, RegisterSubItem>;
 
 typedef QMap<quint64, QString> RegisterMap;
 
diff --git a/src/plugins/debugger/threadshandler.cpp b/src/plugins/debugger/threadshandler.cpp
index 4c2cc2ba2b..87b6efba3a 100644
--- a/src/plugins/debugger/threadshandler.cpp
+++ b/src/plugins/debugger/threadshandler.cpp
@@ -263,7 +263,7 @@ bool ThreadsHandler::setData(const QModelIndex &idx, const QVariant &data, int r
 static ThreadItem *itemForThreadId(const ThreadsHandler *handler, ThreadId threadId)
 {
     const auto matcher = [threadId](ThreadItem *item) { return item->threadData.id == threadId; };
-    return handler->findFirstLevelItem(matcher);
+    return handler->findItemAtLevel<1>(matcher);
 }
 
 static int indexForThreadId(const ThreadsHandler *handler, ThreadId threadId)
@@ -361,7 +361,7 @@ void ThreadsHandler::setThreads(const Threads &threads)
 void ThreadsHandler::updateThreadBox()
 {
     QStringList list;
-    forFirstLevelItems([&list](ThreadItem *item) {
+    forItemsAtLevel<1>([&list](ThreadItem *item) {
         list.append(QString::fromLatin1("#%1 %2").arg(item->threadData.id.raw()).arg(item->threadData.name));
     });
     Internal::setThreadBoxContents(list, indexForThreadId(this, m_currentId));
@@ -382,7 +382,7 @@ void ThreadsHandler::removeAll()
 bool ThreadsHandler::notifyGroupExited(const QString &groupId)
 {
     QList<ThreadItem *> list;
-    forFirstLevelItems([&list, groupId](ThreadItem *item) {
+    forItemsAtLevel<1>([&list, groupId](ThreadItem *item) {
         if (item->threadData.groupId == groupId)
             list.append(item);
     });
@@ -409,7 +409,7 @@ void ThreadsHandler::notifyRunning(const QString &data)
 
 void ThreadsHandler::notifyAllRunning()
 {
-    forFirstLevelItems([](ThreadItem *item) { item->notifyRunning(); });
+    forItemsAtLevel<1>([](ThreadItem *item) { item->notifyRunning(); });
 }
 
 void ThreadsHandler::notifyRunning(ThreadId threadId)
@@ -434,7 +434,7 @@ void ThreadsHandler::notifyStopped(const QString &data)
 
 void ThreadsHandler::notifyAllStopped()
 {
-    forFirstLevelItems([](ThreadItem *item) { item->notifyStopped(); });
+    forItemsAtLevel<1>([](ThreadItem *item) { item->notifyStopped(); });
 }
 
 void ThreadsHandler::notifyStopped(ThreadId threadId)
diff --git a/src/plugins/debugger/threadshandler.h b/src/plugins/debugger/threadshandler.h
index a7d0d6ef31..c95001f867 100644
--- a/src/plugins/debugger/threadshandler.h
+++ b/src/plugins/debugger/threadshandler.h
@@ -42,7 +42,7 @@ class DebuggerEngine;
 class GdbMi;
 class ThreadItem;
 
-class ThreadsHandler : public Utils::LeveledTreeModel<Utils::TypedTreeItem<ThreadItem>, ThreadItem>
+class ThreadsHandler : public Utils::TreeModel<Utils::TypedTreeItem<ThreadItem>, ThreadItem>
 {
     Q_OBJECT
 
diff --git a/src/plugins/debugger/watchhandler.cpp b/src/plugins/debugger/watchhandler.cpp
index 88c2272f18..d16a35f059 100644
--- a/src/plugins/debugger/watchhandler.cpp
+++ b/src/plugins/debugger/watchhandler.cpp
@@ -2018,7 +2018,7 @@ void WatchHandler::notifyUpdateStarted(const QStringList &inames)
     auto marker = [](WatchItem *item) { item->outdated = true; };
 
     if (inames.isEmpty()) {
-        m_model->forFirstLevelItems([marker](WatchItem *item) {
+        m_model->forItemsAtLevel<1>([marker](WatchItem *item) {
             item->forAllChildren(marker);
         });
     } else {
diff --git a/src/plugins/debugger/watchhandler.h b/src/plugins/debugger/watchhandler.h
index 11d50d73c3..cf62cf2aed 100644
--- a/src/plugins/debugger/watchhandler.h
+++ b/src/plugins/debugger/watchhandler.h
@@ -38,7 +38,7 @@ class WatchModel;
 
 typedef QVector<DisplayFormat> DisplayFormats;
 
-class WatchModelBase : public Utils::UniformTreeModel<WatchItem>
+class WatchModelBase : public Utils::TreeModel<WatchItem, WatchItem>
 {
     Q_OBJECT