How to Implement "Connections" Using C++ Functors - c++

Question

I am working on code to implement a lightweight version of something similar to Qt's signals/slots mechanism (i.e. a glorified Observer pattern) where I can connect "signals" to "slots." A "connection" can only be made if the two signatures are identical. Any time a "signal" is emitted, all of the calls to any attached "slots" will be queued to be executed in their appropriate threads at a later time.
I have been doing a large amount of research on this topic and understand that what I want can be achieved through some combination of Functors and templates. However, I am unable to figure out how to make everything work the way I would like. Also, this is being used on an embedded processor so I don't want to use std::function which, as I have read, has a large amount of overhead associated with it.
So far, I have written a successful signature for a "connect" function as follows:
template<typename OBJECT, typename FUNC>
static void connect(OBJECT *sender, FUNC signal, OBJECT *receiver, FUNC slot) {
}
//...
Test1 t;
Test1::connect(&t, &Test1::signal1, &t, &Test1::slot1);
Now, I need some way to store a function call associated with the object/slot to be stored and called by the signal when it is emitted. I understand that this should be done with a Functor. However, I can't figure out how to write a functor that is agnostic of the object but requires a specific signature. I am looking for something along the lines of:
GenericFunctor<int, int> slotsConnectedToSignal1[4];
GenericFunctor<int, char, int> slotsConnectedToSignal2[4];
In this way, the signal (which has the same signature as the array that contains its connected slots) can loop through the array and call all the functor.
Is there any way to achieve what I am trying to accomplish and am I on the right track?
Thank You!
EDIT
I am getting closer to what I want using the following definitions for connect().
template <typename ObjSender, typename Ret, typename ObjReceiver>
static void connect(ObjSender *sender, Ret(ObjSender::*signal)(), ObjReceiver *receiver, Ret(ObjReceiver::*slot)()) {
std::function<Ret()> fSender = std::bind(signal, sender);
std::function<Ret()> fReceiver = std::bind(slot, receiver);
}
template <typename ObjSender, typename Ret, typename ARG0, typename ObjReceiver>
static void connect(ObjSender *sender, Ret(ObjSender::*signal)(ARG0), ObjReceiver *receiver, Ret(ObjReceiver::*slot)(ARG0)) {
std::function<Ret(ARG0)> fSender = std::bind(signal, sender, std::placeholders::_1);
std::function<Ret(ARG0)> fReceiver = std::bind(slot, receiver, std::placeholders::_1);
}
Now, my next question is how to store and recall these std::function objects in their correct signals. For example, when the user calls signal1(1, 2), this function should be able to look up all the "connected" std::function objects associated with it and call each one in turn with arguments.
Also, I need to mention that this code is targeted for an embedded system which is why I am attempting to develop this from scratch so as to minimize the overhead from external libraries.
EDIT 2
Based upon some of the feedback I have received, the following is my most recent attempt to achieve my desired results.
template<typename ... ARGS>
class Signal {
public:
void operator()(ARGS... args) {
_connection(args...);
}
void connect(std::function<void(ARGS...)> slot) {
_connection = slot;
}
private:
std::function<void(ARGS...)> _connection;
};
class Test2 {
public:
Signal<int, int> signal1;
Signal<int, int> signal2;
void slot1(int a, int b) {
signal1(a, b);
}
void slot2(int c, int d) {
int i = c + d;
(void)i;
}
};
int main(void) {
Test2 t2;
t2.signal1.connect(t2.signal2);
t2.signal2.connect(std::bind(&Test2::slot2, &t2, std::placeholders::_1, std::placeholders::_2));
t2.slot1(1, 2);
}
However, I still have the problem in this case that, when I want to connect to a "slot" function (instead of another signal), I need to used std::bind with the right number of placeholders. I know there must be a way to do this but am not familiar enough with out std::function and lambdas work.

Answer 1

