2006-02-02 16:55:44 +01:00
|
|
|
#ifndef _LIST_H_
|
|
|
|
#define _LIST_H_
|
|
|
|
|
|
|
|
#include "mutex.h"
|
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
template <class T>
|
|
|
|
class Iterator {
|
2006-02-02 16:55:44 +01:00
|
|
|
public:
|
2006-04-15 19:55:07 +02:00
|
|
|
virtual ~Iterator() {}
|
|
|
|
virtual bool hasNext() =0;
|
|
|
|
virtual T* next() =0;
|
|
|
|
virtual void remove() =0;
|
|
|
|
virtual void reset() =0;
|
2006-02-02 16:55:44 +01:00
|
|
|
|
|
|
|
protected:
|
2006-04-15 19:55:07 +02:00
|
|
|
Iterator() {}
|
|
|
|
Iterator(const Iterator& it);
|
|
|
|
Iterator& operator=(const Iterator& it);
|
2006-03-06 20:13:26 +01:00
|
|
|
};
|
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
|
|
|
|
template <class T>
|
|
|
|
class NullIterator : public Iterator<T> {
|
2006-03-06 20:13:26 +01:00
|
|
|
public:
|
2006-04-15 19:55:07 +02:00
|
|
|
NullIterator() {}
|
|
|
|
virtual ~NullIterator() {}
|
|
|
|
virtual bool hasNext() { return false; }
|
|
|
|
virtual T* next() { return NULL; }
|
|
|
|
virtual void remove() {}
|
|
|
|
virtual void reset() {}
|
|
|
|
};
|
2006-03-06 20:13:26 +01:00
|
|
|
|
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
template <class T>
|
|
|
|
class ListEntry;
|
2006-03-06 20:13:26 +01:00
|
|
|
|
|
|
|
|
2006-04-17 13:35:50 +02:00
|
|
|
template <class T>
|
|
|
|
class ListIterator;
|
|
|
|
|
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
template <class T>
|
|
|
|
class List {
|
2006-04-17 13:35:50 +02:00
|
|
|
friend class ListIterator<T>;
|
2006-04-15 19:55:07 +02:00
|
|
|
public:
|
|
|
|
List() : head(0), tail(0) {}
|
|
|
|
~List() {}
|
2006-03-06 20:13:26 +01:00
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
void add(T* entry)
|
|
|
|
{
|
|
|
|
ListEntry<T>* tmp = (ListEntry<T>*)entry;
|
|
|
|
tmp->next = NULL;
|
2006-03-06 20:13:26 +01:00
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
if (!head)
|
|
|
|
head = tmp;
|
2006-03-06 20:13:26 +01:00
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
if (tail)
|
|
|
|
tail->next = tmp;
|
|
|
|
tail = tmp;
|
|
|
|
}
|
2006-03-06 20:13:26 +01:00
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
T* get()
|
|
|
|
{
|
|
|
|
ListEntry<T>* retval = head;
|
|
|
|
|
|
|
|
if (head)
|
|
|
|
head = head->next;
|
|
|
|
|
|
|
|
if (!head)
|
|
|
|
tail = NULL;
|
|
|
|
|
|
|
|
return (T*)retval;
|
|
|
|
}
|
|
|
|
|
|
|
|
T* peekHead()
|
|
|
|
{
|
|
|
|
return (T*)head;
|
|
|
|
}
|
|
|
|
|
|
|
|
T* peekTail()
|
|
|
|
{
|
|
|
|
return (T*)tail;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isEmpty()
|
|
|
|
{
|
|
|
|
return (head == NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
Iterator<T>* createIterator()
|
|
|
|
{
|
|
|
|
return new ListIterator<T>(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
List(const List& l);
|
|
|
|
List& operator=(const List& l);
|
2006-03-06 20:13:26 +01:00
|
|
|
|
|
|
|
private:
|
2006-04-15 19:55:07 +02:00
|
|
|
ListEntry<T> *head;
|
|
|
|
ListEntry<T> *tail;
|
2006-02-02 16:55:44 +01:00
|
|
|
};
|
|
|
|
|
2006-02-05 16:44:38 +01:00
|
|
|
|
2006-04-17 13:35:50 +02:00
|
|
|
template <class T>
|
|
|
|
class ListIterator : public Iterator<T> {
|
|
|
|
public:
|
|
|
|
ListIterator(List<T>* list)
|
|
|
|
: list(list)
|
|
|
|
{
|
|
|
|
reset();
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~ListIterator() {}
|
|
|
|
|
|
|
|
virtual bool hasNext()
|
|
|
|
{
|
|
|
|
return (pos == NULL) ? (list->head != NULL) : (pos->next != NULL);
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual T* next()
|
|
|
|
{
|
|
|
|
prev = pos;
|
|
|
|
pos = (pos == NULL) ? list->head : pos->next;
|
|
|
|
return (T*)pos;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void remove()
|
|
|
|
{
|
|
|
|
// remove pre-head -> bail out
|
|
|
|
if (pos == NULL)
|
|
|
|
return;
|
|
|
|
|
|
|
|
// remove first
|
|
|
|
if (pos == list->head)
|
|
|
|
list->head = pos->next;
|
|
|
|
|
|
|
|
// remove middle
|
|
|
|
if (prev)
|
|
|
|
prev->next = pos->next;
|
|
|
|
|
|
|
|
// remove last
|
|
|
|
if (pos == list->tail)
|
|
|
|
list->tail = (prev == NULL) ? NULL : prev;
|
|
|
|
|
|
|
|
pos = prev;
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual void reset()
|
|
|
|
{
|
|
|
|
pos = NULL;
|
|
|
|
prev = NULL;
|
|
|
|
}
|
|
|
|
|
|
|
|
protected:
|
|
|
|
ListIterator(const ListIterator& li);
|
|
|
|
ListIterator& operator=(const ListIterator& li);
|
|
|
|
|
|
|
|
List<T>* list;
|
|
|
|
|
|
|
|
private:
|
|
|
|
ListEntry<T>* pos;
|
|
|
|
ListEntry<T>* prev;
|
|
|
|
};
|
|
|
|
|
|
|
|
|
2006-02-05 16:44:38 +01:00
|
|
|
template <class T>
|
2006-04-15 19:55:07 +02:00
|
|
|
class ListEntry {
|
|
|
|
friend class List<T>;
|
2006-04-17 13:35:50 +02:00
|
|
|
friend class ListIterator<T>;
|
2006-03-06 20:13:26 +01:00
|
|
|
public:
|
2006-04-15 19:55:07 +02:00
|
|
|
ListEntry() {}
|
|
|
|
~ListEntry() {}
|
2006-03-06 20:13:26 +01:00
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
private:
|
|
|
|
ListEntry* next;
|
2006-03-06 20:13:26 +01:00
|
|
|
};
|
2006-02-05 16:44:38 +01:00
|
|
|
|
2006-04-15 19:55:07 +02:00
|
|
|
|
2006-04-17 13:35:50 +02:00
|
|
|
template <class T>
|
|
|
|
class LockedListIterator;
|
|
|
|
|
|
|
|
|
2006-02-02 16:55:44 +01:00
|
|
|
template <class T>
|
2006-04-15 19:55:07 +02:00
|
|
|
class LockedList : private List<T> {
|
2006-04-17 13:35:50 +02:00
|
|
|
friend class LockedListIterator<T>;
|
2006-02-02 16:55:44 +01:00
|
|
|
public:
|
2006-04-15 19:55:07 +02:00
|
|
|
LockedList() {}
|
|
|
|
~LockedList() {}
|
|
|
|
void add(T* entry)
|
|
|
|
{
|
|
|
|
AutoMutex am(mutex);
|
|
|
|
List<T>::add(entry);
|
|
|
|
}
|
|
|
|
|
|
|
|
T* get()
|
|
|
|
{
|
|
|
|
AutoMutex am(mutex);
|
|
|
|
return List<T>::get();
|
|
|
|
}
|
|
|
|
|
|
|
|
T* peekFirst()
|
|
|
|
{
|
|
|
|
return NULL; // not with lockedlist
|
|
|
|
}
|
|
|
|
|
|
|
|
T* peekLast()
|
|
|
|
{
|
|
|
|
return NULL; // not with lockedlist
|
|
|
|
}
|
|
|
|
|
|
|
|
bool isEmpty()
|
|
|
|
{
|
|
|
|
AutoMutex am(mutex);
|
|
|
|
return List<T>::isEmpty();
|
|
|
|
}
|
|
|
|
|
|
|
|
Iterator<T>* createIterator()
|
|
|
|
{
|
|
|
|
return new LockedListIterator<T>(this);
|
|
|
|
}
|
2006-02-02 16:55:44 +01:00
|
|
|
|
|
|
|
private:
|
2006-04-15 19:55:07 +02:00
|
|
|
Mutex mutex;
|
2006-03-06 20:13:26 +01:00
|
|
|
};
|
2006-02-02 16:55:44 +01:00
|
|
|
|
2006-04-17 13:35:50 +02:00
|
|
|
|
|
|
|
template <class T>
|
|
|
|
class LockedListIterator : public ListIterator<T> {
|
|
|
|
public:
|
|
|
|
LockedListIterator(LockedList<T>* list)
|
|
|
|
: ListIterator<T>(list)
|
|
|
|
{
|
|
|
|
list->mutex.lock();
|
|
|
|
}
|
|
|
|
|
|
|
|
virtual ~LockedListIterator()
|
|
|
|
{
|
|
|
|
((LockedList<T>*)list)->mutex.unlock();
|
|
|
|
}
|
|
|
|
};
|
|
|
|
|
2006-02-02 16:55:44 +01:00
|
|
|
#endif //_LIST_H_
|