summaryrefslogtreecommitdiff
path: root/src/core/managed
diff options
context:
space:
mode:
Diffstat (limited to 'src/core/managed')
-rw-r--r--src/core/managed/Managed.cpp29
-rw-r--r--src/core/managed/Managed.hpp22
-rw-r--r--src/core/managed/Manager.cpp36
-rw-r--r--src/core/managed/Manager.hpp23
4 files changed, 88 insertions, 22 deletions
diff --git a/src/core/managed/Managed.cpp b/src/core/managed/Managed.cpp
index d9db0e0..341e0d0 100644
--- a/src/core/managed/Managed.cpp
+++ b/src/core/managed/Managed.cpp
@@ -28,7 +28,8 @@ namespace ousia {
/* Class Managed */
-void Managed::storeData(const std::string &key, Handle<Managed> h) {
+void Managed::storeData(const std::string &key, Handle<Managed> h)
+{
mgr.storeData(this, key, h.get());
}
@@ -37,11 +38,13 @@ bool Managed::hasDataKey(const std::string &key)
return mgr.readData(this, key) != nullptr;
}
-Rooted<Managed> Managed::readData(const std::string &key) {
+Rooted<Managed> Managed::readData(const std::string &key)
+{
return mgr.readData(this, key);
}
-std::map<std::string, Rooted<Managed>> Managed::readData() {
+std::map<std::string, Rooted<Managed>> Managed::readData()
+{
auto map = mgr.readData(this);
std::map<std::string, Rooted<Managed>> res;
for (auto e : map) {
@@ -50,14 +53,15 @@ std::map<std::string, Rooted<Managed>> Managed::readData() {
return res;
}
-bool Managed::deleteData(const std::string &key) {
+bool Managed::deleteData(const std::string &key)
+{
return mgr.deleteData(this, key);
}
EventId Managed::registerEvent(EventType type, EventHandler handler,
- Handle<Managed> owner)
+ Handle<Managed> owner, void *data)
{
- return mgr.registerEvent(this, type, handler, owner.get());
+ return mgr.registerEvent(this, type, handler, owner.get(), data);
}
bool Managed::unregisterEvent(EventId id)
@@ -65,16 +69,15 @@ bool Managed::unregisterEvent(EventId id)
return mgr.unregisterEvent(this, id);
}
-bool Managed::triggerEvent(Event &data)
+bool Managed::unregisterEvent(EventType type, EventHandler handler,
+ Handle<Managed> owner, void *data)
{
- return mgr.triggerEvent(this, data);
+ return mgr.unregisterEvent(this, type, handler, owner.get(), data);
}
-const RttiBase &Managed::type() const
-{
- return typeOf(*this);
-}
+bool Managed::triggerEvent(Event &ev) { return mgr.triggerEvent(this, ev); }
-bool Managed::isa(const RttiBase &t) const { return type().isa(t); }
+const RttiBase &Managed::type() const { return typeOf(*this); }
+bool Managed::isa(const RttiBase &t) const { return type().isa(t); }
}
diff --git a/src/core/managed/Managed.hpp b/src/core/managed/Managed.hpp
index 4a38dbd..cdf81aa 100644
--- a/src/core/managed/Managed.hpp
+++ b/src/core/managed/Managed.hpp
@@ -146,11 +146,29 @@ public:
* from the the reference object to the owner is added. The argument may be
* nullptr in which case no reference is added. The owner is passed to the
* event handler as second parameter.
+ * @param data is some user defined data.
* @return a numeric event id, which is unique for the given reference
* object. The event id must be used when unregistering event handlers.
*/
EventId registerEvent(EventType type, EventHandler handler,
- Handle<Managed> owner);
+ Handle<Managed> owner,
+ void *data = nullptr);
+
+ /**
+ * Unregisters the event handler with the given signature.
+ *
+ * @param type is the event type that should be registered.
+ * @param handler is the callback function.
+ * @param owner is a managed object that owns the event handler. A reference
+ * from the the reference object to the owner is added. The argument may be
+ * nullptr in which case no reference is added. The owner is passed to the
+ * event handler as second parameter.
+ * @param data is some user defined data.
+ * @return a numeric event id, which is unique for the given reference
+ * object. The event id must be used when unregistering event handlers.
+ */
+ bool unregisterEvent(EventType type, EventHandler handler,
+ Handle<Managed> owner, void *data = nullptr);
/**
* Unregisters the event with the given event id.
@@ -167,7 +185,7 @@ public:
*
* @param data is the event data that should be passed to the handlers.
*/
- bool triggerEvent(Event &data);
+ bool triggerEvent(Event &ev);
/* RTTI methods */
diff --git a/src/core/managed/Manager.cpp b/src/core/managed/Manager.cpp
index 94eb1b1..c53f6b8 100644
--- a/src/core/managed/Manager.cpp
+++ b/src/core/managed/Manager.cpp
@@ -447,7 +447,7 @@ bool Manager::deleteData(Managed *ref, const std::string &key)
/* Class Manager: Event handling */
EventId Manager::registerEvent(Managed *ref, EventType type,
- EventHandler handler, Managed *owner)
+ EventHandler handler, Managed *owner, void *data)
{
// Add a reference from the reference object to the owner object
if (owner) {
@@ -457,7 +457,7 @@ EventId Manager::registerEvent(Managed *ref, EventType type,
// Create a event handler descriptor and store it along with the
auto &vec = events.emplace(ref, std::vector<EventHandlerDescriptor>{})
.first->second;
- const EventHandlerDescriptor descr(type, handler, owner);
+ const EventHandlerDescriptor descr(type, handler, owner, data);
for (size_t i = 0; i < vec.size(); i++) {
if (!vec[i].handler) {
vec[i] = descr;
@@ -490,14 +490,40 @@ bool Manager::unregisterEvent(Managed *ref, EventId id)
return false;
}
-bool Manager::triggerEvent(Managed *ref, Event &data)
+bool Manager::unregisterEvent(Managed *ref, EventType type,
+ EventHandler handler, Managed *owner, void *data)
+{
+ auto eventsIt = events.find(ref);
+ if (eventsIt != events.end()) {
+ auto &vec = eventsIt->second;
+ for (EventHandlerDescriptor &descr : vec) {
+ if (descr.type == type && descr.handler == handler &&
+ descr.owner == owner && descr.data == data) {
+ // Delete the reference from the reference object to the handler
+ if (descr.owner) {
+ deleteRef(descr.owner, ref);
+ }
+
+ // Remove the handler from the list by resetting handler and
+ // owner to nullptr
+ descr.handler = nullptr;
+ descr.owner = nullptr;
+ return true;
+ }
+ }
+ }
+ return false;
+}
+
+bool Manager::triggerEvent(Managed *ref, Event &ev)
{
bool hasHandler = false;
auto eventsIt = events.find(ref);
if (eventsIt != events.end()) {
for (EventHandlerDescriptor &descr : eventsIt->second) {
- if (descr.type == data.type && descr.handler) {
- descr.handler(data, descr.owner);
+ if (descr.type == ev.type && descr.handler) {
+ ev.sender = ref;
+ descr.handler(ev, descr.owner, descr.data);
hasHandler = true;
}
}
diff --git a/src/core/managed/Manager.hpp b/src/core/managed/Manager.hpp
index 0e9d519..3bcf3e8 100644
--- a/src/core/managed/Manager.hpp
+++ b/src/core/managed/Manager.hpp
@@ -325,11 +325,12 @@ public:
* from the the reference object to the owner is added. The argument may be
* nullptr in which case no reference is added. The owner is passed to the
* event handler as second parameter.
+ * @param data is some user defined data.
* @return a numeric event id, which is unique for the given reference
* object. The event id must be used when unregistering event handlers.
*/
EventId registerEvent(Managed *ref, EventType type, EventHandler handler,
- Managed *owner);
+ Managed *owner, void *data);
/**
* Unregisters the event with the given event id from the given reference
@@ -344,12 +345,30 @@ public:
bool unregisterEvent(Managed *ref, EventId id);
/**
+ * Searches for the event with the given signature and removes it.
+ *
+ * @param ref is the reference object for which the event should be
+ * registered.
+ * @param type is the event type that should be registered.
+ * @param handler is the callback function.
+ * @param owner is a managed object that owns the event handler. A reference
+ * from the the reference object to the owner is added. The argument may be
+ * nullptr in which case no reference is added. The owner is passed to the
+ * event handler as second parameter.
+ * @param data is some user defined data.
+ * @return true if the operation was successful, false if either the
+ * reference object or and event with the given signature do not exist.
+ */
+ bool unregisterEvent(Managed *ref, EventType type, EventHandler handler,
+ Managed *owner, void *data);
+
+ /**
* Triggers the event of the given type for the reference object.
*
* @param ref is the object for which the given event should be triggered.
* @param data is the event data that should be passed to the handlers.
*/
- bool triggerEvent(Managed *ref, Event &data);
+ bool triggerEvent(Managed *ref, Event &ev);
};
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-30 17:32:27 +0000