[lldb] Simplify predicates of find_if in BroadcastManager

[bulbazord]

Summary

We had some custom classes that were used as the predicate for
std::find_if. It would be a lot simpler if we used lambdas instead.

[JDevlieghere]

🚢

lldb/include/lldb/Utility/Broadcaster.h

 private:
   typedef std::pair<BroadcastEventSpec, lldb::ListenerSP> event_listener_key;
   typedef std::map<BroadcastEventSpec, lldb::ListenerSP> collection;
   typedef std::set<lldb::ListenerSP> listener_collection;
   collection m_event_map;
   listener_collection m_listeners;
 
   mutable std::recursive_mutex m_manager_mutex;
-
-  // A couple of comparator classes for find_if:
-
-  class BroadcasterClassMatches {
-  public:
-    BroadcasterClassMatches(const ConstString &broadcaster_class)
-        : m_broadcaster_class(broadcaster_class) {}
-
-    ~BroadcasterClassMatches() = default;
-
-    bool operator()(const event_listener_key &input) const {
-      return (input.first.GetBroadcasterClass() == m_broadcaster_class);
-    }
-
-  private:
-    ConstString m_broadcaster_class;
-  };
-
-  class BroadcastEventSpecMatches {
-  public:
-    BroadcastEventSpecMatches(const BroadcastEventSpec &broadcaster_spec)
-        : m_broadcaster_spec(broadcaster_spec) {}
-
-    ~BroadcastEventSpecMatches() = default;
-
-    bool operator()(const event_listener_key &input) const {
-      return (input.first.IsContainedIn(m_broadcaster_spec));
-    }
-
-  private:
-    BroadcastEventSpec m_broadcaster_spec;
-  };
-
-  class ListenerMatchesAndSharedBits {
-  public:
-    explicit ListenerMatchesAndSharedBits(
-        const BroadcastEventSpec &broadcaster_spec,
-        const lldb::ListenerSP &listener_sp)
-        : m_broadcaster_spec(broadcaster_spec), m_listener_sp(listener_sp) {}
-
-    ~ListenerMatchesAndSharedBits() = default;
-
-    bool operator()(const event_listener_key &input) const {
-      return (input.first.GetBroadcasterClass() ==
-                  m_broadcaster_spec.GetBroadcasterClass() &&
-              (input.first.GetEventBits() &
-               m_broadcaster_spec.GetEventBits()) != 0 &&
-              input.second == m_listener_sp);
-    }
-
-  private:
-    BroadcastEventSpec m_broadcaster_spec;
-    const lldb::ListenerSP m_listener_sp;
-  };
-
-  class ListenerMatches {
-  public:
-    explicit ListenerMatches(const lldb::ListenerSP &in_listener_sp)
-        : m_listener_sp(in_listener_sp) {}
-
-    ~ListenerMatches() = default;
-
-    bool operator()(const event_listener_key &input) const {
-      if (input.second == m_listener_sp)
-        return true;
-
-      return false;
-    }
-
-  private:
-    const lldb::ListenerSP m_listener_sp;
-  };
-
-  class ListenerMatchesPointer {
-  public:
-    ListenerMatchesPointer(const Listener *in_listener)
-        : m_listener(in_listener) {}
-
-    ~ListenerMatchesPointer() = default;
-
-    bool operator()(const event_listener_key &input) const {
-      if (input.second.get() == m_listener)
-        return true;
-
-      return false;
-    }
-
-    bool operator()(const lldb::ListenerSP &input) const {
-      if (input.get() == m_listener)
-        return true;
-
-      return false;
-    }
-
-  private:
-    const Listener *m_listener;
-  };
 };
 
 /// \class Broadcaster Broadcaster.h "lldb/Utility/Broadcaster.h" An event
 /// broadcasting class.
 ///
 /// The Broadcaster class is designed to be subclassed by objects that wish to
 /// vend events in a multi-threaded environment. Broadcaster objects can each
 /// vend 32 events. Each event is represented by a bit in a 32 bit value and

