Signal.h

/*
 * Copyright (C) 2005-2013 by Dr. Marc Boris Duerner
 * 
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 of the License, or (at your option) any later version.
 * 
 * As a special exception, you may use this file as part of a free
 * software library without restriction. Specifically, if other files
 * instantiate templates or use macros or inline functions from this
 * file, or you compile this file and link it with other files to
 * produce an executable, this file does not by itself cause the
 * resulting executable to be covered by the GNU General Public
 * License. This exception does not however invalidate any other
 * reasons why the executable file might be covered by the GNU Library
 * General Public License.
 * 
 * This library is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * Lesser General Public License for more details.
 * 
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
 */
 
#ifndef Pt_Signal_h
#define Pt_Signal_h
 
#include <Pt/Api.h>
#include <Pt/Void.h>
#include <Pt/Event.h>
#include <Pt/Slot.h>
#include <Pt/Function.h>
#include <Pt/Method.h>
#include <Pt/ConstMethod.h>
#include <Pt/Connectable.h>
#include <map>
 
namespace Pt {
 
class PT_API SignalBase : public Connectable
{
    public:
        struct PT_API Sentry
        {
            Sentry(SignalBase* signal);
 
            ~Sentry();
 
            void detachAll();
 
            void detach();
 
            bool operator!() const
            { return _signal == 0; }
 
            SignalBase* _signal;
            Sentry*     _next;
        };
 
        SignalBase();
 
        ~SignalBase();
 
        SignalBase& operator=(const SignalBase& other);
 
        virtual void onConnectionOpen(const Connection& c);
 
        virtual void onConnectionClose(const Connection& c);
 
    protected:
        void disconnectSlots();
 
        void disconnectSlot(const Slot&);
 
    private:
        Sentry* _sentry;
        bool _sending;
        bool _dirty;
};
 
#include <Pt/Signal.tpp>
 
struct PT_API CompareEventTypeInfo
{
    bool operator()( const std::type_info* t1,
                     const std::type_info* t2 ) const;
};
 
template <>
class PT_API Signal<const Pt::Event&> : public Connectable
                                      , protected NonCopyable
{
    struct PT_API Sentry
    {
        Sentry(Signal* signal);
 
        ~Sentry();
 
        void detach();
 
        void detachAll();
 
        bool operator!() const
        { return _signal == 0; }
 
        Signal*  _signal;
        Sentry*  _next;
    };
 
    class IEventRoute
    {
        public:
            IEventRoute(Connection& target)
            : _target(target)
            { }
 
            virtual ~IEventRoute() {}
 
            virtual void route(const Pt::Event& ev)
            {
                typedef Invokable<const Pt::Event&> InvokableT;
                const InvokableT* invokable = static_cast<const InvokableT*>( _target.slot()->callable() );
                invokable->invoke(ev);
            }
 
            Connection& connection()
            { return _target; }
 
            bool isValid() const
            { return _target.isValid(); }
 
        private:
            Connection _target;
    };
 
    template <typename EventT>
    class EventRoute : public IEventRoute
    {
        public:
            EventRoute(Connection& target)
            : IEventRoute(target)
            { }
 
            virtual void route(const Pt::Event& ev)
            {
                typedef Invokable<const Pt::Event&> InvokableT;
                const InvokableT* invokable = static_cast<const InvokableT*>( connection().slot()->callable() );
 
                const EventT& event = static_cast<const EventT&>(ev);
                invokable->invoke(event);
            }
    };
 
    typedef std::multimap< const std::type_info*,
                           IEventRoute*,
                           CompareEventTypeInfo > RouteMap;
 
    public:
        Signal();
 
        ~Signal();
 
        void send(const Pt::Event& ev);
 
        template <typename EventT>
        Connection connect( const BasicSlot<void, const EventT&>& slot )
        {
            Connection conn( *this, slot.clone() );
            EventT* selectAddRouteOverload = 0;
            this->addRoute(conn, selectAddRouteOverload);
            return conn;
        }
 
        void disconnect();
 
        template <typename R, typename EventT>
        void disconnect(const BasicSlot<R, const EventT&>& slot)
        {
            this->removeRoute(slot);
        }
 
        virtual void onConnectionOpen(const Connection& c);
 
        virtual void onConnectionClose(const Connection& c);
 
    protected:
        void addRoute(Connection& conn, const Pt::Event*)
        {
            this->addRoute( 0, new IEventRoute(conn) );
        }
 
        template <typename EventT>
        void addRoute(Connection& conn, const EventT*)
        {
            const std::type_info& ti = typeid(EventT);
            this->addRoute( &ti, new EventRoute<EventT>(conn) );
        }
 
        void addRoute(const std::type_info* ti, IEventRoute* route);
 
        void removeRoute(const Slot& slot);
 
        // TODO: Pt 2.0 (better performance)
 
        //template <typename R>
        //void removeRoute(const BasicSlot<R, const Event&>& slot)
        //{
        //    this->removeRoute(0, slot);
        //}
 
        //template <typename R, typename EventT>
        //void removeRoute(const BasicSlot<R, const EventT&>& slot)
        //{
        //    const std::type_info& ti = typeid(EventT);
        //    this->removeRoute(&ti, slot);
        //}
 
        void removeRoute(const std::type_info* ti, const Slot& slot);
 
    private:
        RouteMap _routes;
        Sentry* _sentry;
        bool _sending;
        bool _dirty;
};
 
 
template <typename R, class EventT>
Connection operator +=(Signal<const Pt::Event&>& signal, const BasicSlot<R, EventT>& slot)
{
    return signal.connect( slot );
}
 
template <typename R>
Connection operator +=(Signal<const Pt::Event&>& signal, const BasicSlot<R, const Pt::Event&>& slot)
{
    return signal.connect( slot );
}
 
 
template <typename R, class EventT>
void operator -=(Signal<const Pt::Event&>& signal, const BasicSlot<R, EventT>& slot)
{
    signal.disconnect( slot );
}
 
template <typename R>
void operator -=(Signal<const Pt::Event&>& signal, const BasicSlot<R, const Pt::Event&>& slot)
{
    signal.disconnect( slot );
}
 
} // namespace Pt
 
#endif