xrb_signalhandler.hpp

// ///////////////////////////////////////////////////////////////////////////
// xrb_signalhandler.hpp by Victor Dods, created 2005/01/15
// ///////////////////////////////////////////////////////////////////////////
// Unless a different license was explicitly granted in writing by the
// copyright holder (Victor Dods), this software is freely distributable under
// the terms of the GNU General Public License, version 2.  Any works deriving
// from this work must also be released under the GNU GPL.  See the included
// file LICENSE for details.
// ///////////////////////////////////////////////////////////////////////////

#if !defined(_XRB_SIGNALHANDLER_HPP_)
#define _XRB_SIGNALHANDLER_HPP_

#include "xrb.hpp"

#include <algorithm>
#include <list>

namespace Xrb
{

class SignalHandler;

class SignalSenderBase;
template <typename ReceiverAnalog, typename TransformationSet> class SignalSender;
class SignalSender0;
template <typename T> class SignalSender1;
template <typename T, typename U> class SignalSender2;

class SignalReceiverBase;
template <typename SenderAnalog> class SignalReceiver;
class SignalReceiver0;
template <typename T> class SignalReceiver1;
template <typename T, typename U> class SignalReceiver2;

class SignalSenderBase
{
public:

    virtual ~SignalSenderBase () { }

    inline bool IsBlocking () const
    {
        return m_is_blocking;
    }
    inline SignalHandler *Owner () const
    {
        return m_owner;
    }

    inline void SetIsBlocking (bool is_blocking)
    {
        m_is_blocking = is_blocking;
    }

    virtual void DetachAll () const = 0;

protected:

    SignalSenderBase (SignalHandler *owner);

private:

    bool m_is_blocking;
    SignalHandler *m_owner;
}; // end of class SignalSenderBase

template <typename ReceiverAnalog, typename TransformationSet>
struct Attachment
{
    ReceiverAnalog *m_receiver;
    TransformationSet m_transformation_set;

    inline Attachment (
        ReceiverAnalog *receiver,
        TransformationSet transformation_set)
        :
        m_receiver(receiver),
        m_transformation_set(transformation_set)
    { }
    inline Attachment (Attachment const &attachment)
        :
        m_receiver(attachment.m_receiver),
        m_transformation_set(attachment.m_transformation_set)
    { }

    inline bool operator == (ReceiverAnalog const *receiver) const
    {
        return m_receiver == receiver;
    }
}; // end of struct Attachment<ReceiverAnalog, TransformationSet>

template <typename ReceiverAnalog, typename TransformationSet>
class SignalSender : public SignalSenderBase
{
public:

    virtual ~SignalSender ()
    {
        // this is a non-virtual call to SignalSender's DetachAll.
        SignalSender<ReceiverAnalog, TransformationSet>::DetachAll();
    }

    inline Attachment<ReceiverAnalog, TransformationSet> const &IteratorAttachment () const
    {
        ASSERT1(m_iterator != m_iterator_end);
        return *m_iterator;
    }
    inline bool IsIteratorAttachmentValid () const
    {
        return m_iterator != m_iterator_end;
    }
    inline void FetchFirstIteratorAttachment () const
    {
        m_iterator = m_attachment_list.begin();
        m_iterator_end = m_attachment_list.end();
    }
    inline void FetchNextIteratorAttachment () const
    {
        ASSERT1(m_iterator != m_iterator_end);
        ++m_iterator;
    }

    inline void Detach (ReceiverAnalog const *receiver) const
    {
        DetachPrivate(receiver, true);
    }

    virtual void DetachAll () const
    {
        for (typename AttachmentList::iterator
                it = m_attachment_list.begin(),
                it_end = m_attachment_list.end();
             it != it_end;
             ++it)
        {
            ASSERT1(it->m_receiver != NULL);
            it->m_receiver->DetachPrivate(this, false);
        }
        m_attachment_list.clear();
    }

protected:

    SignalSender (SignalHandler *owner)
        :
        SignalSenderBase(owner)
    { }

private:

