Practicing my template skills

Wednesday, November 28. 2007

Practicing my template skills

While working on assignments for the Computergraphics course I'm taking this semester I was missing signals and slots. Using Qt for the assignments is not possible (well actually I didn't ask explicitly whether I could use it), so I felt challenged to code the convenient things I'm so used to...

I knew that boost had some implementation of signals and slots that used templates but I had never actually taken a look at it. And I didn't want to, yet. I wanted to think about the problem myself first. Basically I came up with that a signal needs to be an object where as a slot may not have to be an object, but must also work as a member function. After a few iterations I came up with a header that now allows me to do the following:

#include "signal.h"
#include <iostream>

struct A
{
void operator()()
{
std::cout << "A::operator()" << std::endl;
}

void f()
{
std::cout << "A::f" << std::endl;
}
};

struct B
{
void operator()(int x)
{
std::cout << "B::operator() " << x << std::endl;
}

void f(int x)
{
std::cout << "B::f " << x << std::endl;
}
};

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

void g(int x)
{
std::cout << "g " << x << std::endl;
}

int main()
{
A a;
Signal<> s;
s.connect(&a);
s.connect(&a, &A::f);
s.connect(&g);
s();

B b;
Signal<int> s2;
s2.connect(&b);
s2.connect(&b, &B::f);
s2.connect(&g);
s2(5);

return 0;
}

The output of that program is: A::operator() A::f g B::operator() 5 B::f 5 g 5 as you probably expected. Notice that

You can use 0 to 10 types in the template parameter of the Signal class.
You can connect to functions, member functions and objects that have an operator() with the right signature. This allows to connect one signal to another one, like:
Signal<const std::vector<int> &> s1;
Signal<const std::vector<int> &> s2;
s1.connect(&s2);
s2.connect(&someFunction);
s1(std::vector<int>());
This will call someFunction(std::vector()).
Signal will only allow "slot" connections and operator() calls with the correct signature. I needed to make Signal have different member functions depending on the number of its template arguments. Took me some time to realize but this was possible using inheritance.

Now you probably want to see the code for Signal:

I simplified it to work for only zero or one arguments so that it's easier to get an overview. But imagine those _If<_IsValidArgument >::Result typedefs to span a few lines.

#ifndef SIGNAL_H
#define SIGNAL_H

#include <vector>

class _NoArgument {};

/// undefined result if the condition is neither true nor false
template<bool condition, typename Then, typename Else> struct _If;

/// _If false Else is the Result
template<typename Then, typename Else> struct _If<false, Then, Else> { typedef Else Result; };

/// _If true Then is the Result
template<typename Then, typename Else> struct _If<true, Then, Else> { typedef Then Result; };

/// All arguments are valid
template<typename T> struct _IsValidArgument { enum { Result = true }; };

/// except _NoArgument
template<> struct _IsValidArgument<_NoArgument> { enum { Result = false }; };

struct Slot0 { virtual ~Slot0() {} virtual void invoke() = 0; };

template<typename A1>
struct Slot1 { virtual ~Slot1() {} virtual void invoke(A1) = 0; };

// ...

struct FunctionSlot0Impl : public Slot0
{
typedef void (* FuncPtr)();
inline void invoke() { (*f)(); }
inline FunctionSlot0Impl(FuncPtr _f) : f(_f) {}
FuncPtr f;
};

template<typename A1>
struct FunctionSlot1Impl : public Slot1<A1>
{
typedef void (* FuncPtr)(A1);
inline void invoke(A1 a1) { (*f)(a1); }
inline FunctionSlot1Impl(FuncPtr _f) : f(_f) {}
FuncPtr f;
};

// ...

template<class T>
struct FunctorSlot0Impl : public Slot0
{
inline void invoke() { (*r)(); }
inline FunctorSlot0Impl(T *_r) : r(_r) {}
T *r;
};

template<class T, typename A1>
struct FunctorSlot1Impl : public Slot1<A1>
{
inline void invoke(A1 a1) { (*r)(a1); }
inline FunctorSlot1Impl(T *_r) : r(_r) {}
T *r;
};

// ...

template<class T>
struct MemberSlot0Impl : public Slot0
{
typedef void (T::* FuncPtr)();
inline void invoke() { (r->*f)(); }
inline MemberSlot0Impl(T *_r, FuncPtr _f) : r(_r), f(_f) {}
T *r;
FuncPtr f;
};