What you are doing in your main() in "EDIT 2" is a little convoluted, but the basic issue is that your first connect() call is making a copy of the signal1 object, which is not the same as a reference to t2's member variable. One way to address this is to capture it with a lambda:
#include <iostream>
#include <functional>
#include <vector>
template<typename ... ARGS>
class Signal {
public:
void operator()(ARGS... args) const {
for( const auto& slot : _connection ) {
slot(args...);
}
}
// Return the index as a handle to unregister later
auto connect(std::function<void(ARGS...)> slot) {
_connection.emplace_back( std::move( slot ) );
return _connection.size() - 1;
}
// ... unregister function, etc.
private:
std::vector<std::function<void(ARGS...)>> _connection;
};
class Test2 {
public:
Signal<int, int> signal1;
Signal<int, int> signal2;
void slot1(int a, int b) {
std::cout << "slot1 " << a << ' ' << b << '\n';
signal1(a,b);
}
void slot2(int c, int d) {
std::cout << "slot2 " << c << ' ' << d << '\n';
}
};
int main() {
Test2 t2;
//t2.signal1.connect( t2.signal2 ); // Makes a copy of t2.signal2
t2.signal1.connect( [&]( auto x, auto y ) { t2.signal2(x,y); } ); // Keeps a reference to t2.signal2
t2.signal2.connect( [&]( auto x, auto y ) { t2.slot2( x, y ); } );
t2.signal1(1, 2);
}
See it live on Wandbox, where it calls only slot2() as expected:
slot2 1 2
FWIW, here is the same code (but shorter!) using Boost.Signals2:
#include <iostream>
#include <boost/signals2.hpp>
class Test2 {
public:
boost::signals2::signal<void(int, int)> signal1;
boost::signals2::signal<void(int, int)> signal2;
void slot1(int a, int b) {
std::cout << "slot1 " << a << ' ' << b << '\n';
signal1(a,b);
}
void slot2(int c, int d) {
std::cout << "slot2 " << c << ' ' << d << '\n';
}
};
int main() {
Test2 t2;
//t2.signal1.connect( t2.signal2 );
t2.signal1.connect( [&]( auto x, auto y ) { t2.signal2(x,y); } );
t2.signal2.connect( [&]( auto x, auto y ) { t2.slot2( x, y ); } );
t2.signal1(1, 2);
}
The only differences are the #includes, the declarations of signal1 and signal2, and the deletion of the home-spun Signal class. See it live on Wandbox.
Note that when Qt does this, it relies on macros and the MOC to generate some extra glue code to make it all work.
Update: Replying to your comment, yes. To support that syntax, you could add an overload that does the binding work for the user. You may get into some complications with having to supply multiple overloads for different const-nesses, but this should give you an idea:
#include <iostream>
#include <functional>
#include <utility>
#include <vector>
template<typename ... ARGS>
class Signal {
public:
void operator()(ARGS... args) const {
for( const auto& slot : _connection ) {
slot(args...);
}
}
template<class T>
auto connect(T& t, void(T::* fn)(ARGS...)) {
const auto lambda = [&t, fn](ARGS... args) {
(t.*fn)( std::forward<ARGS>( args )... );
};
return connect( lambda );
}
auto connect(std::function<void(ARGS...)> slot) {
_connection.emplace_back( std::move( slot ) );
return _connection.size() - 1;
}
private:
std::vector<std::function<void(ARGS...)>> _connection;
};
class Sender {
public:
Signal<int, int> signal1;
};
class Receiver {
public:
void slot1(int a, int b) {
std::cout << "slot1 " << a << ' ' << b << '\n';
}
void slot2(int a, int b) {
std::cout << "slot2 " << a << ' ' << b << '\n';
}
};
// Stand-alone slot
void slot3(int a, int b) {
std::cout << "slot3 " << a << ' ' << b << '\n';
}
int main() {
auto sender = Sender{};
auto recv = Receiver{};
// Register three different slots
sender.signal1.connect( [&]( auto x, auto y ) { recv.slot1( x, y ); } );
sender.signal1.connect( recv, &Receiver::slot2 );
sender.signal1.connect( &slot3 );
// Fire the signal
sender.signal1(1, 2);
}
I refactored a little and hopefully made it a little easier to grok. See it live on Wandbox, where it outputs the expected:
slot1 1 2
slot2 1 2
slot3 1 2

Answer 2

