te_signal.h

/* ScummVM - Graphic Adventure Engine
 *
 * ScummVM is the legal property of its developers, whose names
 * are too numerous to list here. Please refer to the COPYRIGHT
 * file distributed with this source distribution.
 *
 * This program 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 3 of the License, or
 * (at your option) any later version.
 *
 * This program 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 this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

#ifndef TETRAEDGE_TE_TE_SIGNAL_H
#define TETRAEDGE_TE_TE_SIGNAL_H

#include "common/array.h"
#include "common/ptr.h"
#include "tetraedge/te/te_callback.h"

namespace Tetraedge {

template<class C> bool _teCallbackSorter(const C &c1, const C &c2) {
    // sort in *descending* priority.
    float p1 = c1->priority();
    float p2 = c2->priority();
    return p2 < p1;
}

typedef Common::SharedPtr<TeICallback0Param> TeICallback0ParamPtr;

class TeSignal0Param : public Common::Array<TeICallback0ParamPtr> {
public:
    TeSignal0Param() : Common::Array<TeICallback0ParamPtr>() {};

    bool call() {
        Common::sort(this->begin(), this->end(), _teCallbackSorter<TeICallback0ParamPtr>);
        typename Common::Array<TeICallback0ParamPtr>::iterator i = this->begin();
        typename Common::Array<TeICallback0ParamPtr>::iterator end_ = this->end();
        for (; i < end_; i++) {
            if ((*i)->call())
                return true;
        }
        return false;
    }

    void remove(const TeICallback0ParamPtr &item) {
        typename Common::Array<TeICallback0ParamPtr>::iterator i = this->begin();
        typename Common::Array<TeICallback0ParamPtr>::iterator end_ = this->end();
        for (; i < end_; i++) {
            if ((*i)->equals(item.get())) {
                i = this->erase(i);
            }
        }
    }

    template<class T> void add(T *obj, typename TeCallback0Param<T>::TMethod method) {
        this->push_back(TeICallback0ParamPtr(new TeCallback0Param<T>(obj, method)));
    }

    template<class T> void remove(T *obj, typename TeCallback0Param<T>::TMethod method) {
        TeICallback0ParamPtr temp(new TeCallback0Param<T>(obj, method));
        this->remove(temp);
    }

};

/* Pointer to a callback with a single parameter of type T */
template<class T> using TeICallback1ParamPtr = Common::SharedPtr<TeICallback1Param<T>>;

/* Array of callbacks with a single parameter of type T */
template<class T> class TeSignal1Param : public Common::Array<TeICallback1ParamPtr<T>> {
public:
    TeSignal1Param() : Common::Array<TeICallback1ParamPtr<T>>() {};

    bool call(T t) {
        Common::sort(this->begin(), this->end(), _teCallbackSorter<TeICallback1ParamPtr<T>>);
        typename Common::Array<TeICallback1ParamPtr<T>>::iterator i = this->begin();
        typename Common::Array<TeICallback1ParamPtr<T>>::iterator end_ = this->end();
        for (; i < end_; i++) {
            if ((*i)->call(t))
                return true;
        }
        return false;
    }

    void remove(const TeICallback1ParamPtr<T> &item) {
        typename Common::Array<TeICallback1ParamPtr<T>>::iterator i = this->begin();
        typename Common::Array<TeICallback1ParamPtr<T>>::iterator end_ = this->end();
        for (; i < end_; i++) {
            if ((*i)->equals(item.get())) {
                i = this->erase(i);
            }
        }
    }

    template<class S> void add(S *obj, typename TeCallback1Param<S, T>::TMethod method) {
        this->push_back(TeICallback1ParamPtr<T>(new TeCallback1Param<S, T>(obj, method)));
    }

    template<class S> void remove(S *obj, typename TeCallback1Param<S, T>::TMethod method) {
        TeICallback1ParamPtr<T> temp(new TeCallback1Param<S, T>(obj, method));
        this->remove(temp);
    }
};

/* Pointer to a callback with 2 paramets parameter of type T and S */
template<class S, class T> using TeICallback2ParamPtr = Common::SharedPtr<TeICallback2Param<S, T>>;

/* Array of callbacks with a two parameters of type T */
template<class S, class T> class TeSignal2Param : public Common::Array<TeICallback2ParamPtr<S, T>> {
public:
    TeSignal2Param() : Common::Array<TeICallback2ParamPtr<S, T>>() {};

    bool call(S s, T t) {
        Common::sort(this->begin(), this->end(), _teCallbackSorter<TeICallback2ParamPtr<S, T>>);
        typename Common::Array<TeICallback2ParamPtr<S, T>>::iterator i = this->begin();
        typename Common::Array<TeICallback2ParamPtr<S, T>>::iterator end_ = this->end();
        for (; i < end_; i++) {
            if ((*i)->call(s, t))
                return true;
        }
        return false;
    }

    void remove(const TeICallback2ParamPtr<S, T> &item) {
        typename Common::Array<TeICallback2ParamPtr<S, T>>::iterator i = this->begin();
        typename Common::Array<TeICallback2ParamPtr<S, T>>::iterator end_ = this->end();
        for (; i < end_; i++) {
            if ((*i)->equals(item.get())) {
                i = this->erase(i);
            }
        }
    }

    template<class C> void add(C *obj, typename TeCallback2Param<C, S, T>::TMethod method) {
        this->push_back(TeICallback2ParamPtr<S, T>(new TeCallback2Param<C, S, T>(obj, method)));
    }

    template<class C> void remove(C *obj, typename TeCallback2Param<C, S, T>::TMethod method) {
        TeICallback2ParamPtr<S, T> temp(new TeCallback2Param<C, S, T>(obj, method));
        this->remove(temp);
    }
};

} // end namespace Tetraedge

#endif // TETRAEDGE_TE_TE_SIGNAL_H