debugger: split BreakpointIndex into plugin and debugger specific part

Change-Id: I21d10cf42eb039c74475e106537b6e107d155196
Reviewed-on: http://codereview.qt.nokia.com/745

Reviewed-by: hjk <qthjk@ovi.com>

src/plugins/debugger/breakhandler.h

@@ -73,20 +73,20 @@ public:
     void handleAlienBreakpoint(const BreakpointResponse &response,
         DebuggerEngine *engine);
     void insertSubBreakpoint(const BreakpointResponse &data);
-    void removeAlienBreakpoint(BreakpointId id);
+    void removeAlienBreakpoint(BreakpointModelId id);
 
-    BreakpointIds allBreakpointIds() const;
-    BreakpointIds engineBreakpointIds(DebuggerEngine *engine) const;
-    BreakpointIds unclaimedBreakpointIds() const;
+    BreakpointModelIds allBreakpointIds() const;
+    BreakpointModelIds engineBreakpointIds(DebuggerEngine *engine) const;
+    BreakpointModelIds unclaimedBreakpointIds() const;
     int size() const { return m_storage.size(); }
 
     // Find a breakpoint matching approximately the data in needle.
-    BreakpointId findSimilarBreakpoint(const BreakpointResponse &needle) const;
-    BreakpointId findBreakpointByNumber(int bpNumber) const;
-    BreakpointId findWatchpoint(const BreakpointParameters &data) const;
-    BreakpointId findBreakpointByFunction(const QString &functionName) const;
-    BreakpointId findBreakpointByIndex(const QModelIndex &index) const;
-    BreakpointIds findBreakpointsByIndex(const QList<QModelIndex> &list) const;
+    BreakpointModelId findSimilarBreakpoint(const BreakpointResponse &needle) const;
+    BreakpointModelId findBreakpointByResponseId(const BreakpointResponseId &resultId) const;
+    BreakpointModelId findWatchpoint(const BreakpointParameters &data) const;
+    BreakpointModelId findBreakpointByFunction(const QString &functionName) const;
+    BreakpointModelId findBreakpointByIndex(const QModelIndex &index) const;
+    BreakpointModelIds findBreakpointsByIndex(const QList<QModelIndex> &list) const;
     void updateMarkers();
 
     static QIcon breakpointIcon();
@@ -96,69 +96,69 @@ public:
     static QIcon watchpointIcon();
     static QIcon tracepointIcon();
 
