ConcurrentList.h

#ifndef __CONCURRENTLIST_H__
#define __CONCURRENTLIST_H__

// tools
#include "tools/Guard.h"
#include "tools/NoCopy.h"

class ConcurrentPtrList
{
public:
    ConcurrentPtrList();

    virtual ~ConcurrentPtrList();
    
    OrderedMutex &getMutex() { return mutex; }
    
    bool isEmpty(Guard &guard);

    size_t size(Guard &guard);
    
    void add(Guard &guard, void *item);

    bool removeIfFound(Guard &guard, void *item);

    void remove(Guard &guard, void *item);
    
    class ConcurrentPtrListIterator iterator(Guard &guard);
    
private:
    PROHIBIT_DEFAULT_COPY(ConcurrentPtrList);
    OrderedMutex     mutex;
    class CPElement *list;
};

class ConcurrentPtrListIterator
{
public:
    ConcurrentPtrListIterator(Guard &guard,
                              ConcurrentPtrList *list,
                              class CPElement *element);

    ConcurrentPtrListIterator(const ConcurrentPtrListIterator &rhs);

    ConcurrentPtrListIterator & operator = (const ConcurrentPtrListIterator &);

    virtual ~ConcurrentPtrListIterator();

    OrderedMutex &getMutex() { return list->getMutex(); }
    
    void *next(Guard &guard);
private:
    ConcurrentPtrList *list;
    class CPElement   *next_element;
    void              *item;

    void getNext(Guard &guard);
};
 
template<class T> class ConcurrentListIterator
{
public:

  ConcurrentListIterator(ConcurrentPtrListIterator iter) : iter(iter) {}

  ConcurrentListIterator(const ConcurrentListIterator &rhs) : iter(rhs.iter) { }
 
  ConcurrentListIterator & operator = (const ConcurrentListIterator &rhs)
    {
        iter = rhs.iter;
        return *this;
    }
        
    T *next()
    {
        Guard guard(__FILE__, __LINE__, iter.getMutex());
        return (T *) iter.next(guard);
    }
private:
    ConcurrentPtrListIterator iter;
};

template<class T> class ConcurrentList
    : public Guardable, private ConcurrentPtrList
{
public:
    ConcurrentList()
    {}

    OrderedMutex &getMutex()
    {
        return ConcurrentPtrList::getMutex();
    }
    
    bool isEmpty()
    {
        Guard guard(__FILE__, __LINE__, ConcurrentPtrList::getMutex());
        return ConcurrentPtrList::isEmpty(guard);
    }
    
    size_t size()
    {
        Guard guard(__FILE__, __LINE__, ConcurrentPtrList::getMutex());
        return ConcurrentPtrList::size(guard);
    }

    void add(T *item)
    {
        Guard guard(__FILE__, __LINE__, ConcurrentPtrList::getMutex());
        ConcurrentPtrList::add(guard, item);
    }
    
    bool removeIfFound(void *item)
    {
        Guard guard(__FILE__, __LINE__, ConcurrentPtrList::getMutex());
        return ConcurrentPtrList::removeIfFound(guard, item);
    }
    
    void remove(T *item)
    {
        Guard guard(__FILE__, __LINE__, ConcurrentPtrList::getMutex());
        ConcurrentPtrList::remove(guard, item);
    }

    ConcurrentListIterator<T> iterator()
    {
        Guard guard(__FILE__, __LINE__, ConcurrentPtrList::getMutex());
        return ConcurrentListIterator<T>(ConcurrentPtrList::iterator(guard));
    }
private:
    PROHIBIT_DEFAULT_COPY(ConcurrentList);
};

#endif