    inline void Attach (
        TransformationSet transformation_set,
        ReceiverAnalog const *receiver) const
    {
        AttachPrivate(transformation_set, receiver, true);
    }

    template <typename SenderAnalog>
    void AttachPrivate (
        TransformationSet transformation_set,
        SignalReceiver<SenderAnalog> const *receiver,
        bool reciprocate) const
    {
        ASSERT1(receiver != NULL);
        // upcast to the real type of ReceiverAnalog (technically invalid,
        // yes, but on the other hand, shut the hell up!)
        ReceiverAnalog const *real_receiver =
            static_cast<ReceiverAnalog const *>(receiver);
        // make sure that this receiver is not already in the attachment list.
        typename AttachmentList::iterator it =
            std::find(
                m_attachment_list.begin(),
                m_attachment_list.end(),
                real_receiver);
        ASSERT1(it == m_attachment_list.end() && "receiver is already attached");
        // add it to the attachment list (this const_cast ugliness
        // is limited to this line only).
        m_attachment_list.push_back(
            Attachment<ReceiverAnalog, TransformationSet>(
                const_cast<ReceiverAnalog *>(real_receiver),
                transformation_set));
        // if necessary, have the receiver reciprocate the attachment
        if (reciprocate)
            receiver->AttachPrivate(this);
    }

    template <typename SenderAnalog>
    void DetachPrivate (
        SignalReceiver<SenderAnalog> const *receiver,
        bool reciprocate) const
    {
        ASSERT1(receiver != NULL);
        // upcast to the real type of ReceiverAnalog (technically invalid,
        // yes, but on the other hand, shut the hell up!)
        ReceiverAnalog const *real_receiver =
            static_cast<ReceiverAnalog const *>(receiver);
        // find which attachment matches the given receiver.
        typename AttachmentList::iterator it =
            std::find(
                m_attachment_list.begin(),
                m_attachment_list.end(),
                real_receiver);
        ASSERT1(it != m_attachment_list.end() && "non-existent receiver");
        // remove it from the attachment list
        m_attachment_list.erase(it);
        // if necessary, have the receiver reciprocate the detachment
        if (reciprocate)
            receiver->DetachPrivate(this, false);
    }

    typedef std::list<Attachment<ReceiverAnalog, TransformationSet> > AttachmentList;

    mutable typename AttachmentList::iterator m_iterator;
    mutable typename AttachmentList::iterator m_iterator_end;
    mutable AttachmentList m_attachment_list;

    template <typename SenderAnalog> friend class SignalReceiver;
    friend class SignalHandler;
}; // end of class SignalSender<ReceiverAnalog, TransformationSet>

struct TransformationSet0
{
};

class SignalSender0 : public SignalSender<SignalReceiver0, TransformationSet0>
{
public:

    SignalSender0 (SignalHandler *owner)
        :
        SignalSender<SignalReceiver0, TransformationSet0>(owner)
    { }
    virtual ~SignalSender0 () { }

    void Signal ();
}; // end of class SignalSender0

template <typename T>
struct TransformationSet1
{
    typedef T (*TransformationFunction)(T);

    TransformationFunction m_transformation_function;

    inline TransformationSet1 (TransformationFunction transformation_function)
        :
        m_transformation_function(transformation_function)
    { }
};

template <typename T>
class SignalSender1 : public SignalSender<SignalReceiver1<T>, TransformationSet1<T> >
{
public:

    SignalSender1 (SignalHandler *owner)
        :
        SignalSender<SignalReceiver1<T>, TransformationSet1<T> >(owner)
    { }
    virtual ~SignalSender1 () { }

