From 325530e630c68c7c10a2f4339f5b43434fcd0329 Mon Sep 17 00:00:00 2001
From: sc
Date: Tue, 28 Nov 2000 14:19:35 +0000
Subject: Incorporation into IvyLeague Ccu -> Ivl ccu -> ivl Smart pointers
 disappear (too dangerous) Imakefile disappears (Makefile now) An empty
 cplus_bugs.h has been created locally

---
 utils/Chain.h | 95 +++++++++++++++++++++++++++++------------------------------
 1 file changed, 47 insertions(+), 48 deletions(-)

(limited to 'utils/Chain.h')

diff --git a/utils/Chain.h b/utils/Chain.h
index b9ecf61..91d1315 100644
--- a/utils/Chain.h
+++ b/utils/Chain.h
@@ -17,92 +17,91 @@
 
 #include "cplus_bugs.h"
 
-typedef void CcuChainItem;
+typedef void IvlChainItem;
 
-class CcuChainIter;
+class IvlChainIter;
 
-
-class CcuChain {
-friend	class	CcuChainIter;
+class IvlChain {
+friend	class	IvlChainIter;
 public:
 	enum	chain_status	{ NoError, WasEmpty, TooEarly, TooFar, BadIterator };
 
 protected:
-	CcuChainItem*	LastLink;
+	IvlChainItem*	LastLink;
 	chain_status	StatusFlag;
-inline		CcuChain () : LastLink (0), StatusFlag (NoError)	{ }
-inline		CcuChain (CcuChainItem* e) : LastLink (e), StatusFlag (NoError) { }
-virtual		~CcuChain ();
+inline		IvlChain () : LastLink (0), StatusFlag (NoError)	{ }
+inline		IvlChain (IvlChainItem* e) : LastLink (e), StatusFlag (NoError) { }
+virtual		~IvlChain ();
 
-virtual	CcuChainItem*	GetNext (CcuChainItem*) const = 0;
-virtual	void	SetNext (CcuChainItem*, CcuChainItem*) const = 0;
-virtual	void	Delete (CcuChainItem*) const = 0;
-	CcuChainItem*	GetPrevious (CcuChainItem*) ;
+virtual	IvlChainItem*	GetNext (IvlChainItem*) const = 0;
+virtual	void	SetNext (IvlChainItem*, IvlChainItem*) const = 0;
+virtual	void	Delete (IvlChainItem*) const = 0;
+	IvlChainItem*	GetPrevious (IvlChainItem*) ;
 
 public:
 inline	chain_status	GetStatus () const		{ return StatusFlag; }
 inline	int	IsEmpty () const			{ return !LastLink; }
-	CcuChainItem*	First ();
-	CcuChainItem*	Last ();
-	CcuChainItem*	Nth (int n);
+	IvlChainItem*	First ();
+	IvlChainItem*	Last ();
+	IvlChainItem*	Nth (int n);
 	int	Length () const;
-	int	Find (CcuChainItem*) const;
+	int	Find (IvlChainItem*) const;
 
-	void	Append (CcuChainItem*);
-	void	Prepend (CcuChainItem*);
-inline	CcuChain&	operator << (CcuChainItem* it)	{ Append (it); return *this; }
+	void	Append (IvlChainItem*);
+	void	Prepend (IvlChainItem*);
+inline	IvlChain&	operator << (IvlChainItem* it)	{ Append (it); return *this; }
 
-	CcuChainItem*	RemoveFirst ();
-	CcuChainItem*	RemoveLast ();
-	int	Remove (CcuChainItem*);
-	int	Remove (int (*) (CcuChainItem*));
+	IvlChainItem*	RemoveFirst ();
+	IvlChainItem*	RemoveLast ();
+	int	Remove (IvlChainItem*);
+	int	Remove (int (*) (IvlChainItem*));
 	void	Clear ();
 
-	void	InsertAfter (const CcuChainIter&, CcuChainItem*);
-	void	InsertBefore (const CcuChainIter&, CcuChainItem*);
-	CcuChainItem*	RemoveAfter (const CcuChainIter&);
-	void	InsertAfter (CcuChainItem*, CcuChainItem*);
-	void	InsertBefore (CcuChainItem*, CcuChainItem*);
-	CcuChainItem*	RemoveAfter (CcuChainItem*);
+	void	InsertAfter (const IvlChainIter&, IvlChainItem*);
+	void	InsertBefore (const IvlChainIter&, IvlChainItem*);
+	IvlChainItem*	RemoveAfter (const IvlChainIter&);
+	void	InsertAfter (IvlChainItem*, IvlChainItem*);
+	void	InsertBefore (IvlChainItem*, IvlChainItem*);
+	IvlChainItem*	RemoveAfter (IvlChainItem*);
 };
 
-class CcuChainIter {
-friend	class	CcuChain;
+class IvlChainIter {
+friend	class	IvlChain;
 public:
 	enum	chainiter_status	{ Normal, StartOfChain, EndOfChain };
 private:
-	const CcuChain*	TheChain;
-	CcuChainItem*	CurLink;
+	const IvlChain*	TheChain;
+	IvlChainItem*	CurLink;
 	chainiter_status	StatusFlag;
 
 public:
-inline		CcuChainIter (const CcuChain& l) : TheChain (&l), CurLink (0), StatusFlag (StartOfChain)	{ }
+inline		IvlChainIter (const IvlChain& l) : TheChain (&l), CurLink (0), StatusFlag (StartOfChain)	{ }
 inline	void	Reset ()		{ CurLink = 0; StatusFlag = StartOfChain; }
-	CcuChainIter&	operator ++ ();
-	CcuChainItem*	operator * () const;
-		int	Find (CcuChainItem*);
+	IvlChainIter&	operator ++ ();
+	IvlChainItem*	operator * () const;
+		int	Find (IvlChainItem*);
 inline	chainiter_status	GetStatus () const		{ return StatusFlag; }
 inline	operator int () const	{ return StatusFlag == Normal; }
 };
 
 #ifndef CPLUS_BUG19
 
-template <class ITEM> class CcuChainOf : public CcuChain {
+template <class ITEM> class IvlChainOf : public IvlChain {
 protected:
-	CcuChainItem*	GetNext (CcuChainItem* i) const	{ return ((ITEM*) i)->GetNext (); }
-	void	SetNext (CcuChainItem* i, CcuChainItem* j) const	{ ((ITEM*) i)->SetNext ((ITEM*) j); }
-	void	Delete (CcuChainItem* i) const	{ delete (ITEM*) i; }
+	IvlChainItem*	GetNext (IvlChainItem* i) const	{ return ((ITEM*) i)->GetNext (); }
+	void	SetNext (IvlChainItem* i, IvlChainItem* j) const	{ ((ITEM*) i)->SetNext ((ITEM*) j); }
+	void	Delete (IvlChainItem* i) const	{ delete (ITEM*) i; }
 
 public:
-inline		CcuChainOf () : CcuChain ()		{ }
-inline		CcuChainOf (ITEM* e) : CcuChain (e)		{ }
-inline		~CcuChainOf ()	{}
+inline		IvlChainOf () : IvlChain ()		{ }
+inline		IvlChainOf (ITEM* e) : IvlChain (e)		{ }
+inline		~IvlChainOf ()	{}
 };
 
-template <class ITEM> class CcuChainIterOf : public CcuChainIter {
+template <class ITEM> class IvlChainIterOf : public IvlChainIter {
 public:
-inline		CcuChainIterOf (const CcuChainOf <ITEM>& l) : CcuChainIter (l)	{ }
-inline	ITEM*	operator * () const	{ return (ITEM*) CcuChainIter::operator * (); }
+inline		IvlChainIterOf (const IvlChainOf <ITEM>& l) : IvlChainIter (l)	{ }
+inline	ITEM*	operator * () const	{ return (ITEM*) IvlChainIter::operator * (); }
 };
 
 #endif	/* CPLUS_BUG19 */
-- 
cgit v1.1