I think I have finally come up with a method that works for me based upon all the comments I have received. Here is a simplified version for anyone who is interested:
template<typename ... ARGS>
class Signal {
#define MAX_CONNECTIONS 4
public:
#define CONNECT_FAILED (ConnectionHandle)(-1);
Signal() : _connections{nullptr} {};
/**
* #brief Implementation of the "function" operator
*
* #param args Arguments passed to all connected slots (or signals)
*/
void operator()(ARGS... args) {
//Loop through the connections array
for (int i = 0; i < MAX_CONNECTIONS; i++) {
if (_connections[i]) {
/*
* Call the connected function
* This will either
* a) Call a lambda which will invoke a slot
* b) Call operator() on another signal (i.e. recursive signals)
*/
_connections[i](args...);
}
}
}
/**
* #brief Make a connection to a slot
*
* #param t A pointer to the object instance
* #param fn A member function pointer to the slot
* #return A handle (ID) used to disconnect the connection if desired
*
* #note This function assumes that T is a subclass of ActiveObject (i.e. has the invoke() method)
*/
template<class T>
inline ConnectionHandle connect(T* t, void(T::* fn)(ARGS...)) {
//This lambda will use ActiveObject::invoke to queue the connected slot for later execution
const auto lambda = [=](ARGS... args) { T::invoke(t, fn, args...); };
return connect(lambda);
}
/**
* #brief Make a connection to another signal
*
* #param t A pointer to the object instance
* #param s The signal
* #return A handle (ID) used to disconnect the connection if desired
*/
template<class T>
inline ConnectionHandle connect(T *t, Signal<ARGS...> T::*s) {
return connect(t->*s);
}
/**
* #brief Make a generic connection to a slot which takes an Event smart pointer as its argument
*
* #param t The object to connect to
* #param fn The member function of t to connect to
* #param eventIndex The user-defined index to assign to the event
* #return A handle (ID) used to disconnect the connection if desired
*
* #note This version of connect is useful to connect any signal to the same slot function which may dispatch the eent directly into its state machine (if derived from StateMachine)
*/
template<class T>
inline ConnectionHandle connect(T *t, void(T::* fn)(std::shared_ptr<Event> e), int eventIndex) {
const auto lambda = [=](ARGS... args){
std::shared_ptr<Event> ptr = std::make_shared<Event>(eventIndex);
T::invoke(t, fn, ptr);
};
return connect(lambda);
}
/**
* #brief Make a connection to an abstract function
*
* #param slot The function to connect to
* #return A handle (ID) used to disconnect the connection if desired
*/
ConnectionHandle connect(std::function<void(ARGS...)> slot) {
ConnectionHandle i;
//2nd: Make the connection in an empty slot
for (i = 0; i < MAX_CONNECTIONS; i++) {
if (!_connections[i]) {
//Make the connection
_connections[i] = slot;
return i;
}
}
return CONNECT_FAILED;
}
/**
* #brief Remove the given connection by its handle (i.e. ID)
* #param h The handle previously returned by a call to connect()
*/
void disconnect(ConnectionHandle h) {
if ((h < 0) || (h >= MAX_CONNECTIONS)) return;
_connections[h] = nullptr;
}
private:
std::function<void(ARGS...)> _connections[MAX_CONNECTIONS];
};
Where any object that wants to take advantage of signals and slots need to subclass the following:
class ActiveObject {
public:
#define DECLARE_SIGNAL(name,...) Signal<__VA_ARGS__> name
#define EMIT
#define DECLARE_SLOT(name, ...) void name(__VA_ARGS__)
#define DEFINE_SLOT(className, name, ...) void className::name(__VA_ARGS__)
ActiveObject(ActiveObjectThread *parentThread);
virtual ~ActiveObject();
/**
* #brief Called by the parent thread during initialization once the thread has started and is running
* #note This function may be overridden by sub-classes to provide initialization code
*/
virtual void initialize() {};
/**
* #brief Return the parent thread of this active object
*/
inline ActiveObjectThread *thread() const { return _parentThread; }
/**
* #brief Queue a slot to be called later by the parent thread
*
* #param t A pointer to the active object
* #param fn A member function pointer within the active object to execute
* #param args The arguments to pass to the slot function when called
* #note Invoke should ALWAYS be used when calling a slot function to ensure that it is executed within the same thread as the active object (i.e. the parent thread)
*/
template<class T, typename ... ARGS>
inline static void invoke(T *t, void(T::* fn)(ARGS...), ARGS... args) {
std::function<void()> *f = new std::function<void()>([=]() { (t->*fn)( args... ); });
//Queue in the parent thread
t->_parentThread->queueInvokable(f);
}
inline static void invoke(ActiveObject *ao, std::function<void()> f) {
std::function<void()> *newF = new std::function<void()>(f);
ao->_parentThread->queueInvokable(newF);
}
private:
ActiveObjectThread *_parentThread;
};
In my application, I am not calling any of the slots directly, but rather am queuing them for later execution by a thread.
Here is an example of how to use these classes:
class MyActiveObject : public ActiveObjecte {
public:
MyActiveObject() :
//Just create a thread as part of the object's constructor
ActiveObject(new ActiveObjectThread("MyActiveObject", 512, 1))
{
thread()->Start();
}
~MyActiveObject() {
//Make sure to delete the thread we created
delete thread();
}
DECLARE_SIGNAL(signal1, int, int);
DECLARE_SLOT(slot1) {
GenericEvent *e = new GenericEvent(EVENT_1);
e->args()[0] = 100;
//Dispatch the event into the state machine
dispatch(e);
EMIT signal1(5, 6);
}
DECLARE_SLOT(slot2, int a, int b) {
GenericEvent *e = new GenericEvent(EVENT_2);
e->args()[0] = a;
e->args()[1] = b;
//Dispatch the event into the state machine
dispatch(e);
}
DECLARE_SLOT(slotEventHander, std::shared_ptr<Event> e) {
dispatch(e.get());
}
};
MyActiveObject myActiveObject;
myActiveObject.signal1.connect(&myActiveObject, &MyActiveObject::slot2);
myActiveObject.signal1.connect(&myActiveObject, &MyActiveObject::slotEventHander, MyActiveObject::EVENT_2);
ActiveObject::invoke(&myActiveObject, &MyActiveObject::slot1);
I have taken out the code that implements the state machine because that is not relevant to this topic.
I hope this helps someone out!