    void Signal (T param)
    {
        // we can early out if the sender is blocked (since it can't
        // cause any receiver callbacks, there's no way for it to become
        // unblocked during this call to Signal().
        if (this->Owner()->IsBlockingSenders() || this->IsBlocking())
            return;

        // iterate through all attached ports and call their
        // callbacks, if outgoing signals aren't blocked
        this->FetchFirstIteratorAttachment();
        while (this->IsIteratorAttachmentValid())
        {
            Attachment<SignalReceiver1<T>, TransformationSet1<T> > const &attachment =
                this->IteratorAttachment();

            ASSERT1(attachment.m_receiver != NULL);
            // only proceed with the callback if this sender's owner isn't
            // blocking senders and this sender isn't blocking itself.
            // this code can't be above this for-loop because the blocking
            // status might change during one of the callbacks.
            if (!this->Owner()->IsBlockingSenders() && !this->IsBlocking())
            {
                // only call the callback if the receiver's owner isn't blocking
                // all receivers and if the receiver isn't blocking itself
                if (!attachment.m_receiver->Owner()->IsBlockingReceivers() &&
                    !attachment.m_receiver->IsBlocking())
                {
                    (attachment.m_receiver->Owner()->*attachment.m_receiver->m_callback)(
                        (attachment.m_transformation_set.m_transformation_function != NULL) ?
                        attachment.m_transformation_set.m_transformation_function(param) :
                        param);
                }
            }
            // we can early out if this sender becomes blocked.
            else
                return;

            this->FetchNextIteratorAttachment();
        }
    }
}; // end of class SignalSender1<T>

template <typename T, typename U>
struct TransformationSet2
{
    typedef T (*TransformationFunction1)(T);
    typedef U (*TransformationFunction2)(U);

    TransformationFunction1 m_transformation_function_1;
    TransformationFunction2 m_transformation_function_2;

    inline TransformationSet2 (
        TransformationFunction1 transformation_function_1,
        TransformationFunction2 transformation_function_2)
        :
        m_transformation_function_1(transformation_function_1),
        m_transformation_function_2(transformation_function_2)
    { }
};

template <typename T, typename U>
class SignalSender2 : public SignalSender<SignalReceiver2<T, U>, TransformationSet2<T, U> >
{
public:

    SignalSender2 (SignalHandler *owner)
        :
        SignalSender<SignalReceiver2<T, U>, TransformationSet2<T, U> >(owner)
    { }
    virtual ~SignalSender2 () { }

    void Signal (T param_1, U param_2)
    {
        // we can early out if the sender is blocked (since it can't
        // cause any receiver callbacks, there's no way for it to become
        // unblocked during this call to Signal().
        if (this->Owner()->IsBlockingSenders() || this->IsBlocking())
            return;

        // iterate through all attached ports and call their
        // callbacks, if outgoing signals aren't blocked
        this->FetchFirstIteratorAttachment();
        while (this->IsIteratorAttachmentValid())
        {
            Attachment<SignalReceiver2<T, U>, TransformationSet2<T, U> > const &attachment =
                this->IteratorAttachment();

            ASSERT1(attachment.m_receiver != NULL);
            // only proceed with the callback if this sender's owner isn't
            // blocking senders and this sender isn't blocking itself.
            // this code can't be above this for-loop because the blocking
            // status might change during one of the callbacks.
            if (!this->Owner()->IsBlockingSenders() && !this->IsBlocking())
            {
                // only call the callback if the receiver's owner isn't blocking
                // all receivers and if the receiver isn't blocking itself
                if (!attachment.m_receiver->Owner()->IsBlockingReceivers() &&
                    !attachment.m_receiver->IsBlocking())
                {
                    (attachment.m_receiver->Owner()->*attachment.m_receiver->m_callback)(
                        (attachment.m_transformation_set.m_transformation_function_1 != NULL) ?
                        attachment.m_transformation_set.m_transformation_function_1(param_1) :
                        param_1,
                        (attachment.m_transformation_set.m_transformation_function_2 != NULL) ?
                        attachment.m_transformation_set.m_transformation_function_2(param_2) :
                        param_2
                        );
                }
            }
            // we can early out if this sender becomes blocked.
            else
                return;

            this->FetchNextIteratorAttachment();
        }
    }
}; // end of class SignalSender2<T, U>





class SignalReceiverBase
{
public:

    virtual ~SignalReceiverBase () { }

    inline bool IsBlocking () const
    {
        return m_is_blocking;
    }
    inline SignalHandler *Owner () const
    {
        return m_owner;
    }