template<class T, typename A1>
struct MemberSlot1Impl : public Slot1<A1>
{
typedef void (T::* FuncPtr)(A1);
inline void invoke(A1 a1) { (r->*f)(a1); }
inline MemberSlot1Impl(T *_r, FuncPtr _f) : r(_r), f(_f) {}
T *r;
FuncPtr f;
};

// ...

struct Signal0 {
typedef Slot0 Slot;
inline void operator()() const { emit(); }
inline void emit() const { for (unsigned int i = 0; i < m_slots.size(); ++i) { m_slots[i]->invoke(); } }
std::vector<Slot *> m_slots;
};

template<typename A1>
struct Signal1 {
typedef Slot1<A1> Slot;
inline void operator()(A1 a1) const { emit(a1); }
inline void emit(A1 a1) const { for (unsigned int i = 0; i < m_slots.size(); ++i) { m_slots[i]->invoke(a1); } }
std::vector<Slot *> m_slots;
};

// ...

template<typename A1 = _NoArgument>
class Signal : public _If<_IsValidArgument<A1>::Result,
Signal1<A1>, Signal0>::Result
{
private:
typedef typename _If<_IsValidArgument<A1>::Result,
Signal1<A1>, Signal0>::Result SignalImpl;
typedef typename SignalImpl::Slot SlotObject;
typedef void (* Ptr1)(A1);
typedef void (* Ptr0)();
typedef typename _If<_IsValidArgument<A1>::Result, Ptr1, Ptr0>::Result Ptr;

inline void connectInternal(SlotObject *slot) { SignalImpl::m_slots.push_back(slot); }

public:
template<class Receiver, typename SlotFunc>
inline void connect(Receiver *recv, SlotFunc func)
{
typedef typename _If<_IsValidArgument<A1>::Result,
MemberSlot1Impl<Receiver, A1>,
MemberSlot0Impl<Receiver> >::Result MemberObject;
connectInternal(new MemberObject(recv, func));
}

template<class Receiver>
inline void connect(Receiver *recv)
{
typedef typename _If<_IsValidArgument<A1>::Result,
FunctorSlot1Impl<Receiver, A1>,
FunctorSlot0Impl<Receiver> >::Result FunctorObject;
connectInternal(new FunctorObject(recv));
}

inline void connect(Ptr slot) {
typedef typename _If<_IsValidArgument<A1>::Result,
FunctionSlot1Impl<A1>,
FunctionSlot0Impl>::Result FunctionObject;
connectInternal(new FunctionObject(slot));
}
};

#endif // SIGNAL_H

Now the only thing I'd like to "fix" is the usage of std::vector. Well actually I'm so out of touch with stdlib classes that I have no idea how to use them correctly. I.e. whether to iterate with an iterator instead of an integer is faster (should be), and whether to use a std::list might be more appropriate. Also a disconnect function is still missing...

But this was all just meant to be a little fun learning templates.

Posted by Matthias Kretz in C++ at 22:24 | Comments (2) | Trackbacks (0)

Trackbacks

Trackback specific URI for this entry

No Trackbacks

Comments

Display comments as (Linear | Threaded)

As you already mentioned, Boost provides a rather flexible signal/slot implementation. There's also libsig++, which is used by gtk--. Both require a library however, I guess for your university courses it would be nicer to have a header-only implementation.

Have you looked at the Boost preprocessor utilities to do some of the heavy lifting when generating all those slot implementations?

Also, you might want to look at Boost.Function (or alternatively tr1::function if you have it) and Boost.Bind. Together with the STL algorithms they're a formidable team.

#1 Niels Aan de Brugh on 2007-11-29 19:43 (Reply)

Yes, after writing my own Signal class I looked at Boost. And I was surprised that boost::signal needs the number of arguments in the class name. But perhaps some feature that I don't provide makes it impossible to put all into one signal class? I didn't take much time to look at implementations yet. I already used too much time to work on those assignments. But I earned a lot of experience when it comes to generic programming - which was my main motivation to not look at other implementations.

#1.1 Matthias Kretz (Homepage) on 2007-11-29 19:50 (Reply)

Add Comment

Name
Email
Homepage
In reply to
Comment	E-Mail addresses will not be displayed and will only be used for E-Mail notifications To prevent automated Bots from commentspamming, please enter the string you see in the image below in the appropriate input box. Your comment will only be submitted if the strings match. Please ensure that your browser supports and accepts cookies, or your comment cannot be verified correctly. Enter the string from the spam-prevention image above: HTML-Tags will be converted to Entities. You can use [geshi lang=lang_name [,ln={y\|n}]][/lang] tags to embed source code snippets Standard emoticons like :-) and ;-) are converted to images.
	Remember Information? Subscribe to this entry