Prepare the Slot classes to be used independently of Signals

Added some polish around them and, to mark this special occasion, moved them out of the SigImpl
namespace.

PS: This partially reverts commit 0775350fee345e37fb59835dda4d85664346b606, since I had to
reintroduce ReturnType template parameter, because it will be used in other places. But Signal classes
remain without the ReturnType, because I still cannot imagine how would it be used.

1 files changed, 59 insertions, 31 deletions

diff --git a/src/FbTk/Slot.hh b/src/FbTk/Slot.hh
index ea7ee2f..71bf6ab 100644
--- a/src/FbTk/Slot.hh
+++ b/src/FbTk/Slot.hh
@@ -22,7 +22,7 @@
 #ifndef FBTK_SLOT_HH
 #define FBTK_SLOT_HH
 
-#include "RefCount.hh"
+#include "NotCopyable.hh"
 
 namespace FbTk {
 
@@ -31,71 +31,99 @@ namespace SigImpl {
 
 struct EmptyArg {};
 
-class SlotBase {
+/** A base class for all slots. It's purpose is to provide a virtual destructor and to enable the
+ * Signal class to hold a pointer to a generic slot.
+ */
+class SlotBase: private FbTk::NotCopyable {
 public:
     virtual ~SlotBase() {}
 };
 
-template<typename Arg1, typename Arg2, typename Arg3>
-class SlotTemplate: public SlotBase {
+} // namespace SigImpl
+
+/** Declares a pure virtual function call operator with a specific number of arguments (depending
+ * on the template specialization). This allows us to "call" any functor in an opaque way.
+ */
+template<typename ReturnType, typename Arg1 = SigImpl::EmptyArg,
+         typename Arg2 = SigImpl::EmptyArg, typename Arg3 = SigImpl::EmptyArg>
+class Slot: public SigImpl::SlotBase {
+public:
+    virtual ReturnType operator()(Arg1, Arg2, Arg3) = 0;
+};
+
+/// Specialization for two arguments
+template<typename ReturnType, typename Arg1, typename Arg2>
+class Slot<ReturnType, Arg1, Arg2, SigImpl::EmptyArg>: public SigImpl::SlotBase {
+public:
+    virtual ReturnType operator()(Arg1, Arg2) = 0;
+};
+
+/// Specialization for one argument
+template<typename ReturnType, typename Arg1>
+class Slot<ReturnType, Arg1, SigImpl::EmptyArg, SigImpl::EmptyArg>: public SigImpl::SlotBase {
+public:
+    virtual ReturnType operator()(Arg1) = 0;
+};
+
+/// Specialization for no arguments
+template<typename ReturnType>
+class Slot<ReturnType, SigImpl::EmptyArg, SigImpl::EmptyArg, SigImpl::EmptyArg>: public SigImpl::SlotBase {
 public:
-    virtual void operator()(Arg1, Arg2, Arg3) = 0;
+    virtual ReturnType operator()() = 0;
 };
 
-template<typename Arg1, typename Arg2, typename Arg3, typename Functor>
-class Slot: public SlotTemplate<Arg1, Arg2, Arg3> {
+/** A class which knows how to call a specific functor. It inherits from Slot and implemetents
+ * the function call operator
+ */
+template<typename Functor, typename ReturnType, typename Arg1 = SigImpl::EmptyArg,
+         typename Arg2 = SigImpl::EmptyArg, typename Arg3 = SigImpl::EmptyArg>
+class SlotImpl: public Slot<ReturnType, Arg1, Arg2, Arg3> {
 public:
-    virtual void operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3)
-    { m_functor(arg1, arg2, arg3); }
+    virtual ReturnType operator()(Arg1 arg1, Arg2 arg2, Arg3 arg3)
+    { return m_functor(arg1, arg2, arg3); }
 
-    Slot(Functor functor) : m_functor(functor) {}
+    SlotImpl(Functor functor) : m_functor(functor) {}
 
 private:
     Functor m_functor;
 };
 
-// specialization for two arguments
-template<typename Arg1, typename Arg2, typename Functor>
-class Slot<Arg1, Arg2, EmptyArg, Functor>: public SlotTemplate<Arg1, Arg2, EmptyArg> {
+/// Specialization for two arguments
+template<typename Functor, typename ReturnType, typename Arg1, typename Arg2>
+class SlotImpl<Functor, ReturnType, Arg1, Arg2, SigImpl::EmptyArg>: public Slot<ReturnType, Arg1, Arg2> {
 public:
-    virtual void operator()(Arg1 arg1, Arg2 arg2, EmptyArg)
-    { m_functor(arg1, arg2); }
+    virtual ReturnType operator()(Arg1 arg1, Arg2 arg2) { return m_functor(arg1, arg2); }
 
-    Slot(Functor functor) : m_functor(functor) {}
+    SlotImpl(Functor functor) : m_functor(functor) {}
 
 private:
     Functor m_functor;
 };
 
-// specialization for one argument
-template<typename Arg1, typename Functor>
-class Slot<Arg1, EmptyArg, EmptyArg, Functor>: public SlotTemplate<Arg1, EmptyArg, EmptyArg> {
+/// Specialization for one argument
+template<typename Functor, typename ReturnType, typename Arg1>
+class SlotImpl<Functor, ReturnType, Arg1, SigImpl::EmptyArg, SigImpl::EmptyArg>: public Slot<ReturnType, Arg1> {
 public:
-    virtual void operator()(Arg1 arg1, EmptyArg, EmptyArg)
-    { m_functor(arg1); }
+    virtual ReturnType operator()(Arg1 arg1) { return m_functor(arg1); }
 
-    Slot(Functor functor) : m_functor(functor) {}
+    SlotImpl(Functor functor) : m_functor(functor) {}
 
 private:
     Functor m_functor;
 };
 
-// specialization for no arguments
-template<typename Functor>
-class Slot<EmptyArg, EmptyArg, EmptyArg, Functor>: public SlotTemplate<EmptyArg, EmptyArg, EmptyArg> {
+/// Specialization for no arguments
+template<typename Functor, typename ReturnType>
+class SlotImpl<Functor, ReturnType, SigImpl::EmptyArg, SigImpl::EmptyArg, SigImpl::EmptyArg>: public Slot<ReturnType> {
 public:
-    virtual void operator()(EmptyArg, EmptyArg, EmptyArg)
-    { m_functor(); }
+    virtual ReturnType operator()() { return m_functor(); }
 
-    Slot(Functor functor) : m_functor(functor) {}
+    SlotImpl(Functor functor) : m_functor(functor) {}
 
 private:
     Functor m_functor;
 };
 
-} // namespace SigImpl
-
 } // namespace FbTk
 
-
 #endif // FBTK_SLOT_H