callbacks.h

#ifndef ROSE_Callbacks_H
#define ROSE_Callbacks_H
#include <Rose/Constants.h>
 
#include <boost/thread/locks.hpp>
#include <boost/thread/mutex.hpp>
#include <list>
 
namespace Rose {
 
namespace Callbacks {
 
enum Direction {
    FORWARD,                
    BACKWARD                
};
 
template<class T>
class List {
public:
    typedef T CallbackType;                                 
    typedef std::list<CallbackType*> CBList;                
private:
    mutable boost::mutex mutex_;
    CBList list;
 
public:
    List() {}
 
    List(const List &other) {
        boost::lock_guard<boost::mutex> lock(other.mutex_);
        list = other.list;
    }
 
    explicit List(CallbackType *callback) {
        append(callback);
    }
 
    size_t size() const {
        boost::lock_guard<boost::mutex> lock(mutex_);
        return list.size();
    }
 
    bool empty() const {
        boost::lock_guard<boost::mutex> lock(mutex_);
        return list.empty();
    }
 
    List& append(CallbackType *cb) {
        assert(cb!=NULL);
        boost::lock_guard<boost::mutex> lock(mutex_);
        list.push_back(cb);
        return *this;
    }
 
    List& prepend(CallbackType *cb) {
        assert(cb!=NULL);
        boost::lock_guard<boost::mutex> lock(mutex_);
        list.push_front(cb);
        return *this;
    }
 
    List& after(CallbackType *relative_to, CallbackType *cb, size_t nreplacements = UNLIMITED) {
        assert(cb!=NULL);
        boost::lock_guard<boost::mutex> lock(mutex_);
        for (typename CBList::iterator li=list.begin(); li!=list.end() && nreplacements>0; ++li) {
            if (*li==relative_to) {
                li = list.insert(++li, cb);
                --nreplacements;
            }
        }
        return *this;
    }
 
    List& before(CallbackType *relative_to, CallbackType *cb, size_t nreplacements = UNLIMITED) {
        assert(cb!=NULL);
        boost::lock_guard<boost::mutex> lock(mutex_);
        for (typename CBList::iterator li=list.begin(); li!=list.end() && nreplacements>0; ++li) {
            if (*li==relative_to) {
                li = list.insert(li, cb);
                ++li;
                --nreplacements;
            }
        }
        return *this;
    }
 
    List& replace(CallbackType *old_cb, CallbackType *new_cb, size_t nreplacements = UNLIMITED, Direction dir = FORWARD) {
        assert(new_cb!=NULL);
        boost::lock_guard<boost::mutex> lock(mutex_);
        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;
                }
            }
        }
        return *this;
    }
 
    bool erase(CallbackType *cb, Direction dir=FORWARD) {
        boost::lock_guard<boost::mutex> lock(mutex_);
        if (FORWARD==dir) {
            for (typename CBList::iterator li=list.begin(); li!=list.end(); ++li) {
                if (*li==cb) {
                    list.erase(li);
                    return true;
                }
            }
        } else {
            for (typename CBList::reverse_iterator li=list.rbegin(); li!=list.rend(); ++li) {
                if (*li==cb) {
                    list.erase((++li).base());
                    return true;
                }
            }
        }
        return false;
    }
 
    List& clear() {
        boost::lock_guard<boost::mutex> lock(mutex_);
        list.clear();
        return *this;
    }
 
    std::list<CallbackType*> callbacks() const {
        boost::lock_guard<boost::mutex> lock(mutex_);
        return list;
    }
 
    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;
    }
};
 
} // namespace
} // namespace
 
#endif /* ROSE_callbacks_H */