242 lines
7.4 KiB
C++
242 lines
7.4 KiB
C++
/* Observers
|
|
|
|
Copyright (C) 2016-2022 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>
|
|
|
|
/* Print an "observer" debug statement. */
|
|
|
|
#define observer_debug_printf(fmt, ...) \
|
|
debug_prefixed_printf_cond (observer_debug, "observer", fmt, ##__VA_ARGS__)
|
|
|
|
/* Print "observer" start/end debug statements. */
|
|
|
|
#define OBSERVER_SCOPED_DEBUG_START_END(fmt, ...) \
|
|
scoped_debug_start_end (observer_debug, "observer", fmt, ##__VA_ARGS__)
|
|
|
|
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,
|
|
const std::vector<const struct token *> &dependencies)
|
|
: token (token), func (func), name (name), dependencies (dependencies)
|
|
{}
|
|
|
|
const struct token *token;
|
|
func_type func;
|
|
const char *name;
|
|
std::vector<const struct token *> dependencies;
|
|
};
|
|
|
|
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 or
|
|
specified as a dependency.
|
|
|
|
DEPENDENCIES is a list of tokens of observers to be notified before this
|
|
one.
|
|
|
|
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,
|
|
const std::vector<const struct token *> &dependencies = {})
|
|
{
|
|
attach (f, nullptr, name, dependencies);
|
|
}
|
|
|
|
/* Attach F as an observer to this observable.
|
|
|
|
T is a reference to a token that can be used to later remove F or specify F
|
|
as a dependency of another observer.
|
|
|
|
DEPENDENCIES is a list of tokens of observers to be notified before this
|
|
one.
|
|
|
|
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,
|
|
const std::vector<const struct token *> &dependencies = {})
|
|
{
|
|
attach (f, &t, name, dependencies);
|
|
}
|
|
|
|
/* 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;
|
|
});
|
|
|
|
observer_debug_printf ("Detaching observable %s from observer %s",
|
|
iter->name, m_name);
|
|
|
|
m_observers.erase (iter, m_observers.end ());
|
|
}
|
|
|
|
/* Notify all observers that are attached to this observable. */
|
|
void notify (T... args) const
|
|
{
|
|
OBSERVER_SCOPED_DEBUG_START_END ("observable %s notify() called", m_name);
|
|
|
|
for (auto &&e : m_observers)
|
|
{
|
|
OBSERVER_SCOPED_DEBUG_START_END ("calling observer %s of observable %s",
|
|
e.name, m_name);
|
|
e.func (args...);
|
|
}
|
|
}
|
|
|
|
private:
|
|
|
|
std::vector<observer> m_observers;
|
|
const char *m_name;
|
|
|
|
/* Use for sorting algorithm, to indicate which observer we have visited. */
|
|
enum class visit_state
|
|
{
|
|
NOT_VISITED,
|
|
VISITING,
|
|
VISITED,
|
|
};
|
|
|
|
/* Helper method for topological sort using depth-first search algorithm.
|
|
|
|
Visit all dependencies of observer at INDEX in M_OBSERVERS (later referred
|
|
to as "the observer"). Then append the observer to SORTED_OBSERVERS.
|
|
|
|
If the observer is already visited, do nothing. */
|
|
void visit_for_sorting (std::vector<observer> &sorted_observers,
|
|
std::vector<visit_state> &visit_states, int index)
|
|
{
|
|
if (visit_states[index] == visit_state::VISITED)
|
|
return;
|
|
|
|
/* If we are already visiting this observer, it means there's a cycle. */
|
|
gdb_assert (visit_states[index] != visit_state::VISITING);
|
|
|
|
visit_states[index] = visit_state::VISITING;
|
|
|
|
/* For each dependency of this observer... */
|
|
for (const token *dep : m_observers[index].dependencies)
|
|
{
|
|
/* ... find the observer that has token DEP. If found, visit it. */
|
|
auto it_dep
|
|
= std::find_if (m_observers.begin (), m_observers.end (),
|
|
[&] (observer o) { return o.token == dep; });
|
|
if (it_dep != m_observers.end ())
|
|
{
|
|
int i = std::distance (m_observers.begin (), it_dep);
|
|
visit_for_sorting (sorted_observers, visit_states, i);
|
|
}
|
|
}
|
|
|
|
visit_states[index] = visit_state::VISITED;
|
|
sorted_observers.push_back (m_observers[index]);
|
|
}
|
|
|
|
/* Sort the observers, so that dependencies come before observers
|
|
depending on them.
|
|
|
|
Uses depth-first search algorithm for topological sorting, see
|
|
https://en.wikipedia.org/wiki/Topological_sorting#Depth-first_search . */
|
|
void sort_observers ()
|
|
{
|
|
std::vector<observer> sorted_observers;
|
|
std::vector<visit_state> visit_states (m_observers.size (),
|
|
visit_state::NOT_VISITED);
|
|
|
|
for (size_t i = 0; i < m_observers.size (); i++)
|
|
visit_for_sorting (sorted_observers, visit_states, i);
|
|
|
|
m_observers = std::move (sorted_observers);
|
|
}
|
|
|
|
void attach (const func_type &f, const token *t, const char *name,
|
|
const std::vector<const struct token *> &dependencies)
|
|
{
|
|
|
|
observer_debug_printf ("Attaching observable %s to observer %s",
|
|
name, m_name);
|
|
|
|
m_observers.emplace_back (t, f, name, dependencies);
|
|
|
|
/* The observer has been inserted at the end of the vector, so it will be
|
|
after any of its potential dependencies attached earlier. If the
|
|
observer has a token, it means that other observers can specify it as
|
|
a dependency, so sorting is necessary to ensure those will be after the
|
|
newly inserted observer afterwards. */
|
|
if (t != nullptr)
|
|
sort_observers ();
|
|
};
|
|
};
|
|
|
|
} /* namespace observers */
|
|
|
|
} /* namespace gdb */
|
|
|
|
#endif /* COMMON_OBSERVABLE_H */
|