blob: cb7daa11dab139e08a0c09f8628a5ab50a78dca3 (
plain)
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
|
/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2019, Google Inc.
*
* signal.cpp - Signal & slot implementation
*/
/**
* \file signal.h
* \brief 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
*
* If the typename T inherits from Object, the signal will be automatically
* disconnected from the \a func slot of \a object when \a object is destroyed.
* Otherwise the caller shall disconnect signals manually before destroying \a
* object.
*/
/**
* \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
* \param object The object pointer whose slots to disconnect
*/
/**
* \fn Signal::disconnect(T *object, void(T::*func)(Args...))
* \brief Disconnect the signal from the \a object slot member function \a func
* \param object The object pointer whose slots to disconnect
* \param func The slot member function to disconnect
*/
/**
* \fn Signal::disconnect(void(*func)(Args...))
* \brief Disconnect the signal from the slot static function \a func
* \param func The slot static function to disconnect
*/
/**
* \fn Signal::emit(Args... args)
* \brief Emit the signal and call all connected slots
* \param args The arguments passed to the 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 */
|
