gdbsupport/observable.h

   1 /* Observers
   2
   3    Copyright (C) 2016-2021 Free Software Foundation, Inc.
   4
   5    This file is part of GDB.
   6
   7    This program is free software; you can redistribute it and/or modify
   8    it under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 3 of the License, or
  10    (at your option) any later version.
  11
  12    This program is distributed in the hope that it will be useful,
  13    but WITHOUT ANY WARRANTY; without even the implied warranty of
  14    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15    GNU General Public License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with this program.  If not, see <http://www.gnu.org/licenses/>.  */
  19
  20 #ifndef COMMON_OBSERVABLE_H
  21 #define COMMON_OBSERVABLE_H
  22
  23 #include <algorithm>
  24 #include <functional>
  25 #include <vector>
  26
  27 namespace gdb
  28 {
  29
  30 namespace observers
  31 {
  32
  33 extern bool observer_debug;
  34
  35 /* An observer is an entity which is interested in being notified
  36    when GDB reaches certain states, or certain events occur in GDB.
  37    The entity being observed is called the observable.  To receive
  38    notifications, the observer attaches a callback to the observable.
  39    One observable can have several observers.
  40
  41    The observer implementation is also currently not reentrant.  In
  42    particular, it is therefore not possible to call the attach or
  43    detach routines during a notification.  */
  44
  45 /* The type of a key that can be passed to attach, which can be passed
  46    to detach to remove associated observers.  Tokens have address
  47    identity, and are thus usually const globals.  */
  48 struct token
  49 {
  50   token () = default;
  51
  52   DISABLE_COPY_AND_ASSIGN (token);
  53 };
  54
  55 template<typename... T>
  56 class observable
  57 {
  58 public:
  59   typedef std::function<void (T...)> func_type;
  60
  61 private:
  62   struct observer
  63   {
  64     observer (const struct token *token, func_type func)
  65       : token (token), func (func)
  66     {}
  67
  68     const struct token *token;
  69     func_type func;
  70   };
  71
  72 public:
  73   explicit observable (const char *name)
  74     : m_name (name)
  75   {
  76   }
  77
  78   DISABLE_COPY_AND_ASSIGN (observable);
  79
  80   /* Attach F as an observer to this observable.  F cannot be
  81      detached.  */
  82   void attach (const func_type &f)
  83   {
  84     m_observers.emplace_back (nullptr, f);
  85   }
  86
  87   /* Attach F as an observer to this observable.  T is a reference to
  88      a token that can be used to later remove F.  */
  89   void attach (const func_type &f, const token &t)
  90   {
  91     m_observers.emplace_back (&t, f);
  92   }
  93
  94   /* Remove observers associated with T from this observable.  T is
  95      the token that was previously passed to any number of "attach"
  96      calls.  */
  97   void detach (const token &t)
  98   {
  99     auto iter = std::remove_if (m_observers.begin (),
 100                                 m_observers.end (),
 101                                 [&] (const observer &o)
 102                                 {
 103                                   return o.token == &t;
 104                                 });
 105
 106     m_observers.erase (iter, m_observers.end ());
 107   }
 108
 109   /* Notify all observers that are attached to this observable.  */
 110   void notify (T... args) const
 111   {
 112     if (observer_debug)
 113       fprintf_unfiltered (gdb_stdlog, "observable %s notify() called\n",
 114                           m_name);
 115     for (auto &&e : m_observers)
 116       e.func (args...);
 117   }
 118
 119 private:
 120
 121   std::vector<observer> m_observers;
 122   const char *m_name;
 123 };
 124
 125 } /* namespace observers */
 126
 127 } /* namespace gdb */
 128
 129 #endif /* COMMON_OBSERVABLE_H */