signal2.h

Go to the documentation of this file.

#pragma once

#include "isignalbase.h"

namespace itasca {
    template <class Param1,class Param2> class Signal2 : public ISignalBase {
    public:

        typedef ISlot2<Param1,Param2> SlotType;

        Signal2() { }
        Signal2(const Signal2 &) = delete;
        Signal2(Signal2 &&) = delete;
        void operator=(const Signal2 &) = delete;
        void operator=(Signal2 &&) = delete;


        virtual ~Signal2();

        virtual void execute(Param1,Param2);

        virtual void attach(SlotType *,const QString &);

        bool remove(ISlotBase *slot,const QString &name=QString());

        virtual void attachNotice(ISignalBase *signal);
        virtual void removeNotice(ISignalBase *signal);

        // Creates a SlotType implementation that calls the method MFP on instance t of class T, using two arguments.
        // T must be derived from ISlotBase.
        template <class T,void (T::*MFP)(Param1,Param2)>
        void attachMethod2(T *t) {
            AutoSlot2<T,MFP> *s = NEW("AutoSlot") AutoSlot2<T,MFP>(t);
            attach(s,typeid(*s).name());
        }

        // Creates a SlotType implementation that calls the method MFP on instance t of class T, using one argument.
        // T must be derived from ISlotBase.
        template <class T,void (T::*MFP)(Param1)>
        void attachMethod1(T *t) {
            AutoSlot1<T,MFP> *s = NEW("AutoSlot") AutoSlot1<T,MFP>(t);
            attach(s,typeid(*s).name());
        }

        // Creates a SlotType implementation that calls the method MFP on instance t of class T, using no arguments.
        // T must be derived from ISlotBase.
        template <class T,void (T::*MFP)()>
        void attachMethod0(T *t) {
            AutoSlot0<T,MFP> *s = NEW("AutoSlot") AutoSlot0<T,MFP>(t);
            attach(s,typeid(*s).name());
        }

        // Removes a slot connection created to method MFP on instance to of class T, using two arguments.
        template <class T,void (T::*MFP)(Param1,Param2)>
        void removeMethod2(T *t) {
            AutoSlot2<T,MFP> s = AutoSlot2<T,MFP>(t);
            remove(t,typeid(s).name());
        }

        // Removes a slot connection created to method MFP on instance to of class T, using one argument.
        template <class T,void (T::*MFP)(Param1)>
        void removeMethod1(T *t) {
            AutoSlot1<T,MFP> s = AutoSlot1<T,MFP>(t);
            remove(t,typeid(s).name());
        }

        // Removes a slot connection created to method MFP on instance to of class T, using no arguments.
        template <class T,void (T::*MFP)()>
        void removeMethod0(T *t) {
            AutoSlot0<T,MFP> s = AutoSlot0<T,MFP>(t);
            remove(t,typeid(s).name());
        }

        // Attaches a signal (same two arguments) to this signal, as a slot, causing the signals to chain.
        void attachSignal(Signal2<Param1,Param2> *sig) {
            attachMethod2<Signal2<Param1,Param2>,&Signal2<Param1,Param2>::execute>(sig);
        }

        // Removes a signal previously attached
        void removeSignal(Signal2<Param1,Param2> *sig) {
            removeMethod2<Signal2<Param1,Param2>,&Signal2<Param1,Param2>::execute>(sig);
        }

    private:
        typedef QMultiMap<QString,SlotType *> SlotMap;
        QList<ISignalBase *> signals_;
        SlotMap              map_;

        // Derived from SlotType - used when a method is attached via attachMethod2().
        template <class T,void (T::*MFP)(Param1,Param2)> class AutoSlot2 : public SlotType {
        public:
            AutoSlot2(T *t) : t_(t) { assert(t_); }
            virtual void execute(Param1 v1,Param2 v2) {
                assert(t_);
                (t_->*MFP)(v1,v2);
            }
            virtual ISlotBase *getBase() { return t_; }
        private:
            T *t_;
        };

        // Derived from SlotType - used when a method is attached via attachMethod1().
        template <class T,void (T::*MFP)(Param1)> class AutoSlot1 : public SlotType {
        public:
            AutoSlot1(T *t) : t_(t) { assert(t_); }
            virtual void execute(Param1 v1,Param2) {
                assert(t_);
                (t_->*MFP)(v1);
            }
            virtual ISlotBase *getBase() { return t_; }
        private:
            T *t_;
        };

        // Derived from SlotType - used when a method is attached via attachMethod0().
        template <class T,void (T::*MFP)()> class AutoSlot0 : public SlotType {
        public:
            AutoSlot0(T *t) : t_(t) { assert(t_); }
            virtual void execute(Param1,Param2) {
                assert(t_);
                (t_->*MFP)();
            }
            virtual ISlotBase *getBase() { return t_; }
        private:
            T *t_;
        };
    };