-    BreakpointId findBreakpointByFileAndLine(const QString &fileName,
+    BreakpointModelId findBreakpointByFileAndLine(const QString &fileName,
         int lineNumber, bool useMarkerPosition = true);
-    BreakpointId findBreakpointByAddress(quint64 address) const;
+    BreakpointModelId findBreakpointByAddress(quint64 address) const;
 
     void breakByFunction(const QString &functionName);
-    void removeBreakpoint(BreakpointId id);
-    QIcon icon(BreakpointId id) const;
-    void gotoLocation(BreakpointId id) const;
+    void removeBreakpoint(BreakpointModelId id);
+    QIcon icon(BreakpointModelId id) const;
+    void gotoLocation(BreakpointModelId id) const;
 
     // Getter retrieves property value.
     // Setter sets property value and triggers update if changed.
-    BreakpointPathUsage pathUsage(BreakpointId id) const;
-    void setPathUsage(BreakpointId, const BreakpointPathUsage &u);
-    QByteArray condition(BreakpointId id) const;
-    void setCondition(BreakpointId, const QByteArray &condition);
-    int ignoreCount(BreakpointId id) const;
-    void setIgnoreCount(BreakpointId, const int &count);
-    int threadSpec(BreakpointId id) const;
-    void setThreadSpec(BreakpointId, const int&spec);
-    QString fileName(BreakpointId id) const;
-    void setFileName(BreakpointId, const QString &fileName);
-    QString functionName(BreakpointId id) const;
-    void setFunctionName(BreakpointId, const QString &functionName);
-    QString expression(BreakpointId id) const;
-    void setExpression(BreakpointId, const QString &expression);
-    BreakpointType type(BreakpointId id) const;
-    void setType(BreakpointId id, const BreakpointType &type);
-    quint64 address(BreakpointId id) const;
-    void setAddress(BreakpointId id, const quint64 &address);
-    int lineNumber(BreakpointId id) const;
-    void changeBreakpointData(BreakpointId id, const BreakpointParameters &data,
+    BreakpointPathUsage pathUsage(BreakpointModelId id) const;
+    void setPathUsage(BreakpointModelId, const BreakpointPathUsage &u);
+    QByteArray condition(BreakpointModelId id) const;
+    void setCondition(BreakpointModelId, const QByteArray &condition);
+    int ignoreCount(BreakpointModelId id) const;
+    void setIgnoreCount(BreakpointModelId, const int &count);
+    int threadSpec(BreakpointModelId id) const;
+    void setThreadSpec(BreakpointModelId, const int&spec);
+    QString fileName(BreakpointModelId id) const;
+    void setFileName(BreakpointModelId, const QString &fileName);
+    QString functionName(BreakpointModelId id) const;
+    void setFunctionName(BreakpointModelId, const QString &functionName);
+    QString expression(BreakpointModelId id) const;
+    void setExpression(BreakpointModelId, const QString &expression);
+    BreakpointType type(BreakpointModelId id) const;
+    void setType(BreakpointModelId id, const BreakpointType &type);
+    quint64 address(BreakpointModelId id) const;
+    void setAddress(BreakpointModelId id, const quint64 &address);
+    int lineNumber(BreakpointModelId id) const;
+    void changeBreakpointData(BreakpointModelId id, const BreakpointParameters &data,
         BreakpointParts parts);
-    const BreakpointParameters &breakpointData(BreakpointId id) const;
-    BreakpointState state(BreakpointId id) const;
-    bool isEnabled(BreakpointId id) const;
-    void setEnabled(BreakpointId id, bool on);
-    void updateLineNumberFromMarker(BreakpointId id, int lineNumber);
-    void setMarkerFileAndLine(BreakpointId id,
+    const BreakpointParameters &breakpointData(BreakpointModelId id) const;
+    BreakpointState state(BreakpointModelId id) const;
+    bool isEnabled(BreakpointModelId id) const;
+    void setEnabled(BreakpointModelId id, bool on);
+    void updateLineNumberFromMarker(BreakpointModelId id, int lineNumber);
+    void setMarkerFileAndLine(BreakpointModelId id,
         const QString &fileName, int lineNumber);
-    bool isWatchpoint(BreakpointId id) const;
-    bool isTracepoint(BreakpointId id) const;
-    void setTracepoint(BreakpointId, bool on);
-    DebuggerEngine *engine(BreakpointId id) const;
-    void setEngine(BreakpointId id, DebuggerEngine *engine);
-    const BreakpointResponse &response(BreakpointId id) const;
-    void setResponse(BreakpointId id, const BreakpointResponse &data);
-    bool needsChange(BreakpointId id) const;
+    bool isWatchpoint(BreakpointModelId id) const;
+    bool isTracepoint(BreakpointModelId id) const;
+    void setTracepoint(BreakpointModelId, bool on);
+    DebuggerEngine *engine(BreakpointModelId id) const;
+    void setEngine(BreakpointModelId id, DebuggerEngine *engine);
+    const BreakpointResponse &response(BreakpointModelId id) const;
+    void setResponse(BreakpointModelId id, const BreakpointResponse &data);
+    bool needsChange(BreakpointModelId id) const;
 
     // State transitions.
-    void notifyBreakpointChangeAfterInsertNeeded(BreakpointId id);
-    void notifyBreakpointInsertProceeding(BreakpointId id);
-    void notifyBreakpointInsertOk(BreakpointId id);
-    void notifyBreakpointInsertFailed(BreakpointId id);
-    void notifyBreakpointChangeOk(BreakpointId id);
-    void notifyBreakpointChangeProceeding(BreakpointId id);
-    void notifyBreakpointChangeFailed(BreakpointId id);
-    void notifyBreakpointPending(BreakpointId id);
-    void notifyBreakpointRemoveProceeding(BreakpointId id);
-    void notifyBreakpointRemoveOk(BreakpointId id);
-    void notifyBreakpointRemoveFailed(BreakpointId id);
-    void notifyBreakpointReleased(BreakpointId id);
-    void notifyBreakpointNeedsReinsertion(BreakpointId id);
-    void notifyBreakpointAdjusted(BreakpointId id,
+    void notifyBreakpointChangeAfterInsertNeeded(BreakpointModelId id);
+    void notifyBreakpointInsertProceeding(BreakpointModelId id);
+    void notifyBreakpointInsertOk(BreakpointModelId id);
+    void notifyBreakpointInsertFailed(BreakpointModelId id);
+    void notifyBreakpointChangeOk(BreakpointModelId id);
+    void notifyBreakpointChangeProceeding(BreakpointModelId id);
+    void notifyBreakpointChangeFailed(BreakpointModelId id);
+    void notifyBreakpointPending(BreakpointModelId id);
+    void notifyBreakpointRemoveProceeding(BreakpointModelId id);
+    void notifyBreakpointRemoveOk(BreakpointModelId id);
+    void notifyBreakpointRemoveFailed(BreakpointModelId id);
+    void notifyBreakpointReleased(BreakpointModelId id);
+    void notifyBreakpointNeedsReinsertion(BreakpointModelId id);
+    void notifyBreakpointAdjusted(BreakpointModelId id,
             const BreakpointParameters &data);
 
     static QString displayFromThreadSpec(int spec);
@@ -176,14 +176,14 @@ private:
     QModelIndex createIndex(int row, int column, quint32 id) const;
     QModelIndex createIndex(int row, int column, void *ptr) const;
 
-    int indexOf(BreakpointId id) const;
-    BreakpointId at(int index) const;
-    bool isEngineRunning(BreakpointId id) const;
-    void setState(BreakpointId id, BreakpointState state);
+    int indexOf(BreakpointModelId id) const;
+    BreakpointModelId at(int index) const;
+    bool isEngineRunning(BreakpointModelId id) const;
+    void setState(BreakpointModelId id, BreakpointState state);
     void loadBreakpoints();
     void saveBreakpoints();
-    void updateMarker(BreakpointId id);
-    void cleanupBreakpoint(BreakpointId id);
+    void updateMarker(BreakpointModelId id);
+    void cleanupBreakpoint(BreakpointModelId id);
 
     struct BreakpointItem
     {
@@ -205,7 +205,7 @@ private:
         BreakpointMarker *marker;
         QList<BreakpointResponse> subItems;
     };
-    typedef QHash<BreakpointId, BreakpointItem> BreakpointStorage;
+    typedef QHash<BreakpointModelId, BreakpointItem> BreakpointStorage;
     typedef BreakpointStorage::ConstIterator ConstIterator;
     typedef BreakpointStorage::Iterator Iterator;
     BreakpointStorage m_storage;

src/plugins/debugger/breakpoint.cpp

@@ -42,11 +42,72 @@ namespace Internal {
 
 //////////////////////////////////////////////////////////////////
 //
-// BreakpointId
+// BreakpointModelId
 //
 //////////////////////////////////////////////////////////////////
 
-BreakpointId::BreakpointId(const QByteArray &ba)
+/*!
+    \class Debugger::Internal::ModelId
+
+    This identifies a breakpoint in the \c BreakHandler. The
+    major parts are strictly increasing over time.
+*/
+
+
+QDebug operator<<(QDebug d, const BreakpointModelId &id)
+{
+    d << qPrintable(id.toString());
+    return d;
+}
+
+QByteArray BreakpointModelId::toByteArray() const
+{
+    if (!isValid())
+        return "<invalid bkpt>";
+    QByteArray ba = QByteArray::number(m_majorPart);
+    if (isMinor()) {
+        ba.append('.');
+        ba.append(QByteArray::number(m_minorPart));
+    }
+    return ba;
+}
+
+QString BreakpointModelId::toString() const
+{
+    if (!isValid())
+        return "<invalid bkpt>";
+    if (isMinor())
+        return QString("%1.%2").arg(m_majorPart).arg(m_minorPart);
+    return QString::number(m_majorPart);
+}
+
+BreakpointModelId BreakpointModelId::parent() const
+{
+    QTC_ASSERT(isMinor(), return BreakpointModelId());
+    return BreakpointModelId(m_majorPart, 0);
+}
+
+BreakpointModelId BreakpointModelId::child(int row) const
+{
+    QTC_ASSERT(isMajor(), return BreakpointModelId());
+    return BreakpointModelId(m_majorPart, row + 1);
+}
+
+
+//////////////////////////////////////////////////////////////////
+//
+// BreakpointResponseId
+//
+//////////////////////////////////////////////////////////////////
+
+/*!
+    \class Debugger::Internal::BreakpointResponseId
+
+    This is what the external debuggers use to identify a breakpoint.
+    It is only valid for one debugger run.
+*/
+
+BreakpointResponseId::BreakpointResponseId(const QByteArray &ba)
 {
     int pos = ba.indexOf('.');
     if (pos == -1) {
@@ -58,13 +119,13 @@ BreakpointId::BreakpointId(const QByteArray &ba)
     }
 }
 
-QDebug operator<<(QDebug d, const BreakpointId &id)
+QDebug operator<<(QDebug d, const BreakpointResponseId &id)
 {
     d << qPrintable(id.toString());
     return d;
 }
 
-QByteArray BreakpointId::toByteArray() const
+QByteArray BreakpointResponseId::toByteArray() const
 {
     if (!isValid())
         return "<invalid bkpt>";
@@ -76,7 +137,7 @@ QByteArray BreakpointId::toByteArray() const
     return ba;
 }
 
-QString BreakpointId::toString() const
+QString BreakpointResponseId::toString() const
 {
     if (!isValid())
         return "<invalid bkpt>";
@@ -85,16 +146,16 @@ QString BreakpointId::toString() const
     return QString::number(m_majorPart);
 }
 
-BreakpointId BreakpointId::parent() const
+BreakpointResponseId BreakpointResponseId::parent() const
 {
-    QTC_ASSERT(isMinor(), return BreakpointId());
-    return BreakpointId(m_majorPart, 0);
+    QTC_ASSERT(isMinor(), return BreakpointResponseId());
+    return BreakpointResponseId(m_majorPart, 0);
 }
 
-BreakpointId BreakpointId::child(int row) const
+BreakpointResponseId BreakpointResponseId::child(int row) const
 {
-    QTC_ASSERT(isMajor(), return BreakpointId());
-    return BreakpointId(m_majorPart, row + 1);
+    QTC_ASSERT(isMajor(), return BreakpointResponseId());
+    return BreakpointResponseId(m_majorPart, row + 1);
 }
 
 //////////////////////////////////////////////////////////////////
@@ -251,8 +312,6 @@ QString BreakpointResponse::toString() const
         ts << " Function: " << functionName;
     if (multiple)
         ts << " Multiple: " << multiple;
-    if (!extra.isEmpty())
-        ts << " Extra: " << extra;
     if (correctedLineNumber)
         ts << " CorrectedLineNumber: " << correctedLineNumber;
     ts << " Hit: " << hitCount << " times";
@@ -263,10 +322,9 @@ QString BreakpointResponse::toString() const
 void BreakpointResponse::fromParameters(const BreakpointParameters &p)
 {
     BreakpointParameters::operator=(p);
-    id = BreakpointId();
+    id = BreakpointResponseId();
     fullName.clear();
     multiple = false;
-    extra.clear();
     correctedLineNumber = 0;
     hitCount = 0;
 }

src/plugins/debugger/breakpoint.h

@@ -41,13 +41,19 @@
 namespace Debugger {
 namespace Internal {
 
-class BreakpointId
+//////////////////////////////////////////////////////////////////
+//
+// BreakpointModelId
+//
+//////////////////////////////////////////////////////////////////
+
+class BreakpointModelId
 {
 public:
-    BreakpointId() { m_majorPart = m_minorPart = 0; }
-    explicit BreakpointId(quint16 ma) { m_majorPart = ma; m_minorPart = 0; }
-    BreakpointId(quint16 ma, quint16 mi) { m_majorPart = ma; m_minorPart = mi; }
-    explicit BreakpointId(const QByteArray &ba); // "21.2"
+    BreakpointModelId() { m_majorPart = m_minorPart = 0; }
+    explicit BreakpointModelId(quint16 ma) { m_majorPart = ma; m_minorPart = 0; }
+    BreakpointModelId(quint16 ma, quint16 mi) { m_majorPart = ma; m_minorPart = mi; }
+    explicit BreakpointModelId(const QByteArray &ba); // "21.2"
 
     bool isValid() const { return m_majorPart != 0; }
     bool isMajor() const { return m_majorPart != 0 && m_minorPart == 0; }
@@ -57,22 +63,60 @@ public:
     quint32 toInternalId() const { return m_majorPart | (m_minorPart << 16); }
     QByteArray toByteArray() const;
     QString toString() const;
-    bool operator==(const BreakpointId &id) const
+    bool operator==(const BreakpointModelId &id) const
         { return m_majorPart == id.m_majorPart && m_minorPart == id.m_minorPart; }
     quint16 majorPart() const { return m_majorPart; }
     quint16 minorPart() const { return m_minorPart; }
-    BreakpointId parent() const;
-    BreakpointId child(int row) const;
+    BreakpointModelId parent() const;
+    BreakpointModelId child(int row) const;
+
+    static BreakpointModelId fromInternalId(quint32 id)
+        { return BreakpointModelId(id & 0xff, id >> 16); }
+
+private:
+    quint16 m_majorPart;
+    quint16 m_minorPart;
+};
+
+QDebug operator<<(QDebug d, const BreakpointModelId &id);
+
+
+//////////////////////////////////////////////////////////////////
+//
+// BreakpointResponseId
+//
+//////////////////////////////////////////////////////////////////
+
+class BreakpointResponseId
+{
+public:
+    BreakpointResponseId() { m_majorPart = m_minorPart = 0; }
+    explicit BreakpointResponseId(quint16 ma) { m_majorPart = ma; m_minorPart = 0; }
+    BreakpointResponseId(quint16 ma, quint16 mi) { m_majorPart = ma; m_minorPart = mi; }
+    explicit BreakpointResponseId(const QByteArray &ba); // "21.2"
 
-    static BreakpointId fromInternalId(quint32 id)
-        { return BreakpointId(id & 0xff, id >> 16); }
+    bool isValid() const { return m_majorPart != 0; }
+    bool isMajor() const { return m_majorPart != 0 && m_minorPart == 0; }
+    bool isMinor() const { return m_majorPart != 0 && m_minorPart != 0; }
+    bool operator!() const { return !isValid(); }
+    operator const void*() const { return isValid() ? this : 0; }
+    quint32 toInternalId() const { return m_majorPart | (m_minorPart << 16); }
+    QByteArray toByteArray() const;
+    QString toString() const;
+    bool operator==(const BreakpointResponseId &id) const
+        { return m_majorPart == id.m_majorPart && m_minorPart == id.m_minorPart; }
+    quint16 majorPart() const { return m_majorPart; }
+    quint16 minorPart() const { return m_minorPart; }
+    BreakpointResponseId parent() const;
+    BreakpointResponseId child(int row) const;
 
 private:
     quint16 m_majorPart;
     quint16 m_minorPart;
 };
 
-QDebug operator<<(QDebug d, const BreakpointId &id);
+QDebug operator<<(QDebug d, const BreakpointModelId &id);
+QDebug operator<<(QDebug d, const BreakpointResponseId &id);
 
 //////////////////////////////////////////////////////////////////
 //
@@ -197,18 +241,17 @@ public:
 public:
     void fromParameters(const BreakpointParameters &p);
 
-    BreakpointId id;        //!< Breakpoint number assigned by the debugger engine.
-    bool pending;           //!< Breakpoint not fully resolved.
-    int hitCount;           //!< Number of times this has been hit.
-    QString fullName;       //!< Full file name acknowledged by the debugger engine.
-    bool multiple;          //!< Happens in constructors/gdb.
-    QByteArray extra;       //!< gdb: <PENDING>, <MULTIPLE>
+    BreakpointResponseId id; //!< Breakpoint number assigned by the debugger engine.
+    bool pending;            //!< Breakpoint not fully resolved.
+    int hitCount;            //!< Number of times this has been hit.
+    QString fullName;        //!< Full file name acknowledged by the debugger engine.
+    bool multiple;           //!< Happens in constructors/gdb.
     int correctedLineNumber; //!< Line number as seen by gdb.
 };
 
-typedef QList<BreakpointId> BreakpointIds;
+typedef QList<BreakpointModelId> BreakpointModelIds;
 
-inline uint qHash(const Debugger::Internal::BreakpointId &id)
+inline uint qHash(const Debugger::Internal::BreakpointModelId &id)
 {
     return id.toInternalId();
 }
@@ -216,7 +259,8 @@ inline uint qHash(const Debugger::Internal::BreakpointId &id)
 } // namespace Internal
 } // namespace Debugger
 
-Q_DECLARE_METATYPE(Debugger::Internal::BreakpointId)
+Q_DECLARE_METATYPE(Debugger::Internal::BreakpointModelId)
+Q_DECLARE_METATYPE(Debugger::Internal::BreakpointResponseId)
 
 
 #endif // DEBUGGER_BREAKPOINT_H

src/plugins/debugger/breakpointmarker.cpp

@@ -46,7 +46,7 @@
 namespace Debugger {
 namespace Internal {
 
-BreakpointMarker::BreakpointMarker(BreakpointId id,
+BreakpointMarker::BreakpointMarker(BreakpointModelId id,
         const QString &fileName, int lineNumber)
   : m_id(id)
 {

src/plugins/debugger/breakpointmarker.h

@@ -46,13 +46,13 @@ class BreakpointMarker : public TextEditor::BaseTextMark
     Q_OBJECT
 
 public:
-    BreakpointMarker(BreakpointId id, const QString &fileName, int lineNumber);
+    BreakpointMarker(BreakpointModelId id, const QString &fileName, int lineNumber);
     ~BreakpointMarker();
     void removedFromEditor();
     void updateLineNumber(int lineNumber);
 
 private:
-    BreakpointId m_id;
+    BreakpointModelId m_id;
     friend class BreakHandler;
 };
 

src/plugins/debugger/breakwindow.cpp

@@ -495,7 +495,7 @@ void BreakWindow::keyPressEvent(QKeyEvent *ev)
         QModelIndexList si = sm->selectedIndexes();
         if (si.isEmpty())
             si.append(currentIndex());
-        const BreakpointIds ids = breakHandler()->findBreakpointsByIndex(si);
+        const BreakpointModelIds ids = breakHandler()->findBreakpointsByIndex(si);
         int row = qMin(model()->rowCount() - ids.size() - 1, currentIndex().row());
         deleteBreakpoints(ids);
         setCurrentIndex(si.at(0).sibling(row, 0));
@@ -512,8 +512,8 @@ void BreakWindow::mouseDoubleClickEvent(QMouseEvent *ev)
 {
     QModelIndex indexUnderMouse = indexAt(ev->pos());
     if (indexUnderMouse.isValid() && indexUnderMouse.column() >= 4) {
-        BreakpointId id = breakHandler()->findBreakpointByIndex(indexUnderMouse);
-        editBreakpoints(BreakpointIds() << id);
+        BreakpointModelId id = breakHandler()->findBreakpointByIndex(indexUnderMouse);
+        editBreakpoints(BreakpointModelIds() << id);
     }
     QTreeView::mouseDoubleClickEvent(ev);
 }
@@ -538,7 +538,7 @@ void BreakWindow::contextMenuEvent(QContextMenuEvent *ev)
         selectedIndices.append(indexUnderMouse);
 
     BreakHandler *handler = breakHandler();
-    BreakpointIds selectedIds = handler->findBreakpointsByIndex(selectedIndices);
+    BreakpointModelIds selectedIds = handler->findBreakpointsByIndex(selectedIndices);
 
     const int rowCount = model()->rowCount();
     unsigned engineCapabilities = AllDebuggerCapabilities;
@@ -554,7 +554,7 @@ void BreakWindow::contextMenuEvent(QContextMenuEvent *ev)
 
     // Delete by file: Find indices of breakpoints of the same file.
     QAction *deleteByFileAction = 0;
-    BreakpointIds breakpointsInFile;
+    BreakpointModelIds breakpointsInFile;
     if (indexUnderMouse.isValid()) {
         const QModelIndex index = indexUnderMouse.sibling(indexUnderMouse.row(), 2);
         const QString file = index.data().toString();
@@ -648,21 +648,21 @@ void BreakWindow::contextMenuEvent(QContextMenuEvent *ev)
         addBreakpoint();
 }
 
-void BreakWindow::setBreakpointsEnabled(const BreakpointIds &ids, bool enabled)
+void BreakWindow::setBreakpointsEnabled(const BreakpointModelIds &ids, bool enabled)
 {
     BreakHandler *handler = breakHandler();
-    foreach (const BreakpointId id, ids)
+    foreach (const BreakpointModelId id, ids)
         handler->setEnabled(id, enabled);
 }
 
-void BreakWindow::deleteBreakpoints(const BreakpointIds &ids)
+void BreakWindow::deleteBreakpoints(const BreakpointModelIds &ids)
 {
     BreakHandler *handler = breakHandler();
-    foreach (const BreakpointId id, ids)
+    foreach (const BreakpointModelId id, ids)
        handler->removeBreakpoint(id);
 }
 
-void BreakWindow::editBreakpoint(BreakpointId id, QWidget *parent)
+void BreakWindow::editBreakpoint(BreakpointModelId id, QWidget *parent)
 {
     BreakpointParameters data = breakHandler()->breakpointData(id);
     unsigned engineCapabilities = AllDebuggerCapabilities;
@@ -684,11 +684,11 @@ void BreakWindow::addBreakpoint()
         breakHandler()->appendBreakpoint(data);
 }
 
-void BreakWindow::editBreakpoints(const BreakpointIds &ids)
+void BreakWindow::editBreakpoints(const BreakpointModelIds &ids)
 {
     QTC_ASSERT(!ids.isEmpty(), return);
 
-    const BreakpointId id = ids.at(0);
+    const BreakpointModelId id = ids.at(0);
 
     if (ids.size() == 1) {
         editBreakpoint(id, this);
@@ -719,17 +719,17 @@ void BreakWindow::editBreakpoints(const BreakpointIds &ids)
             && newThreadSpec == oldThreadSpec)
         return;
 
-    foreach (const BreakpointId id, ids) {
+    foreach (const BreakpointModelId id, ids) {
         handler->setCondition(id, newCondition.toLatin1());
         handler->setIgnoreCount(id, newIgnoreCount);
         handler->setThreadSpec(id, newThreadSpec);
     }
 }
 
-void BreakWindow::associateBreakpoint(const BreakpointIds &ids, int threadId)
+void BreakWindow::associateBreakpoint(const BreakpointModelIds &ids, int threadId)
 {
     BreakHandler *handler = breakHandler();
-    foreach (const BreakpointId id, ids)
+    foreach (const BreakpointModelId id, ids)
         handler->setThreadSpec(id, threadId);
 }
 

src/plugins/debugger/breakwindow.h

@@ -47,7 +47,7 @@ class BreakWindow : public QTreeView
 public:
     explicit BreakWindow(QWidget *parent = 0);
 
-    static void editBreakpoint(BreakpointId id, QWidget *parent);
+    static void editBreakpoint(BreakpointModelId id, QWidget *parent);
     void setModel(QAbstractItemModel *model);
 
 private slots:
@@ -64,11 +64,11 @@ private:
     void keyPressEvent(QKeyEvent *ev);
     void mouseDoubleClickEvent(QMouseEvent *ev);
 
-    void deleteBreakpoints(const BreakpointIds &ids);