lldb/source/Utility/Broadcaster.cpp

 
 uint32_t BroadcasterManager::RegisterListenerForEvents(
     const lldb::ListenerSP &listener_sp, const BroadcastEventSpec &event_spec) {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 
   collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
   uint32_t available_bits = event_spec.GetEventBits();
 
+  auto class_matches = [&event_spec](const event_listener_key &input) -> bool {
+    return input.first.GetBroadcasterClass() ==
+           event_spec.GetBroadcasterClass();
+  };
+
   while (iter != end_iter &&
-         (iter = find_if(iter, end_iter,
-                         BroadcasterClassMatches(
-                             event_spec.GetBroadcasterClass()))) != end_iter) {
+         (iter = find_if(iter, end_iter, class_matches)) != end_iter) {
     available_bits &= ~((*iter).first.GetEventBits());
     iter++;
   }
 
   if (available_bits != 0) {
     m_event_map.insert(event_listener_key(
         BroadcastEventSpec(event_spec.GetBroadcasterClass(), available_bits),
         listener_sp));
     m_listeners.insert(listener_sp);
   }
 
   return available_bits;
 }
 
 bool BroadcasterManager::UnregisterListenerForEvents(
     const lldb::ListenerSP &listener_sp, const BroadcastEventSpec &event_spec) {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
   bool removed_some = false;
 
   if (m_listeners.erase(listener_sp) == 0)
     return false;
 
-  ListenerMatchesAndSharedBits predicate(event_spec, listener_sp);
+  auto listener_matches_and_shared_bits =
+      [&listener_sp, &event_spec](const event_listener_key &input) -> bool {
+    return input.first.GetBroadcasterClass() ==
+               event_spec.GetBroadcasterClass() &&
+           (input.first.GetEventBits() & event_spec.GetEventBits()) != 0 &&
+           input.second == listener_sp;
+  };
   std::vector<BroadcastEventSpec> to_be_readded;
   uint32_t event_bits_to_remove = event_spec.GetEventBits();
 
   // Go through the map and delete the exact matches, and build a list of
   // matches that weren't exact to re-add:
   while (true) {
     collection::iterator iter, end_iter = m_event_map.end();
-    iter = find_if(m_event_map.begin(), end_iter, predicate);
+    iter = find_if(m_event_map.begin(), end_iter,
+                   listener_matches_and_shared_bits);
     if (iter == end_iter) {
       break;
     }
     uint32_t iter_event_bits = (*iter).first.GetEventBits();
     removed_some = true;
 
     if (event_bits_to_remove != iter_event_bits) {
       uint32_t new_event_bits = iter_event_bits & ~event_bits_to_remove;
bool BroadcasterManager::UnregisterListenerForEvents(
 
   return removed_some;
 }
 
 ListenerSP BroadcasterManager::GetListenerForEventSpec(
     const BroadcastEventSpec &event_spec) const {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 
+  auto event_spec_matches =
+      [&event_spec](const event_listener_key &input) -> bool {
+    return input.first.IsContainedIn(event_spec);
+  };
+
   collection::const_iterator iter, end_iter = m_event_map.end();
-  iter = find_if(m_event_map.begin(), end_iter,
-                 BroadcastEventSpecMatches(event_spec));
+  iter = find_if(m_event_map.begin(), end_iter, event_spec_matches);
   if (iter != end_iter)
     return (*iter).second;
 
   return nullptr;
 }
 
 void BroadcasterManager::RemoveListener(Listener *listener) {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
-  ListenerMatchesPointer predicate(listener);
+  auto listeners_predicate =
+      [&listener](const lldb::ListenerSP &input) -> bool {
+    return input.get() == listener;
+  };
+
   listener_collection::iterator iter = m_listeners.begin(),
                                 end_iter = m_listeners.end();
 
-  iter = std::find_if(iter, end_iter, predicate);
+  iter = std::find_if(iter, end_iter, listeners_predicate);
   if (iter != end_iter)
     m_listeners.erase(iter);
 
   while (true) {
+    auto events_predicate =
+        [&listener](const event_listener_key &input) -> bool {
+      return input.second.get() == listener;
+    };
     collection::iterator iter, end_iter = m_event_map.end();
-    iter = find_if(m_event_map.begin(), end_iter, predicate);
+    iter = find_if(m_event_map.begin(), end_iter, events_predicate);
     if (iter == end_iter)
       break;
 
     m_event_map.erase(iter);
   }
 }
 
 void BroadcasterManager::RemoveListener(const lldb::ListenerSP &listener_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
-  ListenerMatches predicate(listener_sp);
+
+  auto listener_matches =
+      [&listener_sp](const event_listener_key &input) -> bool {
+    return input.second == listener_sp;
+  };
 
   if (m_listeners.erase(listener_sp) == 0)
     return;
 
   while (true) {
     collection::iterator iter, end_iter = m_event_map.end();
-    iter = find_if(m_event_map.begin(), end_iter, predicate);
+    iter = find_if(m_event_map.begin(), end_iter, listener_matches);
     if (iter == end_iter)
       break;
 
     m_event_map.erase(iter);
   }
 }
 
 void BroadcasterManager::SignUpListenersForBroadcaster(
     Broadcaster &broadcaster) {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
 
   collection::iterator iter = m_event_map.begin(), end_iter = m_event_map.end();
 
+  auto class_matches = [&broadcaster](const event_listener_key &input) -> bool {
+    return input.first.GetBroadcasterClass() ==
+           broadcaster.GetBroadcasterClass();
+  };
+
   while (iter != end_iter &&
-         (iter = find_if(iter, end_iter,
-                         BroadcasterClassMatches(
-                             broadcaster.GetBroadcasterClass()))) != end_iter) {
+         (iter = find_if(iter, end_iter, class_matches)) != end_iter) {
     (*iter).second->StartListeningForEvents(&broadcaster,
                                             (*iter).first.GetEventBits());
     iter++;
   }
 }
 
 void BroadcasterManager::Clear() {
   std::lock_guard<std::recursive_mutex> guard(m_manager_mutex);
   listener_collection::iterator end_iter = m_listeners.end();
 
   for (listener_collection::iterator iter = m_listeners.begin();
        iter != end_iter; iter++)
     (*iter)->BroadcasterManagerWillDestruct(this->shared_from_this());
   m_listeners.clear();
   m_event_map.clear();
 }