How to distinguish python callbacks on cpp side?

[jagiella]

Goal:

I would like to use an event-based workflow with a Signal class, that provides following mechanisms:

• connect/disconnect: registers / unregisters python functions and c++-functions as callbacks
• emit: calls all registered callbacks with passed arguments

Problem:

• the callbacks are stored as std::function in a std::list
• in order to unregister a callback or to avoid registering the same callback twice, a comparison operator for std::function is required
• the proposed implementation for Signal class and comparison operator works for c++ callbacks, but doesnt for python callbacks:

test with cpp callback (works!)

from signal import Signal, cpp_callback

s = Signal()
s.connect(cpp_callback)
s.emit()
s.connect(cpp_callback) # <- throws an exception as already connected

test with python callback (fails!)

from signal import Signal

def py_callback1():
    print("py_callback1 called")
def py_callback2():
    print("py_callback2 called")

s = Signal()
s.connect(py_callback1)
s.connect(py_callback2) # <- throws an exception, because the cast to target function (std::function::target()) does not work

signal.cpp

#include <list>
#include <functional>
#include <pybind11/pybind11.h>
#include <pybind11/functional.h>
#include <pybind11/stl.h>

void cpp_callback() {
	std::cout << "cpp_callback called" << std::endl;
}

template<typename ... Types>
class Signal {
private:
	std::list<std::function<void(Types ...)> > m_callbacks;
public:
	Signal() {}
	~Signal() {}

	void connect(std::function<void(Types ...)> callback) {
		for (auto it = m_callbacks.begin(); it != m_callbacks.end();) {
			if (*it == callback) {
				throw std::runtime_error("callback already connected!");
			} else {
				++it;
			}
		}
		m_callbacks.push_back(callback);
	}

	void disconnect(std::function<void(Types ...)> callback) {
		for (auto it = m_callbacks.begin(); it != m_callbacks.end();) {
			if (*it == callback) {
				it = m_callbacks.erase(it);
				return;
			} else {
				++it;
			}
		}
		throw std::runtime_error("callback is not connected!");
	}

	void emit(Types ... args) {
		for (const auto &func : m_callbacks) {
			func(args ...);
		}
	}
}

template<typename ... T>
size_t getAddress(std::function<void(T ...)> function) {
	typedef void (fnType)(T ...);
	if (function.target_type() == typeid(void (*)(T ...))) {
		fnType **fnPointer = function.template target<fnType*>();
		return (size_t) *fnPointer;
	} else {
		std::cout << "Function of unknown type:" << function.target_type().name();
		return 0;
	}
}

template<typename ... Types>
bool operator==(std::function<void(Types ...)> &f1, std::function<void(Types ...)> &f2) {
	if(f1.target_type() != f2.target_type())
		return false;
	else
		return getAddress(f1) == getAddress(f2);
}

namespace py = pybind11;

PYBIND11_MODULE(signal, m) {
	py::class_< Signal<> >(m, "Signal")
		.def(py::init<>())
		.def("connect", &Signal<>::connect, py::arg("callback"))
		.def("disconnect", &Signal<>::disconnect, py::arg("callback"))
		.def("emit", &Signal<>::emit);

	m.def("cpp_callback", &cpp_callback);
}