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