Added super-experimental proof-of-concept for SignalCall and DeferredSignal

1 files changed, 200 insertions, 0 deletions

diff --git a/src/tests/signalcall.cpp b/src/tests/signalcall.cpp
new file mode 100644
index 0000000..8b4b174
--- /dev/null
+++ b/src/tests/signalcall.cpp
@@ -0,0 +1,200 @@
+#include <bu/signals.h>
+#include <bu/sio.h>
+#include <bu/randomcmwc.h>
+
+#include <time.h>
+
+template<typename ret>
+class SignalCallable
+{
+public:
+    SignalCallable()
+    {
+    }
+
+    virtual ~SignalCallable()
+    {
+    }
+
+    virtual ret call()=0;
+};
+
+template<typename ret>
+class SignalCall0 : public SignalCallable<ret>
+{
+public:
+    SignalCall0( const Bu::Signal0<ret> &sRef ) :
+        sRef( sRef )
+    {
+    }
+
+    virtual ~SignalCall0()
+    {
+    }
+
+    virtual ret call()
+    {
+        return sRef();
+    }
+
+private:
+    Bu::Signal0<ret> sRef;
+};
+
+template<typename ret, typename p1t>
+class SignalCall1 : public SignalCallable<ret>
+{
+public:
+    SignalCall1( const Bu::Signal1<ret, p1t> &sRef, const p1t &p1 ) :
+        sRef( sRef ), p1( p1 )
+    {
+    }
+
+    virtual ~SignalCall1()
+    {
+    }
+
+    virtual ret call()
+    {
+        return sRef( p1 );
+    }
+
+private:
+    Bu::Signal1<ret, p1t> sRef;
+    p1t p1;
+};
+
+template<typename ret, typename p1t, typename p2t>
+class SignalCall2 : public SignalCallable<ret>
+{
+public:
+    SignalCall2( const Bu::Signal2<ret, p1t, p2t> &sRef, const p1t &p1, const p2t &p2 ) :
+        sRef( sRef ), p1( p1 ), p2( p2 )
+    {
+    }
+
+    virtual ~SignalCall2()
+    {
+    }
+
+    virtual ret call()
+    {
+        return sRef( p1, p2 );
+    }
+
+private:
+    Bu::Signal2<ret, p1t, p2t> sRef;
+    p1t p1;
+    p2t p2;
+};
+
+template<typename ret, typename p1t, typename p2t>
+class DeferredSignal2 : public Bu::Signal2<ret, p1t, p2t>
+{
+    typedef Bu::Signal2<ret, p1t, p2t> Parent;
+public:
+    DeferredSignal2() : Parent() { }
+    DeferredSignal2( Bu::_Slot2<ret, p1t, p2t> *pCb ) : Parent( pCb ) { }
+    DeferredSignal2( const DeferredSignal2<ret, p1t, p2t> &rSrc ) :
+        Parent( (const Parent &)rSrc ) { }
+    virtual ~DeferredSignal2() { }
+
+    void operator()( p1t p1, p2t p2 )
+    {
+        lCalls.enqueue( SignalCall2<ret, p1t, p2t>( (Parent &)*this, p1, p2 ) );
+    }
+
+    DeferredSignal2<ret, p1t, p2t> &operator=( const Bu::Signal2<ret, p1t, p2t> &rhs )
+    {
+        ((Parent &)*this) = rhs;
+        return *this;
+    }
+
+    bool operator==( const Bu::Signal2<ret, p1t, p2t> &rhs ) const
+    {
+        return ((Parent &)*this) == rhs;
+    }
+
+    bool hasNext() const
+    {
+        return !lCalls.isEmpty();
+    }
+
+    ret callNext()
+    {
+        return lCalls.dequeue().call();
+    }
+
+private:
+    Bu::List< SignalCall2<ret, p1t, p2t> > lCalls;
+};
+
+
+//
+// Slots
+//
+int area( int x, int y )
+{
+    return x*y;
+}
+
+int diff( int x, int y )
+{
+    return x-y;
+}
+
+int thing( int x, int y )
+{
+    return x*x-y*y;
+}
+
+int square( int x )
+{
+    return x*x;
+}
+
+int rand()
+{
+    Bu::RandomCmwc c;
+    c.seed( time( NULL ) );
+    return c.rand();
+}
+
+int main()
+{
+    // Direct use of SignalCall objects
+    Bu::println("Testing SignalCall classes:");
+
+    typedef Bu::List<SignalCallable<int> * > CallList;
+    CallList calls;
+
+    calls.append( new SignalCall2<int, int, int>( Bu::slot(&area), 5, 10 ) );
+    calls.append( new SignalCall2<int, int, int>( Bu::slot(&diff), 5, 15 ) );
+    calls.append( new SignalCall2<int, int, int>( Bu::slot(&thing), 10, 5 ) );
+    calls.append( new SignalCall1<int, int>( Bu::slot(&square), 12 ) );
+    calls.append( new SignalCall0<int>( Bu::slot(&rand)) );
+
+    for( CallList::iterator i = calls.begin(); i; i++ )
+    {
+        Bu::println(" - Result: %1").arg( (*i)->call() );
+    }
+
+    // Deferred Signals:
+    Bu::println("");
+    Bu::println("Testing DeferredSignals:");
+
+    DeferredSignal2<int, int, int> sigArea;
+    sigArea = Bu::slot(&area);
+
+    sigArea( 5, 5 );
+    sigArea( 10, 10 );
+    sigArea( 15, 15 );
+
+    while( sigArea.hasNext() )
+    {
+        Bu::println(" - Result: %1").arg( sigArea.callNext() );
+    }
+
+    return 0;
+}
+