---

testListening.cc

Go to the documentation of this file.

#include <typeinfo>
#include <iostream>
#include <assert.h>
using std::cin;
using std::cout;
using std::cerr;
using std::endl;

#include "TimeStampedEvent.hh"
#include "PolymorphEvent.hh"
#include "Listener.hh"
#include "EventSender.hh"

class TicEvent: public TimeStampedEvent<>
{
    public:
        TicEvent(int bin): _bin(bin) {}
        const int _bin;
};

class TacEvent: public TimeStampedEvent<>, public PolymorphEvent
{
    public:
        TacEvent(int bin): _bin(bin) {}
        virtual void send() const { sendTypedEvent(*this); }
        // following will be flagged by compiler only if TacEvent instantiated
        //virtual void send() const { EventSender<TacEvent>::send(*this); }
        const int _bin;
};

class TicTacListener;
// global listener to affect reaction of TicTacListener to tic events
TicTacListener* ticTacListener2p = NULL;

class TicTacListener: public Listener<TicEvent>, public Listener<TacEvent>
{
    private: 
        size_t countTicsHeard;
        size_t countTacsHeard;
        size_t countAllHeard;
            
    public: 
        TicTacListener(): countTicsHeard(0), countTacsHeard(0), countAllHeard(0) {}
    
    private:
        virtual void processEvent(const TicEvent& event);
        virtual void processEvent(const TacEvent& event)
        {
            countTacsHeard ++;
            countAllHeard ++;
            assert(event.getTimeStamp() == (countAllHeard+1));
            cout << countTacsHeard << ": Heard TacEvent bin "
                 << event._bin << endl;
            assert(EventSender<TicEvent>::isSending());
        }
};

void TicTacListener::processEvent(const TicEvent& event)
{
    countTicsHeard ++;
    countAllHeard ++;
    if (countTicsHeard==1)
        assert(event.getTimeStamp() == countAllHeard);
    else 
        assert(event.getTimeStamp() == (countAllHeard+1));
        
    cout << countTicsHeard << ": Heard TicEvent bin " 
         << event._bin << endl;
    assert(EventSender<TicEvent>::isSending());
    
    switch (countTicsHeard) 
    {
    case 1:
        EventSender<TicEvent>::send(TicEvent(2));
        break;
    case 2:
        Listener<TicEvent>::ignoreThisEvent();
        Listener<TicEvent>::ignoreThisEvent();
        Listener<TicEvent>::ignoreThisEvent();
        break;
    case 3: { 
        const size_t before = EventSender<TacEvent>::getMinNumIgnored();
        Listener<TacEvent>::ignoreThisEvent(); // do nothing
        assert(before == EventSender<TacEvent>::getMinNumIgnored());
        }
        break;
    case 4:
        Listener<TicEvent>::listenForEvents(); // do nothing
        Listener<TicEvent>::ignoreEvents();    // removal queue
        Listener<TicEvent>::ignoreEvents();    // do nothing
        Listener<TicEvent>::listenForEvents(); // elim from removal
        Listener<TicEvent>::listenForEvents(); // do nothing
        Listener<TicEvent>::ignoreEvents();    // removal queue
        Listener<TicEvent>::ignoreEvents();    // do nothing
        break;
    case 5:
        if (this != ticTacListener2p) 
        {
            assert(ticTacListener2p);
            // nada:
            ticTacListener2p->Listener<TicEvent>::ignoreEvents(); 
            ticTacListener2p->Listener<TicEvent>::listenForEvents();
            // nada:
            ticTacListener2p->Listener<TicEvent>::listenForEvents();
            // ignore:
            ticTacListener2p->Listener<TicEvent>::ignoreEvents(); 
            ticTacListener2p->Listener<TicEvent>::listenForEvents();
            // nada:
            ticTacListener2p->Listener<TicEvent>::listenForEvents();
        }
        break;
    default: break;
    }
}

int main()
{
    TicTacListener ticTacListener;
            
    cout << "\n*** Test immediate registration/deregistration ***" << endl;
    cout << "--> Deregister unregistered listener: " << endl;
    assert(EventSender<TicEvent>::getNumListeners() == 0);
    EventSender<TicEvent>::remove(ticTacListener);
    assert(EventSender<TicEvent>::getNumListeners() == 0);
    cout << "--> Register listener: " << endl;
    EventSender<TicEvent>::add(ticTacListener);
    assert(EventSender<TicEvent>::getNumListeners() == 1);
            
    /* NOTE: listener is setup so that first event received (ie
       first call to send())  causes another TicEvent to be
       generated, thereby leading to a recursive flush exception. 
       This is caught here. 
       */
    cout << "\n*** Test recursive event generation ***" << endl;
    try {
        EventSender<TicEvent>::send(TicEvent(1));
    }
    //following line leads to compiler crash:
    catch (const EventSender<TicEvent>::IllegalSendError& rse)
    //catch (const std::logic_error& rse)
    {
        cout << "RecursiveSend Exception properly thrown, message is:" << endl;
        cout << rse.what() << endl;
    }
    assert(! EventSender<TicEvent>::isSending());
    assert(EventSender<TicEvent>::getMinNumIgnored() == 0);
    
    // NOTE: no other event sent should cause 
    // exception so no need to catch
    
    cout << "\n*** Test ignoring events ***" << endl;
    EventSender<TicEvent>::send( TicEvent(2) );
    assert(EventSender<TicEvent>::getMinNumIgnored() == 1);
    EventSender<TicEvent>::send( TicEvent(3) );
    assert(EventSender<TicEvent>::getMinNumIgnored() == 0);
    
    cout << "\n*** Test add/remove during send ***" << endl;
    EventSender<TicEvent>::send( TicEvent(4) );
    assert(EventSender<TicEvent>::getNumListeners() == 0);
    EventSender<TicEvent>::add(ticTacListener);
    
    TicTacListener ticTacListener2;
    ticTacListener2p = &ticTacListener2;
    EventSender<TicEvent>::send( TicEvent(5) );
    assert(EventSender<TicEvent>::getNumListeners() == 2);
    
    cout << "\n*** Done ***" << endl;
}

---