Easy3D 2.5.3
Test_Signal
1/********************************************************************
2 * Copyright (C) 2015 Liangliang Nan <liangliang.nan@gmail.com>
3 * https://3d.bk.tudelft.nl/liangliang/
4 *
5 * This file is part of Easy3D. If it is useful in your research/work,
6 * I would be grateful if you show your appreciation by citing it:
7 * ------------------------------------------------------------------
8 * Liangliang Nan.
9 * Easy3D: a lightweight, easy-to-use, and efficient C++ library
10 * for processing and rendering 3D data.
11 * Journal of Open Source Software, 6(64), 3255, 2021.
12 * ------------------------------------------------------------------
13 *
14 * Easy3D is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License Version 3
16 * as published by the Free Software Foundation.
17 *
18 * Easy3D is distributed in the hope that it will be useful,
19 * but WITHOUT ANY WARRANTY; without even the implied warranty of
20 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 * GNU General Public License for more details.
22 *
23 * You should have received a copy of the GNU General Public License
24 * along with this program. If not, see <http://www.gnu.org/licenses/>.
25 ********************************************************************/
26
27
28#include <easy3d/core/signal.h>
29#include <iostream>
30#include <string>
31
32
33using namespace easy3d;
34
35
36// A trivial class (that does not make sense, but just to show how to use the Signal class).
37
38class MyCar {
39public:
40 MyCar(int speed) : speed_(speed) {}
41
42public:
43 int speed() const { return speed_; }
44
45 void start() {
46 std::cout << "started. speed: " << speed_ << "\n";
47 }
48
49 void start(const std::string& msg) {
50 std::cout << "car started: " << msg << "\n";
51 }
52
53 void report_speed(int max_allow_speed) const {
54 std::cout << "max allowed speed is " << max_allow_speed << ". I am at " << speed_ << "\n";
55 }
56
57 void stop(int hours, const std::string &msg) const {
58 std::cout << msg << ". After driving for " << hours << " hours\n";
59 }
60
61private:
62 int speed_;
63};
64
65
66void test_signal_for_members(MyCar *car) {
67 Signal<> start_signal;
68 Signal<const std::string&> start_signal_1arg;
69 Signal<int> report_signal;
71
72 // ---- connect to a class member, no argument
73
74 start_signal.connect(car, &MyCar::start); // this works
75 start_signal.send();
76 start_signal.connect(car, static_cast<void (MyCar::*)(void)> (&MyCar::start)); // this works
77 start_signal.connect(car, overload<MyCar>(&MyCar::start)); // this works
78
79// easy3d::connect(&start_signal, car, &MyCar::start); // this won't work
80 easy3d::connect(&start_signal, car, static_cast<void (MyCar::*)(void)> (&MyCar::start)); // this works
81 easy3d::connect(&start_signal, car, overload<MyCar>(&MyCar::start)); // this works
82
83 start_signal_1arg.connect(car, &MyCar::start); // this works
84 start_signal_1arg.connect(car, static_cast<void (MyCar::*)(const std::string&)> (&MyCar::start)); // this works
85 start_signal_1arg.connect(car, overload<MyCar, const std::string&>(&MyCar::start)); // this works
86
87// easy3d::connect(&start_signal_1arg, car, &MyCar::start); // this won't work
88 easy3d::connect(&start_signal_1arg, car, static_cast<void (MyCar::*)(const std::string&)> (&MyCar::start)); // this works
89 easy3d::connect(&start_signal_1arg, car, overload<MyCar, const std::string&>(&MyCar::start)); // this works
90
91 // ---- connect to a const class member, one argument
92
93 easy3d::connect(&report_signal, car, &MyCar::report_speed); // use the global function connect()
94 report_signal.connect(car, &MyCar::report_speed); // use signal's connect()
95
96 // ---- connect to a const class member, two arguments
97
98 easy3d::connect(&stop_signal, car, &MyCar::stop); // use the global function connect()
99 stop_signal.connect(car, &MyCar::stop); // use signal's connect()
100
101 // ---- emit all the signals
102
103 start_signal.send();
104 report_signal.send(80);
105 stop_signal.send(6, "I have to stop");
106
107 // ---- disconnect all signals
108
109 start_signal.disconnect_all();
110 report_signal.disconnect_all();
111 stop_signal.disconnect_all();
112}
113
114
115void signal_func_start() {
116 std::cout << "started\n";
117}
118
119void signal_func_start(const std::string& msg) {
120 std::cout << "car started: " << msg << "\n";
121}
122
123void signal_func_report_speed(int max_allow_speed, const MyCar *car) {
124 std::cout << "max allowed is " << max_allow_speed << ". I am at " << car->speed() << "\n";
125}
126
127void signal_func_stop(const MyCar *car, int hours, const std::string &msg) {
128 std::cout << msg << " after driving for " << hours << " hours. My speed was " << car->speed() << "\n";
129}
130
131
132void test_signal_for_functions(MyCar *car) {
133 Signal<> func_start_signal;
134 Signal<const std::string &> func_start_signal_1arg;
135 Signal<int, const MyCar *> func_report_signal;
137
138 // ---- connect to a function, no argument
139
140// func_start_signal.connect(signal_func_start); // this won't work
141 func_start_signal.connect(static_cast<void (*)(void)> (signal_func_start)); // this works
142 func_start_signal.connect(overload<>(signal_func_start)); // this also works
143
144// easy3d::connect(&func_start_signal, signal_func_start); // this won't work
145 easy3d::connect(&func_start_signal, static_cast<void (*)(void)> (signal_func_start)); // this works
146 easy3d::connect(&func_start_signal, overload<>(signal_func_start)); // this also works
147
148 // ---- connect to a function, one argument
149
150// func_start_signal_1arg.connect(signal_func_start); // this won't work
151 easy3d::connect(&func_start_signal_1arg, static_cast<void (*)(const std::string&)> (signal_func_start)); // this works
152 easy3d::connect(&func_start_signal_1arg, overload<const std::string&>(signal_func_start)); // this works
153
154// func_start_signal_1arg.connect(signal_func_start); // this won't work
155 func_start_signal_1arg.connect(static_cast<void (*)(const std::string&)> (signal_func_start)); // this works
156 func_start_signal_1arg.connect(overload<const std::string&> (signal_func_start)); // this works
157
158 // ---- connect to a function, two arguments
159
160 easy3d::connect(&func_report_signal, signal_func_report_speed); // use the global function connect()
161 func_report_signal.connect(signal_func_report_speed); // use signal's connect()
162
163 // ---- connect to a function, three arguments
164
165 easy3d::connect(&another_stop_signal, signal_func_stop); // use the global function connect()
166 another_stop_signal.connect(signal_func_stop); // use signal's connect()
167
168 // ---- send all the signals
169
170 func_start_signal.send();
171 func_start_signal_1arg.send("blabla...");
172 func_report_signal.send(80, car);
173 another_stop_signal.send(car, 6, "I have to stop");
174
175 func_start_signal.disconnect_all();
176 func_start_signal_1arg.disconnect_all();
177 func_report_signal.disconnect_all();
178 another_stop_signal.disconnect_all();
179}
180
181
182void test_signal_for_lambda_functions(MyCar *car) {
183 auto lambda_start = []() -> void {
184 std::cout << "started\n";
185 };
186
187 auto lambda_start_1arg = [](MyCar *car) -> void {
188 std::cout << "speed is " << car->speed() << "\n";
189 };
190
191 auto lambda_report_speed = [](int max_allow_speed, const MyCar *car) -> void {
192 std::cout << "max allowed is " << max_allow_speed << ". I am at " << car->speed() << "\n";
193 };
194
195 auto lambda_stop = [](const MyCar *car, int hours, const std::string &msg) -> void {
196 std::cout << msg << " after driving for " << hours << " hours. My speed was " << car->speed() << "\n";
197 };
198
199 Signal<> lambda_start_signal;
200 Signal<MyCar *> lambda_start_signal_1arg;
201 Signal<int, const MyCar *> lambda_report_signal;
203
204 // ---- connect to a function, no argument
205 easy3d::connect(&lambda_start_signal, lambda_start); // use the global function connect()
206 lambda_start_signal.connect(lambda_start); // use signal's connect()
207
208 // ---- connect to a function, one argument
209
210 easy3d::connect(&lambda_start_signal_1arg, lambda_start_1arg); // use the global function connect()
211 lambda_start_signal_1arg.connect(lambda_start_1arg); // use signal's connect()
212
213 // ---- connect to a function, two arguments
214 easy3d::connect(&lambda_report_signal, lambda_report_speed); // use the global function connect()
215 lambda_report_signal.connect(lambda_report_speed); // use signal's connect()
216
217 // ---- connect to a function, three arguments
218 easy3d::connect(&lambda_stop_signal, lambda_stop); // use the global function connect()
219 lambda_stop_signal.connect(lambda_stop); // use signal's connect()
220
221 lambda_start_signal.send();
222 lambda_start_signal_1arg.send(car);
223 lambda_report_signal.send(80, car);
224 lambda_stop_signal.send(car, 6, "I have to stop");
225
226 lambda_start_signal.disconnect_all();
227 lambda_start_signal_1arg.disconnect_all();
228 lambda_report_signal.disconnect_all();
229 lambda_stop_signal.disconnect_all();
230}
231
232
233void test_signal_for_connect_signal_to_signal() {
237
238 easy3d::connect(&A, &B); // or A.connect(&B);
239 easy3d::connect(&B, &C); // or B.connect(&C);
240 int id = C.connect([](const std::string &msg) -> void {
241 std::cout << "C: " << msg << std::endl;
242 });
243
244 A.send("abc");
245
246 A.disconnect(id);
247}
248
249
250int test_signal() {
251 MyCar car(100);
252
253 std::cout << "connect to a class member --------------------------------------------------------------\n";
254 test_signal_for_members(&car);
255
256 std::cout << "connect to a function ------------------------------------------------------------------\n";
257 test_signal_for_functions(&car);
258
259 std::cout << "connect to a lambda function -----------------------------------------------------------\n";
260 test_signal_for_lambda_functions(&car);
261
262 std::cout << "connect a signal to another signal -----------------------------------------------------\n";
263 test_signal_for_connect_signal_to_signal();
264
265 return EXIT_SUCCESS;
266}
A light-weight implementation of the simple signal-slot mechanism.
Definition: signal.h:56
void disconnect_all()
Disconnects all previously connected functions.
Definition: signal.h:155
int connect(std::function< void(Args...)> const &slot)
Connects a function to this signal.
Definition: signal.h:97
void send(Args... p)
Calls all connected functions.
Definition: signal.h:160
void disconnect(int id)
Disconnects a previously connected function.
Definition: signal.h:150
Definition: collider.cpp:182
int connect(SIGNAL *signal, FUNCTION const &slot)
Connects a function to the signal.
Definition: signal.h:202