/home/pete/Work/TSE3.svn/tse3/src/tse3/Notifier.h

Go to the documentation of this file.

/*
 * @(#)Notifier.h 3.00 13 July 2000
 *
 * Copyright (c) 2000 Pete Goodliffe (pete@cthree.org)
 *
 * This file is part of TSE3 - the Trax Sequencer Engine version 3.00.
 *
 * This library is modifiable/redistributable under the terms of the GNU
 * General Public License.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; see the file COPYING. If not, write to the Free Software
 * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 *
 */

#ifndef TSE3_NOTIFIER_H
#define TSE3_NOTIFIER_H

#include <iostream>

/******************************************************************************
 * This file contains the implementation of the TSE3 Notifier framework.
 * It is the TSE3 implementation of the observer design pattern (GoF book).
 *
 * The public API (the Notifier and Listener classes) for this framework can
 * be found in the bottom half of the file, the top half contains internal
 * implementation concerns.
 *
 * This implementation can cope with listener event methods with between
 * zero and four parameters. This can be extended, by adding extra code
 * at the positions marked with (*)
 *****************************************************************************/

/*
 * A few annoying presentation choices have been made in this file because
 * KDOC (2.0.36) falls over. Notably some short classes have been spread
 * out, and there is a ";" at the end of the Impl namespace.
 *
 * Other namespaces in the TSE3 library have a similar problem. In each
 * case the trailing ";" is intentional. Sigh.
 */

namespace TSE3
{
    template <class interface_type> class Listener;

    /**************************************************************************
     * Notifier implementation details: ignore this bit
     *************************************************************************/

    namespace Impl
    {
        class def_type
        {
        };

        template <typename T>
        struct arg_count
        {
            enum { count=1 };
        };
        template <>
        struct arg_count<def_type>
        {
            enum { count=0 };
        };

        template<unsigned>
        class num_type
        {
        };

        class void_list
        {
            public:

                void_list();
                void_list(const void_list &);
                ~void_list();

                bool push_back(void *p);

                bool erase(void *p);

                unsigned int size() const;

                void *operator[](unsigned int index);

                bool contains(void *p) const;

            private:

                void_list &operator=(const void_list &);

                class impl;
                impl *pimpl;
        };

        template <class interface_type, typename listener_func,
                  typename p1_type = def_type,
                  typename p2_type = def_type,
                  typename p3_type = def_type,
                  typename p4_type = def_type>                           // (*)
        class Event
        {
            public:

                explicit Event(listener_func func,
                               const p1_type &p1 = p1_type(),
                               const p2_type &p2 = p2_type(),
                               const p3_type &p3 = p3_type(),
                               const p4_type &p4 = p4_type())            // (*)
                    : func(func), p1(p1), p2(p2), p3(p3), p4(p4) {}      // (*)

                void callOnEvery(void_list &listeners)
                {
                    const unsigned int argCount = arg_count<p1_type>::count
                                                + arg_count<p2_type>::count
                                                + arg_count<p3_type>::count
                                                + arg_count<p4_type>::count;
                                                                         // (*)
                    void_list copy_list(listeners);
                    for (unsigned int i = 0; i < copy_list.size(); ++i)
                    {
                        if (listeners.contains(copy_list[i]))
                        {
                            typedef Listener<interface_type> listener_type;
                            interface_type *listener
                                = static_cast<listener_type*>(copy_list[i]);
                            invokeImpl(listener, num_type<argCount>());
                        }
                    }
                }

            private:

                template <class T>
                void invokeImpl(T *listener, num_type<0>) const
                {
                    (void)(listener->*func)();
                }
                template <class T>
                void invokeImpl(T *listener, num_type<1>) const
                {
                    (void)(listener->*func)(p1);
                }
                template <class T>
                void invokeImpl(T *listener, num_type<2>) const
                {
                    (void)(listener->*func)(p1, p2);
                }
                template <class T>
                void invokeImpl(T *listener, num_type<3>) const
                {
                    (void)(listener->*func)(p1, p2, p3);
                }
                template <class T>
                void invokeImpl(T *listener, num_type<4>) const
                {
                    (void)(listener->*func)(p1, p2, p3, p4);
                }                                                        // (*)

