#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_