    inline void SetIsBlocking (bool is_blocking)
    {
        m_is_blocking = is_blocking;
    }

    virtual void DetachAll () const = 0;

protected:

    SignalReceiverBase (SignalHandler *owner);

private:

    bool m_is_blocking;
    SignalHandler *m_owner;
}; // end of class SignalReceiverBase

template <typename SenderAnalog>
class SignalReceiver : public SignalReceiverBase
{
public:

    virtual ~SignalReceiver ()
    {
        // this is a non-virtual call to SignalReceiver's DetachAll.
        SignalReceiver<SenderAnalog>::DetachAll();
    }

    inline void Detach (SenderAnalog const *sender) const
    {
        DetachPrivate(sender, true);
    }

    virtual void DetachAll () const
    {
        for (typename AttachmentList::iterator
                it = m_attachment_list.begin(),
                it_end = m_attachment_list.end();
             it != it_end;
             ++it)
        {
            SenderAnalog const *sender = *it;
            ASSERT1(sender != NULL);
            sender->DetachPrivate(this, false);
        }
        m_attachment_list.clear();
    }

protected:

    SignalReceiver (SignalHandler *owner)
        :
        SignalReceiverBase(owner)
    { }

private:

    template <typename ReceiverAnalog, typename TransformationSet>
    void AttachPrivate (
        SignalSender<ReceiverAnalog, TransformationSet> const *sender) const
    {
        ASSERT1(sender != NULL);
        // upcast to the real type of SenderAnalog (technically invalid,
        // yes, but on the other hand, shut the hell up!)
        SenderAnalog const *real_sender =
            static_cast<SenderAnalog const *>(sender);
        // make sure that this sender is not already in the attachment list
        typename AttachmentList::iterator it =
            std::find(
                m_attachment_list.begin(),
                m_attachment_list.end(),
                real_sender);
        ASSERT1(it == m_attachment_list.end() && "sender is already attached");
        // add it to the attachment list
        m_attachment_list.push_back(real_sender);
    }

    template <typename ReceiverAnalog, typename TransformationSet>
    void DetachPrivate (
        SignalSender<ReceiverAnalog, TransformationSet> const *sender,
        bool reciprocate) const
    {
        ASSERT1(sender != NULL);
        // upcast to the real type of SenderAnalog (technically invalid,
        // yes, but on the other hand, shut the hell up!)
        SenderAnalog const *real_sender =
            static_cast<SenderAnalog const *>(sender);
        // find which attachment matches the given sender.
        typename AttachmentList::iterator it =
            std::find(
                m_attachment_list.begin(),
                m_attachment_list.end(),
                real_sender);
        ASSERT1(it != m_attachment_list.end() && "non-existent sender");
        // remove it from the attachment list
        m_attachment_list.erase(it);
        // if necessary, have the sender reciprocate the detachment
        if (reciprocate)
            sender->DetachPrivate(this, false);
    }

    typedef std::list<SenderAnalog const *> AttachmentList;

    mutable AttachmentList m_attachment_list;

    template <typename ReceiverAnalog, typename TransformationSet> friend class SignalSender;
}; // end of class SignalReceiver<SenderAnalog>

class SignalReceiver0 : public SignalReceiver<SignalSender0>
{
public:

    typedef void (SignalHandler::*CallbackType)();

    template <typename SignalHandlerSubclass>
    SignalReceiver0 (
        void (SignalHandlerSubclass::*callback)(),
        SignalHandler *owner)
        :
        SignalReceiver<SignalSender0>(owner)
    {
        ASSERT1(callback != NULL);
        m_callback = static_cast<CallbackType>(callback);
    }

private:

    CallbackType m_callback;

    friend class SignalSender0;
}; // end of class SignalReceiver0

template <typename T>
class SignalReceiver1 : public SignalReceiver<SignalSender1<T> >
{
public:

    typedef void (SignalHandler::*CallbackType)(T);

