1 /* Observers 2 3 Copyright (C) 2016-2020 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 unsigned int 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 60 typedef std::function<void (T...)> func_type; 61 62 explicit observable (const char *name) 63 : m_name (name) 64 { 65 } 66 67 DISABLE_COPY_AND_ASSIGN (observable); 68 69 /* Attach F as an observer to this observable. F cannot be 70 detached. */ 71 void attach (const func_type &f) 72 { 73 m_observers.emplace_back (nullptr, f); 74 } 75 76 /* Attach F as an observer to this observable. T is a reference to 77 a token that can be used to later remove F. */ 78 void attach (const func_type &f, const token &t) 79 { 80 m_observers.emplace_back (&t, f); 81 } 82 83 /* Remove observers associated with T from this observable. T is 84 the token that was previously passed to any number of "attach" 85 calls. */ 86 void detach (const token &t) 87 { 88 auto iter = std::remove_if (m_observers.begin (), 89 m_observers.end (), 90 [&] (const std::pair<const token *, 91 func_type> &e) 92 { 93 return e.first == &t; 94 }); 95 96 m_observers.erase (iter, m_observers.end ()); 97 } 98 99 /* Notify all observers that are attached to this observable. */ 100 void notify (T... args) const 101 { 102 if (observer_debug) 103 fprintf_unfiltered (gdb_stdlog, "observable %s notify() called\n", 104 m_name); 105 for (auto &&e : m_observers) 106 e.second (args...); 107 } 108 109 private: 110 111 std::vector<std::pair<const token *, func_type>> m_observers; 112 const char *m_name; 113 }; 114 115 } /* namespace observers */ 116 117 } /* namespace gdb */ 118 119 #endif /* COMMON_OBSERVABLE_H */ 120