callbacks.h

Go to the documentation of this file.

#ifndef ROSE_Callbacks_H
#define ROSE_Callbacks_H

#include "threadSupport.h"
#include <list>

namespace ROSE_Callbacks {

    enum Direction {
        FORWARD,                
        BACKWARD                
    };

    template<class T>
    class List {
    public:
        typedef T CallbackType;                                 
        typedef std::list<CallbackType*> CBList;                
        List() {
            RTS_mutex_init(&mutex, RTS_LAYER_ROSE_CALLBACKS_LIST_OBJ, NULL);
        }

        explicit List(CallbackType *callback) {
            RTS_mutex_init(&mutex, RTS_LAYER_ROSE_CALLBACKS_LIST_OBJ, NULL);
            append(callback);
        }

        size_t size() const {
            size_t retval = 0;
            RTS_MUTEX(mutex) {
                retval = list.size();
            } RTS_MUTEX_END;
            return retval;
        }

        bool empty() const {
            bool retval = false;
            RTS_MUTEX(mutex) {
                retval = list.empty();
            } RTS_MUTEX_END;
            return retval;
        }

        List& append(CallbackType *cb) {
            RTS_MUTEX(mutex) {
                assert(cb!=NULL);
                list.push_back(cb);
            } RTS_MUTEX_END;
            return *this;
        }

        List& prepend(CallbackType *cb) {
            RTS_MUTEX(mutex) {
                assert(cb!=NULL);
                list.push_front(cb);
            } RTS_MUTEX_END;
            return *this;
        }

        List& after(CallbackType *relative_to, CallbackType *cb, size_t nreplacements=(size_t)(-1)) {
            RTS_MUTEX(mutex) {
                assert(cb!=NULL);
                for (typename CBList::iterator li=list.begin(); li!=list.end() && nreplacements>0; ++li) {
                    if (*li==relative_to) {
                        li = list.insert(++li, cb);
                        --nreplacements;
                    }
                }
            } RTS_MUTEX_END;
            return *this;
        }

        List& before(CallbackType *relative_to, CallbackType *cb, size_t nreplacements=(size_t)(-1)) {
            RTS_MUTEX(mutex) {
                assert(cb!=NULL);
                for (typename CBList::iterator li=list.begin(); li!=list.end() && nreplacements>0; ++li) {
                    if (*li==relative_to) {
                        li = list.insert(li, cb);
                        ++li;
                        --nreplacements;
                    }
                }
            } RTS_MUTEX_END;
            return *this;
        }

        List& replace(CallbackType *old_cb, CallbackType *new_cb, size_t nreplacements=(size_t)(-1), Direction dir=FORWARD) {
            RTS_MUTEX(mutex) {
                assert(new_cb!=NULL);
                if (FORWARD==dir) {
                    for (typename CBList::iterator li=list.begin(); li!=list.end() && nreplacements>0; ++li) {
                        if (*li==old_cb) {
                            *li = new_cb;
                            --nreplacements;
                        }
                    }
                } else {
                    for (typename CBList::reverse_iterator li=list.rbegin(); li!=list.rend() && nreplacements>0; ++li) {
                        if (*li==old_cb) {
                            *li = new_cb;
                            --nreplacements;
                        }
                    }
                }
            } RTS_MUTEX_END;
            return *this;
        }

        bool erase(CallbackType *cb, Direction dir=FORWARD) {
            bool erased = false;
            RTS_MUTEX(mutex) {
                if (FORWARD==dir) {
                    for (typename CBList::iterator li=list.begin(); li!=list.end(); ++li) {
                        if (*li==cb) {
                            list.erase(li);
                            erased = true;
                            break;
                        }
                    }
                } else {
                    for (typename CBList::reverse_iterator li=list.rbegin(); li!=list.rend(); ++li) {
                        if (*li==cb) {
                            list.erase((++li).base());
                            erased = true;
                            break;
                        }
                    }
                }
            } RTS_MUTEX_END;
            return erased;
        }

        List& clear() {
            RTS_MUTEX(mutex) {
                list.clear();
            } RTS_MUTEX_END;
            return *this;
        }

        std::list<CallbackType*> callbacks() const {
            CBList retval;
            RTS_MUTEX(mutex) {
                retval = list;
            } RTS_MUTEX_END;
            return retval;
        }

        template<class ArgumentType>
        bool apply(bool b, const ArgumentType &args, Direction dir=FORWARD) const {
            CBList list = callbacks(); /* copy, so callbacks can safely modify this object's list */
            if (FORWARD==dir) {
                for (typename CBList::iterator li=list.begin(); li!=list.end(); ++li) {
                    b = (**li)(b, args);
                }
            } else {
                for (typename CBList::reverse_iterator li=list.rbegin(); li!=list.rend(); ++li) {
                    b = (**li)(b, args);
                }
            }
            return b;
        }

    private:
        mutable RTS_mutex_t mutex;
        CBList list;
    };
}

#endif /* ROSE_callbacks_H */