libcamera: Add signal/slot communication mechanism

Introduce a Signal class that allows connecting event sources (signals)
to event listeners (slots) without adding any boilerplate code usually
associated with the observer or listener design patterns.

Signed-off-by: Laurent Pinchart <laurent.pinchart@ideasonboard.com>
Reviewed-by: Niklas Söderlund <niklas.soderlund@ragnatech.se>
Reviewed-by: Jacopo Mondi <jacopo@jmondi.org>

5 files changed, 243 insertions, 1 deletions

diff --git a/Documentation/Doxyfile.in b/Documentation/Doxyfile.in
index 335664db..5c0d87ba 100644
--- a/Documentation/Doxyfile.in
+++ b/Documentation/Doxyfile.in
@@ -860,7 +860,9 @@ EXCLUDE_PATTERNS       =
 # Note that the wildcards are matched against the file with absolute path, so to
 # exclude all test directories use the pattern */test/*
 
-EXCLUDE_SYMBOLS        =
+EXCLUDE_SYMBOLS        = libcamera::SlotBase \
+                         libcamera::SlotMember \
+                         libcamera::SlotStatic
 
 # The EXAMPLE_PATH tag can be used to specify one or more files or directories
 # that contain example code fragments that are included (see the \include
diff --git a/include/libcamera/meson.build b/include/libcamera/meson.build
index 3e04557d..6f87689e 100644
--- a/include/libcamera/meson.build
+++ b/include/libcamera/meson.build
@@ -2,6 +2,7 @@ libcamera_api = files([
     'camera.h',
     'camera_manager.h',
     'libcamera.h',
+    'signal.h',
 ])
 
 install_headers(libcamera_api,
diff --git a/include/libcamera/signal.h b/include/libcamera/signal.h
new file mode 100644
index 00000000..0b437a48
--- /dev/null
+++ b/include/libcamera/signal.h
@@ -0,0 +1,154 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2019, Google Inc.
+ *
+ * signal.h - Signal & slot implementation
+ */
+#ifndef __LIBCAMERA_SIGNAL_H__
+#define __LIBCAMERA_SIGNAL_H__
+
+#include <list>
+#include <vector>
+
+namespace libcamera {
+
+template<typename... Args>
+class Signal;
+
+template<typename... Args>
+class SlotBase
+{
+public:
+	SlotBase(void *obj)
+		: obj_(obj) { }
+	virtual ~SlotBase() { }
+
+	virtual void invoke(Args... args) = 0;
+
+protected:
+	friend class Signal<Args...>;
+	void *obj_;
+};
+
+template<typename T, typename... Args>
+class SlotMember : public SlotBase<Args...>
+{
+public:
+	SlotMember(T *obj, void(T::*func)(Args...))
+		: SlotBase<Args...>(obj), func_(func) { }
+
+	void invoke(Args... args) { (reinterpret_cast<T *>(this->obj_)->*func_)(args...); }
+
+private:
+	friend class Signal<Args...>;
+	void(T::*func_)(Args...);
+};
+
+template<typename... Args>
+class SlotStatic : public SlotBase<Args...>
+{
+public:
+	SlotStatic(void(*func)(Args...))
+		: SlotBase<Args...>(nullptr), func_(func) { }
+
+	void invoke(Args... args) { (*func_)(args...); }
+
+private:
+	friend class Signal<Args...>;
+	void(*func_)(Args...);
+};
+
+template<typename... Args>
+class Signal
+{
+public:
+	Signal() { }
+	~Signal()
+	{
+		for (SlotBase<Args...> *slot : slots_)
+			delete slot;
+	}
+
+	template<typename T>
+	void connect(T *object, void(T::*func)(Args...))
+	{
+		slots_.push_back(new SlotMember<T, Args...>(object, func));
+	}
+
+	void connect(void(*func)(Args...))
+	{
+		slots_.push_back(new SlotStatic<Args...>(func));
+	}
+
+	void disconnect()
+	{
+		for (SlotBase<Args...> *slot : slots_)
+			delete slot;
+		slots_.clear();
+	}
+
+	template<typename T>
+	void disconnect(T *object)
+	{
+		for (auto iter = slots_.begin(); iter != slots_.end(); ) {
+			SlotBase<Args...> *slot = *iter;
+			if (slot->obj_ == object) {
+				iter = slots_.erase(iter);
+				delete slot;
+			} else {
+				++iter;
+			}
+		}
+	}
+
+	template<typename T>
+	void disconnect(T *object, void(T::*func)(Args...))
+	{
+		for (auto iter = slots_.begin(); iter != slots_.end(); ) {
+			SlotBase<Args...> *slot = *iter;
+			/*
+			 * If the obj_ pointer matches the object types must
+			 * match, so we can safely cast to SlotMember<T, Args>.
+			 */
+			if (slot->obj_ == object &&
+			    reinterpret_cast<SlotMember<T, Args...> *>(slot)->func_ == func) {
+				iter = slots_.erase(iter);
+				delete slot;
+			} else {
+				++iter;
+			}
+		}
+	}
+
+	void disconnect(void(*func)(Args...))
+	{
+		for (auto iter = slots_.begin(); iter != slots_.end(); ) {
+			SlotBase<Args...> *slot = *iter;
+			if (slot->obj_ == nullptr &&
+			    reinterpret_cast<SlotStatic<Args...> *>(slot)->func_ == func) {
+				iter = slots_.erase(iter);
+				delete slot;
+			} else {
+				++iter;
+			}
+		}
+	}
+
+	void emit(Args... args)
+	{
+		/*
+		 * Make a copy of the slots list as the slot could call the
+		 * disconnect operation, invalidating the iterator.
+		 */
+		std::vector<SlotBase<Args...> *> slots{ slots_.begin(), slots_.end() };
+		for (SlotBase<Args...> *slot : slots)
+			slot->invoke(args...);
+	}
+
+private:
+	std::list<SlotBase<Args...> *> slots_;
+};
+
+} /* namespace libcamera */
+
+#endif /* __LIBCAMERA_SIGNAL_H__ */
diff --git a/src/libcamera/meson.build b/src/libcamera/meson.build
index 78562299..3ec86e75 100644
--- a/src/libcamera/meson.build
+++ b/src/libcamera/meson.build
@@ -6,6 +6,7 @@ libcamera_sources = files([
     'media_device.cpp',
     'media_object.cpp',
     'pipeline_handler.cpp',
+    'signal.cpp',
 ])
 
 libcamera_headers = files([
diff --git a/src/libcamera/signal.cpp b/src/libcamera/signal.cpp
new file mode 100644
index 00000000..0fd3bb2a
--- /dev/null
+++ b/src/libcamera/signal.cpp
@@ -0,0 +1,84 @@
+/* SPDX-License-Identifier: LGPL-2.1-or-later */
+/*
+ * Copyright (C) 2019, Google Inc.
+ *
+ * signal.cpp - Signal & slot implementation
+ */
+
+namespace libcamera {
+
+/**
+ * \class Signal
+ * \brief Generic signal and slot communication mechanism
+ *
+ * Signals and slots are a language construct aimed at communication between
+ * objects through the observer pattern without the need for boilerplate code.
+ * See http://doc.qt.io/qt-5/signalsandslots.html for more information.
+ *
+ * Signals model events that can be observed from objects unrelated to the event
+ * source. Slots are functions that are called in response to a signal. Signals
+ * can be connected to and disconnected from slots dynamically at runtime. When
+ * a signal is emitted, all connected slots are called sequentially in the order
+ * they have been connected.
+ *
+ * Signals are defined with zero, one or more typed parameters. They are emitted
+ * with a value for each of the parameters, and those values are passed to the
+ * connected slots.
+ *
+ * Slots are normal static or class member functions. In order to be connected
+ * to a signal, their signature must match the signal type (taking the same
+ * arguments as the signal and returning void).
+ *
+ * Connecting a signal to a slot results in the slot being called with the
+ * arguments passed to the emit() function when the signal is emitted. Multiple
+ * slots can be connected to the same signal, and multiple signals can connected
+ * to the same slot. Duplicate connections between a signal and a slot are
+ * allowed and result in the slot being called multiple times for the same
+ * signal emission.
+ */
+
+/**
+ * \fn Signal::connect(T *object, void(T::*func)(Args...))
+ * \brief Connect the signal to a member function slot
+ * \param object The slot object pointer
+ * \param func The slot member function
+ */
+
+/**
+ * \fn Signal::connect(void(*func)(Args...))
+ * \brief Connect the signal to a static function slot
+ * \param func The slot static function
+ */
+
+/**
+ * \fn Signal::disconnect()
+ * \brief Disconnect the signal from all slots
+ */
+
+/**
+ * \fn Signal::disconnect(T *object)
+ * \brief Disconnect the signal from all slots of the \a object
+ */
+
+/**
+ * \fn Signal::disconnect(T *object, void(T::*func)(Args...))
+ * \brief Disconnect the signal from the \a object slot member function \a func
+ */
+
+/**
+ * \fn Signal::disconnect(void(*func)(Args...))
+ * \brief Disconnect the signal from the slot static function \a func
+ */
+
+/**
+ * \fn Signal::emit(Args... args)
+ * \brief Emit the signal and call all connected slots
+ *
+ * Emitting a signal calls all connected slots synchronously and sequentially in
+ * the order the slots have been connected. The arguments passed to the emit()
+ * function are passed to the slot functions unchanged. If a slot modifies one
+ * of the arguments (when passed by pointer or reference), the modification is
+ * thus visible to all subsequently called slots.
+ */
+
+} /* namespace libcamera */