ObjectDispatcher.h

Go to the documentation of this file.

/*

Copyright (C) 2006-2007 by Peter Dimov.

This file is part of Calitko (http://www.calitko.org).

Calitko is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2 of the License, or
(at your option) any later version.

Calitko 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with Calitko; if not, write to the Free Software
Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA

*/

#ifndef UTILS__OBJECT_DISPATCHER_H
#define UTILS__OBJECT_DISPATCHER_H

#include "Imports.h"
#include "Callable.h"

namespace Utils {


template <typename DispatchBase, typename Sender = void>
class ObjectDispatcher
{
public:
    typedef Callable <void (const DispatchBase &)>  DispatchBaseHandler;
    typedef Callable <void (const DispatchBase &, Sender *)>
                                                    DispatchBaseSenderHandler;

    ObjectDispatcher()
     :  catchAllHandlers(), handlers(), notHandledHandlers()
    {
    }

    ~ObjectDispatcher()
    {
        foreach (Handler *handler, catchAllHandlers + handlers.values()
                                    + notHandledHandlers)
            delete handler;

        catchAllHandlers.clear();
        handlers.clear();
        notHandledHandlers.clear();
    }

    void registerCatchAllHandler (const DispatchBaseHandler &handler)
    {
        doRegisterCatchAllHandler (
                            new TypeHandler <DispatchBaseHandler> (handler));
    }

    void registerCatchAllHandler (const DispatchBaseSenderHandler &handler)
    {
        doRegisterCatchAllHandler (
            new TypeHandlerWithSender <DispatchBaseSenderHandler> (handler));
    }

    template <typename T>
    void registerTypeHandler (const Callable <void (const T &)> &handler)
    {
        doRegisterHandler <T> (
                    new TypeHandler <Callable <void (const T &)> > (handler));
    }

    template <typename T>
    void registerTypeHandler (const Callable <void (const T &, Sender *)> &handler)
    {
        doRegisterHandler <T> (new TypeHandlerWithSender
                        <Callable <void (const T &, Sender *)> > (handler));
    }

    template <typename T>
    void unregisterTypeHandler (const Callable <void (const T &)> &handler)
    {
        doUnregisterHandler <T> (
                    new TypeHandler <Callable <void (const T &)> > (handler));
    }

    template <typename T>
    void unregisterTypeHandler (const Callable <void (const T &, Sender *)> &handler)
    {
        doUnregisterHandler <T> (new TypeHandlerWithSender
                        <Callable <void (const T &, Sender *)> > (handler));
    }

    void registerNotHandledHandler (const DispatchBaseHandler &handler)
    {
        doRegisterNotHandledHandler (
                        new TypeHandler <DispatchBaseHandler> (handler));
    }

    void registerNotHandledHandler (const DispatchBaseSenderHandler &handler)
    {
        doRegisterNotHandledHandler (
            new TypeHandlerWithSender <DispatchBaseSenderHandler> (handler));
    }


    bool dispatch (const DispatchBase &object, Sender *sender = 0)
    {
        dispatchToCatchAllHandlers (object, sender);
        if (dispatchToTypeHandlers (object, sender))
            return true;
        dispatchToNotHandledHandlers (object, sender);
        return false;
    }

private:
    struct Handler; // Declared below.

    void doRegisterCatchAllHandler (Handler *handler)
    {
        catchAllHandlers.append (handler);
    }

    template <typename T>
    void doRegisterHandler (Handler *handler)
    {
        const std::type_info *type = &typeid (T);
        handlers.insert (type, handler);
    }

    template <typename T>
    void doUnregisterHandler (Handler *handler)
    {
        const std::type_info *type = &typeid (T);
        QMultiMap <const std::type_info *, Handler *> newHandlers;
        typename QMultiMap <const std::type_info *, Handler *>::iterator it, end;
        for (it = handlers.begin(), end = handlers.end(); it != end; ++it)
            if (it.key() == type && handler->operator== (*it.value()))
                delete it.value();
            else
                newHandlers.insert (it.key(), it.value());
        delete handler;
        handlers = newHandlers;
    }

    void doRegisterNotHandledHandler (Handler *handler)
    {
        notHandledHandlers.append (handler);
    }

    void dispatchToCatchAllHandlers (const DispatchBase &object, Sender *sender)
    {
        foreach (Handler *handler, catchAllHandlers)
            handler->handle (object, sender);
    }


    bool dispatchToTypeHandlers (const DispatchBase &object, Sender *sender)
    {
        const std::type_info *type = &typeid (object);
        QListIterator <Handler *> list (handlers.values (type));
        if (!list.hasNext())
            return false; // List was empty, we have not dispatched.
        list.toBack();
        while (list.hasPrevious())
            list.previous()->handle (object, sender);
        return true; // List was not empty, we dispatched.
    }

    void dispatchToNotHandledHandlers (const DispatchBase &object,
                                       Sender *sender)
    {
        foreach (Handler *handler, notHandledHandlers)
            handler->handle (object, sender);
    }

    struct Handler
    {
        bool operator == (const Handler &other) const
        { return typeid (*this) == typeid (other) && isEqual (other); }

        virtual ~Handler() {}
        virtual void handle (const DispatchBase &, Sender *) = 0;
        virtual bool isEqual (const Handler &) const = 0;
    };

    template <typename Callable>
    class TypeHandler : public Handler
    {
    public:
        TypeHandler (const Callable &c)
        : callable (c) {}

        void handle (const DispatchBase &packet, Sender *)
        { callable (dynamic_cast <typename Callable::ParameterType1>
                                                            (packet)); }

        bool isEqual (const Handler &other) const
        { return dynamic_cast <const TypeHandler &> (other).callable
                    == callable; }

    private:
        Callable callable;
    };

    template <typename Callable>
    class TypeHandlerWithSender : public Handler
    {
    public:
        TypeHandlerWithSender (const Callable &c)
        : callable (c) {}

        void handle (const DispatchBase &packet, Sender *sender)
        { callable (dynamic_cast <typename Callable::ParameterType1>
                                                        (packet), sender); }

        bool isEqual (const Handler &other) const
        { return dynamic_cast <const TypeHandlerWithSender &> (other)
                    .callable == callable; }

    private:
        Callable callable;
    };

    QList <Handler *>                               catchAllHandlers;
    QMultiMap <const std::type_info *, Handler *>   handlers;
    QList <Handler *>                               notHandledHandlers;
};

} // namespace Utils

#endif // UTILS__OBJECT_DISPATCHER_H

Copyright © 2006 Peter Dimov.
Powered by Doxygen.