                const listener_func  func;
                const p1_type       &p1;
                const p2_type       &p2;
                const p3_type       &p3;
                const p4_type       &p4;                                 // (*)
        };

    };

    /**************************************************************************
     * Public Notifier framework API
     *************************************************************************/

    template <class interface_type>
    class Notifier
    {
        public:

            typedef Listener<interface_type> listener_type;

            friend class listener_type;

        protected:

            Notifier() {}

            typedef typename interface_type::notifier_type c_notifier_type;

            template <typename func_type>
            void notify(func_type func)
            {
                typedef
                    Impl::Event<interface_type, func_type, c_notifier_type*>
                    event_type;
                event_type(func, static_cast<c_notifier_type*>(this))
                    .callOnEvery(listeners);
            }

            template <typename func_type, typename p1_type>
            void notify(func_type func, const p1_type &p1)
            {
                typedef
                    Impl::Event<interface_type, func_type, c_notifier_type *,
                                p1_type>
                    event_type;
                event_type(func, static_cast<c_notifier_type*>(this), p1)
                    .callOnEvery(listeners);
            }

            template <typename func_type, typename p1_type, typename p2_type>
            void notify(func_type func, const p1_type &p1, const p2_type &p2)
            {
                typedef
                    Impl::Event<interface_type, func_type, c_notifier_type *,
                                p1_type, p2_type>
                    event_type;
                event_type(func, static_cast<c_notifier_type*>(this), p1, p2)
                    .callOnEvery(listeners);
            }

            template <typename func_type, typename p1_type, typename p2_type,
                      typename p3_type>
            void notify(func_type func, const p1_type &p1, const p2_type &p2,
                        const p3_type &p3)
            {
                typedef
                    Impl::Event<interface_type, func_type, c_notifier_type *,
                                p1_type, p2_type, p3_type>
                    event_type;
                event_type
                    (func, static_cast<c_notifier_type*>(this), p1, p2, p3)
                    .callOnEvery(listeners);
            }                                                            // (*)

            virtual ~Notifier()
            {
                // LOCK
                for (unsigned int i = 0; i < listeners.size(); ++i)
                {
                    listener_type *l
                        = static_cast<listener_type*>(listeners[i]);
                    l->NotifierImpl_Deleted
                        (static_cast<c_notifier_type*>(this));
                }
            }

            unsigned int numListeners() const { return listeners.size(); }

        private:

            bool attach(listener_type *listener)
            {
                // LOCK
                return listeners.push_back(listener);
            }

            void detach(listener_type *listener)
            {
                // LOCK
                listeners.erase(listener);
            }

            typedef Notifier<interface_type> self_type;

            Notifier(const self_type &);
            self_type &operator=(const self_type &);

            Impl::void_list listeners;
    };

    template <class interface_type>
    class Listener : public interface_type
    {
        public:

            typedef Notifier<interface_type> notifier_type;

            void attachTo(notifier_type *notifier)
            {
                if (notifier->attach(this)) notifiers.push_back(notifier);
            }

            void detachFrom(notifier_type *notifier)
            {
                if (notifiers.erase(notifier)) notifier->detach(this);
            }

            friend class notifier_type;

        protected:

            Listener() {}

            typedef typename interface_type::notifier_type c_notifier_type;

            virtual void Notifier_Deleted(c_notifier_type * /*notifier*/) {}

            virtual ~Listener()
            {
                // LOCK
                for (unsigned int i = 0; i < notifiers.size(); ++i)
                {
                    notifier_type *n
                        = static_cast<notifier_type*>(notifiers[i]);
                    n->detach(this);
                }
            }

        private:

            void NotifierImpl_Deleted(c_notifier_type *src)
            {
                notifiers.erase(static_cast<notifier_type*>(src));
                this->Notifier_Deleted(src);
            }

            typedef Listener<interface_type> self_type;

            Listener(const self_type &);
            self_type &operator=(const self_type &);

            Impl::void_list notifiers;
    };
}

#endif

---