/*
 *	CENA C++ Utilities
 *
 *	by Stephane Chatty
 *
 *	Copyright 1992
 *	Centre d'Etudes de la Navigation Aerienne (CENA)
 *
 *	plain and generic lists (original ideas by Yves Berteaud)
 *
 *	$Id$
 *	$CurLog$
 */

#ifndef List_H_
#define List_H_

#include "cplus_bugs.h"

class CcuAllocator;

typedef void CcuListItem;

#ifdef CPLUS_BUG20
class CcuListLink;
#endif

class CcuList {
friend	class	CcuListIter;

#ifndef CPLUS_BUG20
	class CcuListLink {
	static	CcuAllocator*	ListLinkMem;
	public:
		CcuListItem*	Entry;
		CcuListLink*	Next;
	inline		CcuListLink (CcuListItem* e, CcuListLink* n = 0)	{ Entry = e; Next = n ? n : this; }
		CcuListLink*	Previous ();
		void*	operator new (unsigned int);
		void	operator delete (void*);
	};
#endif

public:
	enum	list_status	{ NoError, WasEmpty, TooEarly, TooFar, BadIterator };
	enum	list_remove	{ All = -1 };

private:

	CcuListLink*	LastLink;
	list_status	StatusFlag;

	void	InsertAfterLink (CcuListLink*, CcuListItem*);
	void	InsertBeforeLink (CcuListLink*, CcuListItem*);
	CcuListItem*	RemoveAfterLink (CcuListLink*);

public:
inline		CcuList () : LastLink (0), StatusFlag (NoError)	{ }
		CcuList (CcuListItem*);
		CcuList (const CcuList&);
		~CcuList ();
		CcuList&	operator = (const CcuList&);
inline	list_status	GetStatus () const		{ return StatusFlag; }

inline	int	IsEmpty () const			{ return !LastLink; }
	CcuListItem*	First ();
	CcuListItem*	Last ();
	CcuListItem*	Nth (int n);
	int	Length () const;
	int	Find (CcuListItem*) const;

	void	Append (CcuListItem*);
	void	Prepend (CcuListItem*);
inline	CcuList&	operator << (CcuListItem* it)	{ Append (it); return *this; }

	CcuListItem*	RemoveFirst ();
	CcuListItem*	RemoveLast ();
	int	Remove (CcuListItem*, int = 1);
	int	Remove (int (*) (CcuListItem*), int = 1);
	void	Clear ();

	void	InsertAfter (const CcuListIter&, CcuListItem*);
	void	InsertBefore (const CcuListIter&, CcuListItem*);
	CcuListItem*	RemoveAfter (const CcuListIter&);
};

class CcuListIter {
friend	class	CcuList;

public:
	enum	listiter_status	{ Normal, StartOfList, EndOfList };

private:
	const CcuList*	TheList;
#ifdef CPLUS_BUG20
	CcuListLink*	CurLink;
#else
	CcuList::CcuListLink*	CurLink;
#endif
	listiter_status	StatusFlag;

public:
inline		CcuListIter (const CcuList& l) : TheList (&l), CurLink (0), StatusFlag (StartOfList)	{ }
inline	void	Reset ()		{ CurLink = 0; StatusFlag = StartOfList; }
inline	CcuListIter&	operator = (const CcuList& l)	{ TheList = &l; CurLink = 0; StatusFlag = StartOfList; return *this; }
inline	CcuListIter&	operator = (const CcuListIter& li)	{ TheList = li.TheList; CurLink = li.CurLink; StatusFlag = li.StatusFlag; return *this; }
	CcuListIter&	operator ++ ();
#ifndef CPLUS_BUG16
	CcuListIter&	operator ++ (int);
#endif
		int	Find (CcuListItem*);
	CcuListItem*	operator * () const;
inline	listiter_status	GetStatus () const		{ return StatusFlag; }
inline	operator int () const	{ return StatusFlag == Normal; }
};


