144 lines
3.0 KiB
C++
144 lines
3.0 KiB
C++
#ifndef _LIST_H_
|
|
#define _LIST_H_
|
|
|
|
#include "mutex.h"
|
|
|
|
class IteratorBase {
|
|
public:
|
|
virtual ~IteratorBase() {}
|
|
virtual bool hasNext() =0;
|
|
virtual void* next() =0;
|
|
virtual void remove() =0;
|
|
virtual void reset() =0;
|
|
|
|
protected:
|
|
IteratorBase() {}
|
|
IteratorBase(const IteratorBase& it);
|
|
IteratorBase& operator=(const IteratorBase& it);
|
|
};
|
|
|
|
class ListBase {
|
|
public:
|
|
ListBase();
|
|
~ListBase();
|
|
|
|
void add(const void* part);
|
|
void addTail(const void* part);
|
|
void* get();
|
|
void* getTail();
|
|
bool isEmpty() const;
|
|
|
|
IteratorBase* createIterator();
|
|
|
|
protected:
|
|
ListBase(const ListBase& l);
|
|
ListBase& operator=(const ListBase& l);
|
|
|
|
class ListEntryBase {
|
|
public:
|
|
ListEntryBase(const void* part = 0);
|
|
~ListEntryBase();
|
|
|
|
void add(ListEntryBase* prev, ListEntryBase* next);
|
|
void del();
|
|
bool isEmpty() const;
|
|
|
|
void* getPart() const;
|
|
ListEntryBase* getPrev() const;
|
|
ListEntryBase* getNext() const;
|
|
|
|
protected:
|
|
ListEntryBase(const ListEntryBase& l);
|
|
ListEntryBase& operator=(const ListEntryBase& l);
|
|
|
|
private:
|
|
ListEntryBase* prev;
|
|
ListEntryBase* next;
|
|
const void* part;
|
|
};
|
|
|
|
class ListIteratorBase : public IteratorBase {
|
|
public:
|
|
ListIteratorBase(ListBase* list);
|
|
~ListIteratorBase();
|
|
|
|
bool hasNext();
|
|
void* next();
|
|
void remove();
|
|
void reset();
|
|
|
|
private:
|
|
ListBase* list;
|
|
ListEntryBase* pos;
|
|
};
|
|
|
|
private:
|
|
ListEntryBase head;
|
|
Mutex mutex;
|
|
|
|
friend class ListIteratorBase;
|
|
};
|
|
|
|
|
|
template <class T>
|
|
class Iterator : public IteratorBase {
|
|
public:
|
|
virtual T* next() =0;
|
|
};
|
|
|
|
template <class T>
|
|
class NullIterator : public Iterator<T> {
|
|
public:
|
|
NullIterator() {}
|
|
~NullIterator() {}
|
|
|
|
bool hasNext() { return false; }
|
|
T* next() { return NULL; }
|
|
void remove() {}
|
|
void reset() {}
|
|
};
|
|
|
|
template <class T>
|
|
class List : public ListBase {
|
|
public:
|
|
List() {}
|
|
~List() {}
|
|
|
|
void add(const T* part) { ListBase::add(part); }
|
|
void addTail(const T* part) { ListBase::addTail(part); }
|
|
T* get() { return (T*)ListBase::get(); }
|
|
T* getTail() { return (T*)ListBase::getTail(); }
|
|
bool isEmpty() const { return ListBase::isEmpty(); }
|
|
|
|
Iterator<T>* createIterator() const { return new ListIteratorRO<T>(this); }
|
|
Iterator<T>* createIteratorRW() { return new ListIteratorRW<T>(this); }
|
|
|
|
private:
|
|
template <class TT>
|
|
class ListIteratorRO : public Iterator<TT>, private ListIteratorBase {
|
|
public:
|
|
ListIteratorRO(const List<TT>* list) : ListIteratorBase((ListBase*)list) {}
|
|
~ListIteratorRO() {}
|
|
|
|
bool hasNext() { return ListIteratorBase::hasNext(); }
|
|
TT* next() { return (TT*)ListIteratorBase::next(); }
|
|
void remove() {}
|
|
void reset() { ListIteratorBase::reset(); }
|
|
};
|
|
|
|
template <class TT>
|
|
class ListIteratorRW : public Iterator<TT>, private ListIteratorBase {
|
|
public:
|
|
ListIteratorRW(List<TT>* list) : ListIteratorBase(list) {}
|
|
~ListIteratorRW() {}
|
|
|
|
bool hasNext() { return ListIteratorBase::hasNext(); }
|
|
TT* next() { return (TT*)ListIteratorBase::next(); }
|
|
void remove() { ListIteratorBase::remove(); }
|
|
void reset() { ListIteratorBase::reset(); }
|
|
};
|
|
|
|
};
|
|
|
|
#endif //_LIST_H_
|