libcore/include/sirikata/core/util/ListenerProvider.hpp

Go to the documentation of this file.

/*  Sirikata Utilities -- Sirikata Listener Pattern
 *  ListenerProvider.hpp
 *
 *  Copyright (c) 2009, Daniel Reiter Horn
 *  All rights reserved.
 *
 *  Redistribution and use in source and binary forms, with or without
 *  modification, are permitted provided that the following conditions are
 *  met:
 *  * Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 *  * Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in
 *    the documentation and/or other materials provided with the
 *    distribution.
 *  * Neither the name of Sirikata nor the names of its contributors may
 *    be used to endorse or promote products derived from this software
 *    without specific prior written permission.
 *
 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
 * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
 * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
 * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER
 * OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
 * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
 * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
 * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
 * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
 * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
 * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 */
#ifndef _SIRIKATA_LISTENER_PROVIDER_HPP_
#define _SIRIKATA_LISTENER_PROVIDER_HPP_


namespace Sirikata {
template <typename ListenerPtr> class Provider {
protected:
    typedef std::vector<ListenerPtr> ListenerVector;
    typedef std::map<ListenerPtr,uint32> ListenerMap;
    ListenerVector mListeners;
    ListenerMap mListenerIndex;
    virtual ~Provider(){}
    virtual void listenerAdded(ListenerPtr ){}
    virtual void listenerRemoved(ListenerPtr ){}
    virtual void firstListenerAdded(ListenerPtr ){}
    virtual void lastListenerRemoved(ListenerPtr ){}
    template <typename T> void notify(T func){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)();
        }
    }    
    template <typename T, typename A> void notify(T func, A newA){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA);
        }
    }
    template <typename T, typename A, typename B>
      void notify(T func, A newA, B newB){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB);
        }
    }
    template <typename T, typename A, typename B, typename C>
      void notify(T func, A newA, B newB, C newC){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC);
        }
    }
    template <typename T, typename A, typename B, typename C, typename D>
      void notify(T func, A newA, B newB, C newC, D newD){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC,newD);
        }
    }
    template <typename T, typename A, typename B, typename C, typename D, typename E>
      void notify(T func, A newA, B newB, C newC, D newD, E newE){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC,newD,newE);
        }
    }
    template <typename T, typename A, typename B, typename C, typename D, typename E, typename F>
      void notify(T func, A newA, B newB, C newC, D newD, E newE, F newF){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC,newD,newE,newF);
        }
    }

    template <typename T, typename A, typename B, typename C, typename D, typename E, typename F, typename G>
    void notify(T func, A newA, B newB, C newC, D newD, E newE, F newF, G newG){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC,newD,newE,newF,newG);
        }
    }

    template <typename T, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H>
    void notify(T func, A newA, B newB, C newC, D newD, E newE, F newF, G newG, H newH){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC,newD,newE,newF,newG,newH);
        }
    }

    template <typename T, typename A, typename B, typename C, typename D, typename E, typename F, typename G, typename H, typename I>
    void notify(T func, A newA, B newB, C newC, D newD, E newE, F newF, G newG, H newH, I newI){
        for (int32 i=(int32)mListeners.size()-1;
             i>=0&&i<(int32)mListeners.size();
             --i) {
            ((&*mListeners[i])->*func)(newA,newB,newC,newD,newE,newF,newG,newH,newI);
        }
    }


public:
    virtual void addListener(ListenerPtr p) {
        if (mListeners.empty()) {
            mListeners.push_back(p);
            this->firstListenerAdded(p);
        }else if (mListeners.size()==1) {
            mListenerIndex[mListeners[0]]=0;
            mListenerIndex[p]=1;
            mListeners.push_back(p);
        }else {
            mListenerIndex[p]=mListeners.size();
            mListeners.push_back(p);
        }
        this->listenerAdded(p);
    }
    virtual void removeListener(ListenerPtr p) {
        this->listenerRemoved(p);
        if (mListeners.size()>1) {
            typename ListenerMap::iterator where=mListenerIndex.find(p);
            assert(where!=mListenerIndex.end());
            if (where->second+1!=mListeners.size()) {
                mListenerIndex[mListeners.back()]=where->second;
                mListeners[where->second]=mListeners.back();
            }
            mListeners.resize(mListeners.size()-1);
            mListenerIndex.erase(where);
        }else {
            this->lastListenerRemoved(p);
            assert(mListeners[0]==p);
            mListeners.resize(0);
            mListenerIndex=ListenerMap();
        }
    }
};

}
#endif