#ifndef CPLUS_BUG19
template <class ITEM> class CcuListIterOf;

template <class ITEM> class CcuListOf : public CcuList {
public:
inline		CcuListOf () : CcuList ()	{}
inline		CcuListOf (ITEM* it) : CcuList (it)	{}
inline	ITEM*	First ()	{ return (ITEM*) (CcuList::First ()); }
inline	ITEM*	Last ()	{ return (ITEM*) (CcuList::Last ()); }
inline	ITEM*	Nth (int n)	{ return (ITEM*) (CcuList::Nth (n)); }
inline	int	Find (ITEM* it) const	{ return CcuList::Find (it); }

inline	void	Append (ITEM* it)	{ CcuList::Append (it); }
inline	void	Prepend (ITEM* it)	{ CcuList::Prepend (it); }
inline	CcuListOf&	operator << (ITEM* it)	{ CcuList::Append (it); return *this; }

inline	ITEM*	RemoveFirst ()	{ return (ITEM*) (CcuList::RemoveFirst ()); }
inline	ITEM*	RemoveLast ()	{ return (ITEM*) (CcuList::RemoveLast ()); }
inline	int	Remove (ITEM* it, int nb = 1)	{ return CcuList::Remove (it, nb); }
inline	int	Remove (int (*p) (ITEM*), int nb = 1)	{ return CcuList::Remove ((int (*) (ITEM*)) p, nb); }

inline	void	InsertAfter (const CcuListIterOf <ITEM>& li, ITEM*it)	{ CcuList::InsertAfter (li, it); }
inline	void	InsertBefore (const CcuListIterOf <ITEM>& li, ITEM* it)	{ CcuList::InsertBefore (li, it); }
inline	ITEM*	RemoveAfter (const CcuListIterOf <ITEM>& li)		{ return (ITEM*) CcuList::RemoveAfter (li); }
};

template <class ITEM> class CcuListIterOf : public CcuListIter {
public:
inline		CcuListIterOf (const CcuListOf <ITEM>& l) : CcuListIter (l)	{ }
inline	CcuListIterOf&	operator =  (const CcuListOf <ITEM>& l)	{ return (CcuListIterOf&) CcuListIter::operator = (l); }
inline	CcuListIterOf&	operator =  (const CcuListIterOf& li)	{ return (CcuListIterOf&) CcuListIter::operator = (li); }
inline	ITEM*	operator * () const	{ return (ITEM*) CcuListIter::operator * (); }
inline	int	Find (ITEM* it)		{ return CcuListIter::Find (it); }
};
#endif	/* CPLUS_BUG19 */



typedef CcuListItem CcuStackItem;

/* CPLUS_BUG10 */
class CcuStack : _private CcuList {
public:
		CcuList :: Clear;
		CcuList :: IsEmpty;
		CcuList :: GetStatus;
inline void	Push (CcuStackItem* p)	{ Prepend (p); }
inline CcuStackItem*	Pop ()		{ return RemoveFirst (); }
inline CcuStackItem*	Top ()		{ return First (); }
};

typedef CcuListItem CcuQueueItem;

/* CPLUS_BUG10 */
class CcuQueue : _private CcuList {
public:
		CcuList :: Clear;
		CcuList :: IsEmpty;
		CcuList :: GetStatus;
inline void	Put (CcuQueueItem* p)	{ Append (p); }
inline CcuQueueItem*	Get ()		{ return RemoveFirst (); }
inline		operator const CcuList& ()	{ return *this; }
};

#ifndef CPLUS_BUG19
template <class ITEM> class CcuQueueOf : public CcuQueue {
public:
inline void	Put (ITEM* p)	{ CcuQueue::Put (p); }
inline ITEM*	Get ()		{ return (ITEM*) CcuQueue::Get (); }
inline		operator const CcuListOf <ITEM>& ()	{ return *this; }
};
#endif	/* CPLUS_BUG19 */

#endif	/* List_H_ */