[lldb] Make WatchpointList iterable

[mgorny]

Summary

Based on de448c0a9e5088979526e2e67152fe547ae4ccf0.

[mgorny]

lldb/include/lldb/Breakpoint/WatchpointList.h

193

NB: I needed to make a const variant since it's used in some const context (below). However, it doesn't seem that a non-const variant is needed at all but this is above my pay grade ;-).

[JDevlieghere]

LGTM. Thanks!

lldb/include/lldb/Breakpoint/WatchpointList.h

193

Haha :-D

lldb/include/lldb/Breakpoint/WatchpointList.h

 //===-- WatchpointList.h ----------------------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_BREAKPOINT_WATCHPOINTLIST_H
 #define LLDB_BREAKPOINT_WATCHPOINTLIST_H
 
 #include <list>
 #include <mutex>
 #include <vector>
 
 #include "lldb/Core/Address.h"
+#include "lldb/Utility/Iterable.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
 /// \class WatchpointList WatchpointList.h "lldb/Breakpoint/WatchpointList.h"
 /// This class is used by Watchpoint to manage a list of watchpoints,
 //  each watchpoint in the list has a unique ID, and is unique by Address as
 //  well.
 
 class WatchpointList {
   // Only Target can make the watchpoint list, or add elements to it. This is
   // not just some random collection of watchpoints.  Rather, the act of adding
   // the watchpoint to this list sets its ID.
   friend class Watchpoint;
   friend class Target;
 
 public:
   /// Default constructor makes an empty list.
   WatchpointList();
 
   /// Destructor, currently does nothing.
   ~WatchpointList();
 
+  typedef std::list<lldb::WatchpointSP> wp_collection;
+  typedef LockingAdaptedIterable<wp_collection, lldb::WatchpointSP,
+                                 vector_adapter, std::recursive_mutex>
+      WatchpointIterable;
+
   /// Add a Watchpoint to the list.
   ///
   /// \param[in] wp_sp
   ///    A shared pointer to a watchpoint being added to the list.
   ///
   /// \return
   ///    The ID of the Watchpoint in the list.
   lldb::watch_id_t Add(const lldb::WatchpointSP &wp_sp, bool notify);
public:
   void RemoveAll(bool notify);
 
   /// Sets the passed in Locker to hold the Watchpoint List mutex.
   ///
   /// \param[in] lock
   ///   The locker object that is set.
   void GetListMutex(std::unique_lock<std::recursive_mutex> &lock);
 
+  WatchpointIterable Watchpoints() const {
+    return WatchpointIterable(m_watchpoints, m_mutex);
+  }
+
 protected:
-  typedef std::list<lldb::WatchpointSP> wp_collection;
   typedef std::vector<lldb::watch_id_t> id_vector;
 
   id_vector GetWatchpointIDs() const;
 
   wp_collection::iterator GetIDIterator(lldb::watch_id_t watchID);
 
   wp_collection::const_iterator
   GetIDConstIterator(lldb::watch_id_t watchID) const;

lldb/source/Commands/CommandCompletions.cpp

 void CommandCompletions::WatchPointIDs(CommandInterpreter &interpreter,
                                        CompletionRequest &request,
                                        SearchFilter *searcher) {
   const ExecutionContext &exe_ctx = interpreter.GetExecutionContext();
   if (!exe_ctx.HasTargetScope())
     return;
 
   const WatchpointList &wp_list = exe_ctx.GetTargetPtr()->GetWatchpointList();
-  const size_t wp_num = wp_list.GetSize();
-  for (size_t idx = 0; idx < wp_num; ++idx) {
-    const lldb::WatchpointSP wp_sp = wp_list.GetByIndex(idx);
+  for (lldb::WatchpointSP wp_sp : wp_list.Watchpoints()) {
     StreamString strm;
     wp_sp->Dump(&strm);
     request.TryCompleteCurrentArg(std::to_string(wp_sp->GetID()),
                                   strm.GetString());
   }
 }
 
 void CommandCompletions::TypeCategoryNames(CommandInterpreter &interpreter,

lldb/source/Target/Target.cpp

if (!end_to_end) {
     return true;
   }
 
   // Otherwise, it's an end to end operation.
 
   if (!ProcessIsValid())
     return false;
 
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
+  for (WatchpointSP wp_sp : m_watchpoint_list.Watchpoints()) {
     if (!wp_sp)
       return false;
 
     Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
     if (rc.Fail())
       return false;
   }
   m_watchpoint_list.RemoveAll(true);
bool Target::DisableAllWatchpoints(bool end_to_end) {
   }
 
   // Otherwise, it's an end to end operation.
 
   if (!ProcessIsValid())
     return false;
 
   size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
+  for (WatchpointSP wp_sp : m_watchpoint_list.Watchpoints()) {
     if (!wp_sp)
       return false;
 
     Status rc = m_process_sp->DisableWatchpoint(wp_sp.get());
     if (rc.Fail())
       return false;
   }
   return true; // Success!
if (!end_to_end) {
     return true;
   }
 
   // Otherwise, it's an end to end operation.
 
   if (!ProcessIsValid())
     return false;
 
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
+  for (WatchpointSP wp_sp : m_watchpoint_list.Watchpoints()) {
     if (!wp_sp)
       return false;
 
     Status rc = m_process_sp->EnableWatchpoint(wp_sp.get());
     if (rc.Fail())
       return false;
   }
   return true; // Success!
 }
 
 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
 bool Target::ClearAllWatchpointHitCounts() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   LLDB_LOGF(log, "Target::%s\n", __FUNCTION__);
 
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
+  for (WatchpointSP wp_sp : m_watchpoint_list.Watchpoints()) {
     if (!wp_sp)
       return false;
 
     wp_sp->ResetHitCount();
   }
   return true; // Success!
 }
 
 // Assumption: Caller holds the list mutex lock for m_watchpoint_list.
 bool Target::ClearAllWatchpointHistoricValues() {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   LLDB_LOGF(log, "Target::%s\n", __FUNCTION__);
 
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
+  for (WatchpointSP wp_sp : m_watchpoint_list.Watchpoints()) {
     if (!wp_sp)
       return false;
 
     wp_sp->ResetHistoricValues();
   }
   return true; // Success!
 }
 
 // Assumption: Caller holds the list mutex lock for m_watchpoint_list during
 // these operations.
 bool Target::IgnoreAllWatchpoints(uint32_t ignore_count) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_WATCHPOINTS));
   LLDB_LOGF(log, "Target::%s\n", __FUNCTION__);
 
   if (!ProcessIsValid())
     return false;
 
-  size_t num_watchpoints = m_watchpoint_list.GetSize();
-  for (size_t i = 0; i < num_watchpoints; ++i) {
-    WatchpointSP wp_sp = m_watchpoint_list.GetByIndex(i);
+  for (WatchpointSP wp_sp : m_watchpoint_list.Watchpoints()) {
     if (!wp_sp)
       return false;
 
     wp_sp->SetIgnoreCount(ignore_count);
   }
   return true; // Success!
 }