    template <typename SignalHandlerSubclass>
    SignalReceiver1 (
        void (SignalHandlerSubclass::*callback)(T),
        SignalHandler *owner)
        :
        SignalReceiver<SignalSender1<T> >(owner)
    {
        ASSERT1(callback != NULL);
        m_callback = static_cast<CallbackType>(callback);
    }

private:

    CallbackType m_callback;

    friend class SignalSender1<T>;
}; // end of class SignalReceiver1<T>

template <typename T, typename U>
class SignalReceiver2 : public SignalReceiver<SignalSender2<T, U> >
{
public:

    typedef void (SignalHandler::*CallbackType)(T, U);

    template <typename SignalHandlerSubclass>
    SignalReceiver2 (
        void (SignalHandlerSubclass::*callback)(T, U),
        SignalHandler *owner)
        :
        SignalReceiver<SignalSender2<T, U> >(owner)
    {
        ASSERT1(callback != NULL);
        m_callback = static_cast<CallbackType>(callback);
    }

private:

    CallbackType m_callback;

    friend class SignalSender2<T, U>;
}; // end of class SignalReceiver2<T, U>

class SignalHandler
{
public:

    SignalHandler ();
    virtual ~SignalHandler ();

    bool IsBlockingSenders () const
    {
        return m_is_blocking_senders;
    }
    bool IsBlockingReceivers () const
    {
        return m_is_blocking_receivers;
    }

    void SetIsBlockingSenders (bool const is_blocking_senders)
    {
        m_is_blocking_senders = is_blocking_senders;
    }
    void SetIsBlockingReceivers (bool const is_blocking_receivers)
    {
        m_is_blocking_receivers = is_blocking_receivers;
    }

    void DetachAll ();

    static inline void Connect0 (
        SignalSender0 const *sender,
        SignalReceiver0 const *receiver)
    {
        ASSERT1(sender != NULL);
        ASSERT1(receiver != NULL);
        sender->Attach(TransformationSet0(), receiver);
    }

    template <typename T>
    static inline void Connect1 (
        SignalSender1<T> const *sender,
        SignalReceiver1<T> const *receiver)
    {
        ASSERT1(sender != NULL);
        ASSERT1(receiver != NULL);
        sender->Attach(TransformationSet1<T>(NULL), receiver);
    }
    template <typename T>
    static inline void Connect1 (
        SignalSender1<T> const *sender,
        T (*transformation_function)(T),
        SignalReceiver1<T> const *receiver)
    {
        ASSERT1(sender != NULL);
        ASSERT1(receiver != NULL);
        sender->Attach(TransformationSet1<T>(transformation_function), receiver);
    }

    template <typename T, typename U>
    static inline void Connect2 (
        SignalSender2<T, U> const *sender,
        SignalReceiver2<T, U> const *receiver)
    {
        ASSERT1(sender != NULL);
        ASSERT1(receiver != NULL);
        sender->Attach(
            TransformationSet2<T, U>(NULL, NULL),
            receiver);
    }
    template <typename T, typename U>
    static inline void Connect2 (
        SignalSender2<T, U> const *sender,
        T (*transformation_function_1)(T),
        U (*transformation_function_2)(U),
        SignalReceiver2<T, U> const *receiver)
    {
        ASSERT1(sender != NULL);
        ASSERT1(receiver != NULL);
        sender->Attach(
            TransformationSet2<T, U>(transformation_function_1, transformation_function_2),
            receiver);
    }

private:

    void AddSender (SignalSenderBase const *sender);
    void AddReceiver (SignalReceiverBase const *receiver);

    typedef std::list<SignalSenderBase const *> SignalSenderList;

    typedef std::list<SignalReceiverBase const *> SignalReceiverList;

    bool m_is_blocking_senders;
    bool m_is_blocking_receivers;
    SignalSenderList m_sender_list;
    SignalReceiverList m_receiver_list;

    friend class SignalSenderBase;
    friend class SignalReceiverBase;
}; // end of class SignalHandler

} // end of namespace Xrb

#endif // !defined(_XRB_SIGNALHANDLER_HPP_)

---