    template <class Param1,class Param2>
    Signal2<Param1,Param2>::~Signal2() {
        while (signals_.size()) {
            ISignalBase *base = signals_.last();
            base->remove(this);
        }
        while (map_.size()) {
            typename SlotMap::iterator it = map_.begin();
            SlotType *slot = it.value();
            map_.erase(it);
            slot->getBase()->removeNotice(this);
            delete slot;
        }
    }

    template <class Param1,class Param2>
    void Signal2<Param1,Param2>::execute(Param1 v1,Param2 v2) {
        for (typename SlotMap::iterator it=map_.begin();it!=map_.end();++it)
            it.value()->execute(v1,v2);
    }

    template <class Param1,class Param2>
    void Signal2<Param1,Param2>::attach(SlotType *slot,const QString &name) {
        assert(slot);
        map_.insert(name,slot);
        slot->getBase()->attachNotice(this);
    }

    template <class Param1,class Param2>
    bool Signal2<Param1,Param2>::remove(ISlotBase *slot,const QString &name) {
        if (slot && name.length()) { // First first entry
            for (typename SlotMap::iterator it=map_.find(name);it!=map_.end() && it.key()==name;++it) {
                SlotType *st = it.value();
                if (st->getBase()==slot) {
                    map_.erase(it);
                    st->getBase()->removeNotice(this);
                    delete st;
                    return true;
                }
            }
            return false;
        }
        if (slot) { // Remove all entries matching that slot base
            QList<QPair<QString,SlotType *> > toRemove;
            for (typename SlotMap::iterator it=map_.begin();it!=map_.end();++it) {
                if (it.value()->getBase()==slot)
                    toRemove.push_back(QPair<QString,SlotType *>(it.key(),it.value()));
            }
            for (int i=0;i<toRemove.size();++i) {
                QPair<QString,SlotType *> &p = toRemove[i];
                map_.remove(p.first,p.second);
                p.second->getBase()->removeNotice(this);
                delete p.second;
            }
            return toRemove.size() ? true : false;
        }
        if (name.length()) { // Remove all slots with matching name
            QList<QPair<QString,SlotType *> > toRemove;
            for (typename SlotMap::iterator it=map_.find(name);it!=map_.end() && it.key()==name;++it)
                toRemove.push_back(QPair<QString,SlotType *>(it.key(),it.value()));
            for (int i=0;i<toRemove.size();++i) {
                QPair<QString,SlotType *> &p = toRemove[i];
                map_.remove(p.first,p.second);
                p.second->getBase()->removeNotice(this);
                delete p.second;
            }
            return toRemove.size() ? true : false;
        }
        // Remove all slots
        while (map_.size()) {
            typename SlotMap::iterator it = map_.begin();
            SlotType *slotType = it.value();
            map_.erase(it);
            slotType->getBase()->removeNotice(this);
            delete slotType;
        }
        return true;
    }

    template <class Param1,class Param2>
    void Signal2<Param1,Param2>::attachNotice(ISignalBase *signal) {
        signals_.push_back(signal);
    }

    template <class Param1,class Param2>
    void Signal2<Param1,Param2>::removeNotice(ISignalBase *signal) {
        int i = signals_.indexOf(signal);
        if (i<0) return;
        signals_.removeAt(i);
    }
} // namespace Itasca
// Eof