1 files changed, 56 insertions, 117 deletions

diff --git a/source/Breakpoint/BreakpointList.cpp b/source/Breakpoint/BreakpointList.cpp
index 4a49b1e105ab..370da10d82b4 100644
--- a/source/Breakpoint/BreakpointList.cpp
+++ b/source/Breakpoint/BreakpointList.cpp
@@ -9,15 +9,18 @@
 
 #include "lldb/Breakpoint/BreakpointList.h"
 
-// C Includes
-// C++ Includes
-// Other libraries and framework includes
-// Project includes
 #include "lldb/Target/Target.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+static void NotifyChange(const BreakpointSP &bp, BreakpointEventType event) {
+  Target &target = bp->GetTarget();
+  if (target.EventTypeHasListeners(Target::eBroadcastBitBreakpointChanged))
+    target.BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
+                          new Breakpoint::BreakpointEventData(event, bp));
+}
+
 BreakpointList::BreakpointList(bool is_internal)
     : m_mutex(), m_breakpoints(), m_next_break_id(0),
       m_is_internal(is_internal) {}
@@ -26,37 +29,34 @@ BreakpointList::~BreakpointList() {}
 
 break_id_t BreakpointList::Add(BreakpointSP &bp_sp, bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
+
   // Internal breakpoint IDs are negative, normal ones are positive
   bp_sp->SetID(m_is_internal ? --m_next_break_id : ++m_next_break_id);
 
   m_breakpoints.push_back(bp_sp);
-  if (notify) {
-    if (bp_sp->GetTarget().EventTypeHasListeners(
-            Target::eBroadcastBitBreakpointChanged))
-      bp_sp->GetTarget().BroadcastEvent(Target::eBroadcastBitBreakpointChanged,
-                                        new Breakpoint::BreakpointEventData(
-                                            eBreakpointEventTypeAdded, bp_sp));
-  }
+
+  if (notify)
+    NotifyChange(bp_sp, eBreakpointEventTypeAdded);
+
   return bp_sp->GetID();
 }
 
 bool BreakpointList::Remove(break_id_t break_id, bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  bp_collection::iterator pos = GetBreakpointIDIterator(break_id); // Predicate
-  if (pos != m_breakpoints.end()) {
-    BreakpointSP bp_sp(*pos);
-    m_breakpoints.erase(pos);
-    if (notify) {
-      if (bp_sp->GetTarget().EventTypeHasListeners(
-              Target::eBroadcastBitBreakpointChanged))
-        bp_sp->GetTarget().BroadcastEvent(
-            Target::eBroadcastBitBreakpointChanged,
-            new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
-                                                bp_sp));
-    }
-    return true;
-  }
-  return false;
+
+  auto it = std::find_if(
+      m_breakpoints.begin(), m_breakpoints.end(),
+      [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
+
+  if (it == m_breakpoints.end())
+    return false;
+
+  if (notify)
+    NotifyChange(*it, eBreakpointEventTypeRemoved);
+
+  m_breakpoints.erase(it);
+
+  return true;
 }
 
 void BreakpointList::RemoveInvalidLocations(const ArchSpec &arch) {
@@ -83,93 +83,50 @@ void BreakpointList::RemoveAll(bool notify) {
   ClearAllBreakpointSites();
 
   if (notify) {
-    bp_collection::iterator pos, end = m_breakpoints.end();
-    for (pos = m_breakpoints.begin(); pos != end; ++pos) {
-      if ((*pos)->GetTarget().EventTypeHasListeners(
-              Target::eBroadcastBitBreakpointChanged)) {
-        (*pos)->GetTarget().BroadcastEvent(
-            Target::eBroadcastBitBreakpointChanged,
-            new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
-                                                *pos));
-      }
-    }
+    for (const auto &bp_sp : m_breakpoints)
+      NotifyChange(bp_sp, eBreakpointEventTypeRemoved);
   }
-  m_breakpoints.erase(m_breakpoints.begin(), m_breakpoints.end());
+
+  m_breakpoints.clear();
 }
 
 void BreakpointList::RemoveAllowed(bool notify) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
 
-  bp_collection::iterator pos, end = m_breakpoints.end();
-  if (notify) {
-    for (pos = m_breakpoints.begin(); pos != end; ++pos) {
-      if(!(*pos)->AllowDelete())
-        continue;
-      if ((*pos)->GetTarget().EventTypeHasListeners(
-              Target::eBroadcastBitBreakpointChanged)) {
-        (*pos)->GetTarget().BroadcastEvent(
-            Target::eBroadcastBitBreakpointChanged,
-            new Breakpoint::BreakpointEventData(eBreakpointEventTypeRemoved,
-                                                *pos));
-      }
-    }
-  }
-  pos = m_breakpoints.begin();
-  while ( pos != end) {
-    auto bp = *pos;
-    if (bp->AllowDelete()) {
-      bp->ClearAllBreakpointSites();
-      pos = m_breakpoints.erase(pos);
-    } else
-      pos++;
+  for (const auto &bp_sp : m_breakpoints) {
+    if (bp_sp->AllowDelete())
+      bp_sp->ClearAllBreakpointSites();
+    if (notify)
+      NotifyChange(bp_sp, eBreakpointEventTypeRemoved);
   }
-}
-
-class BreakpointIDMatches {
-public:
-  BreakpointIDMatches(break_id_t break_id) : m_break_id(break_id) {}
 
-  bool operator()(const BreakpointSP &bp) const {
-    return m_break_id == bp->GetID();
-  }
-
-private:
-  const break_id_t m_break_id;
-};
+  m_breakpoints.erase(
+      std::remove_if(m_breakpoints.begin(), m_breakpoints.end(),
+                     [&](const BreakpointSP &bp) { return bp->AllowDelete(); }),
+      m_breakpoints.end());
+}
 
 BreakpointList::bp_collection::iterator
 BreakpointList::GetBreakpointIDIterator(break_id_t break_id) {
-  return std::find_if(m_breakpoints.begin(),
-                      m_breakpoints.end(),            // Search full range
-                      BreakpointIDMatches(break_id)); // Predicate
+  return std::find_if(
+      m_breakpoints.begin(), m_breakpoints.end(),
+      [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
 }
 
 BreakpointList::bp_collection::const_iterator
 BreakpointList::GetBreakpointIDConstIterator(break_id_t break_id) const {
-  return std::find_if(m_breakpoints.begin(),
-                      m_breakpoints.end(),            // Search full range
-                      BreakpointIDMatches(break_id)); // Predicate
-}
-
-BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  BreakpointSP stop_sp;
-  bp_collection::iterator pos = GetBreakpointIDIterator(break_id);
-  if (pos != m_breakpoints.end())
-    stop_sp = *pos;
-
-  return stop_sp;
+  return std::find_if(
+      m_breakpoints.begin(), m_breakpoints.end(),
+      [&](const BreakpointSP &bp) { return bp->GetID() == break_id; });
 }
 
-const BreakpointSP
-BreakpointList::FindBreakpointByID(break_id_t break_id) const {
+BreakpointSP BreakpointList::FindBreakpointByID(break_id_t break_id) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  BreakpointSP stop_sp;
-  bp_collection::const_iterator pos = GetBreakpointIDConstIterator(break_id);
-  if (pos != m_breakpoints.end())
-    stop_sp = *pos;
 
-  return stop_sp;
+  auto it = GetBreakpointIDConstIterator(break_id);
+  if (it != m_breakpoints.end())
+    return *it;
+  return {};
 }
 
 bool BreakpointList::FindBreakpointsByName(const char *name,
@@ -186,6 +143,7 @@ bool BreakpointList::FindBreakpointsByName(const char *name,
       matching_bps.Add(bkpt_sp, false);
     }
   }
+
   return true;
 }
 
@@ -201,30 +159,11 @@ void BreakpointList::Dump(Stream *s) const {
   s->IndentLess();
 }
 
-BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) {
+BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) const {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  BreakpointSP stop_sp;
-  bp_collection::iterator end = m_breakpoints.end();
-  bp_collection::iterator pos;
-  size_t curr_i = 0;
-  for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) {
-    if (curr_i == i)
-      stop_sp = *pos;
-  }
-  return stop_sp;
-}
-
-const BreakpointSP BreakpointList::GetBreakpointAtIndex(size_t i) const {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  BreakpointSP stop_sp;
-  bp_collection::const_iterator end = m_breakpoints.end();
-  bp_collection::const_iterator pos;
-  size_t curr_i = 0;
-  for (pos = m_breakpoints.begin(), curr_i = 0; pos != end; ++pos, ++curr_i) {
-    if (curr_i == i)
-      stop_sp = *pos;
-  }
-  return stop_sp;
+  if (i < m_breakpoints.size())
+    return m_breakpoints[i];
+  return {};
 }
 
 void BreakpointList::UpdateBreakpoints(ModuleList &module_list, bool added,