Listener.h

Go to the documentation of this file.

//===-- Listener.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_UTILITY_LISTENER_H
#define LLDB_UTILITY_LISTENER_H
 
#include "lldb/Utility/Broadcaster.h"
#include "lldb/Utility/Timeout.h"
#include "lldb/lldb-defines.h"
#include "lldb/lldb-forward.h"
 
#include <condition_variable>
#include <list>
#include <map>
#include <memory>
#include <mutex>
#include <ratio>
#include <string>
#include <vector>
 
#include <cstddef>
#include <cstdint>
 
namespace lldb_private {
class Event;
}
 
namespace lldb_private {
 
class Listener : public std::enable_shared_from_this<Listener> {
public:
  typedef bool (*HandleBroadcastCallback)(lldb::EventSP &event_sp, void *baton);
 
  friend class Broadcaster;
  friend class BroadcasterManager;
 
  // Constructors and Destructors
  //
  // Listeners have to be constructed into shared pointers - at least if you
  // want them to listen to Broadcasters,
protected:
  Listener(const char *name);
 
public:
  static lldb::ListenerSP MakeListener(const char *name);
 
  ~Listener();
 
  void AddEvent(lldb::EventSP &event);
 
  void Clear();
 
  const char *GetName() { return m_name.c_str(); }
 
  uint32_t
  StartListeningForEventSpec(const lldb::BroadcasterManagerSP &manager_sp,
                             const BroadcastEventSpec &event_spec);
 
  bool StopListeningForEventSpec(const lldb::BroadcasterManagerSP &manager_sp,
                                 const BroadcastEventSpec &event_spec);
 
  uint32_t StartListeningForEvents(Broadcaster *broadcaster,
                                   uint32_t event_mask);
 
  uint32_t StartListeningForEvents(Broadcaster *broadcaster,
                                   uint32_t event_mask,
                                   HandleBroadcastCallback callback,
                                   void *callback_user_data);
 
  bool StopListeningForEvents(Broadcaster *broadcaster, uint32_t event_mask);
 
  Event *PeekAtNextEvent();
 
  Event *PeekAtNextEventForBroadcaster(Broadcaster *broadcaster);
 
  Event *PeekAtNextEventForBroadcasterWithType(Broadcaster *broadcaster,
                                               uint32_t event_type_mask);
 
  // Returns true if an event was received, false if we timed out.
  bool GetEvent(lldb::EventSP &event_sp, const Timeout<std::micro> &timeout);
 
  bool GetEventForBroadcaster(Broadcaster *broadcaster, lldb::EventSP &event_sp,
                              const Timeout<std::micro> &timeout);
 
  bool GetEventForBroadcasterWithType(Broadcaster *broadcaster,
                                      uint32_t event_type_mask,
                                      lldb::EventSP &event_sp,
                                      const Timeout<std::micro> &timeout);
 
  size_t HandleBroadcastEvent(lldb::EventSP &event_sp);
 
  void SetShadow(bool is_shadow) { m_is_shadow = is_shadow; }
 
private:
  // Classes that inherit from Listener can see and modify these
  struct BroadcasterInfo {
    BroadcasterInfo(uint32_t mask, HandleBroadcastCallback cb = nullptr,
                    void *ud = nullptr)
        : event_mask(mask), callback(cb), callback_user_data(ud) {}
 
    uint32_t event_mask;
    HandleBroadcastCallback callback;
    void *callback_user_data;
  };
 
  typedef std::multimap<Broadcaster::BroadcasterImplWP, BroadcasterInfo,
                        std::owner_less<Broadcaster::BroadcasterImplWP>>
      broadcaster_collection;
  typedef std::list<lldb::EventSP> event_collection;
  typedef std::vector<lldb::BroadcasterManagerWP>
      broadcaster_manager_collection;
 
  bool
  FindNextEventInternal(std::unique_lock<std::mutex> &lock,
                        Broadcaster *broadcaster, // nullptr for any broadcaster
                        uint32_t event_type_mask, lldb::EventSP &event_sp,
                        bool remove);
 
  bool GetEventInternal(const Timeout<std::micro> &timeout,
                        Broadcaster *broadcaster, // nullptr for any broadcaster
                        uint32_t event_type_mask, lldb::EventSP &event_sp);
 
  std::string m_name;
  broadcaster_collection m_broadcasters;
  std::recursive_mutex m_broadcasters_mutex; // Protects m_broadcasters
  event_collection m_events;
  std::mutex m_events_mutex; // Protects m_broadcasters and m_events
  std::condition_variable m_events_condition;
  broadcaster_manager_collection m_broadcaster_managers;
  bool m_is_shadow = false;
 
  void BroadcasterWillDestruct(Broadcaster *);
 
  void BroadcasterManagerWillDestruct(lldb::BroadcasterManagerSP manager_sp);
 
  //    broadcaster_collection::iterator
  //    FindBroadcasterWithMask (Broadcaster *broadcaster,
  //                             uint32_t event_mask,
  //                             bool exact);
 
  // For Listener only
  Listener(const Listener &) = delete;
  const Listener &operator=(const Listener &) = delete;
};
 
} // namespace lldb_private
 
#endif // LLDB_UTILITY_LISTENER_H