From 3a4838bed13b767132cbdf06364b2658da6cc356 Mon Sep 17 00:00:00 2001
From: chatty
Date: Tue, 15 Dec 1992 10:55:33 +0000
Subject: Initial revision

---
 utils/Array.cc | 228 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 228 insertions(+)
 create mode 100644 utils/Array.cc

(limited to 'utils/Array.cc')

diff --git a/utils/Array.cc b/utils/Array.cc
new file mode 100644
index 0000000..e51e7ae
--- /dev/null
+++ b/utils/Array.cc
@@ -0,0 +1,228 @@
+/*
+ *	CENA C++ Utilities
+ *
+ *	by Stephane Chatty
+ *
+ *	Copyright 1990, 1991, 1992
+ *	Laboratoire de Recherche en Informatique (LRI)
+ *	Centre d'Etudes de la Navigation Aerienne (CENA)
+ *
+ *	plain and generic arrays (orginal C version by Michel Beaudouin-Lafon)
+ *
+ *	$Id$
+ *	$CurLog$
+ */
+
+#include "Array.h"
+#include <memory.h>
+#include <stdio.h>
+
+/*?class CcuArray
+\typ{CcuArray}s are dynamic arrays whose lower bound is 0. For a 
+\typ{CcuArray} with size \var{size}, the valid indices are \var{0, \ldots, size -- 1.}
+Their elements are of type \typ{CcuArrayItem*}. Methods are provided for 
+initialization, data storage and retrieval, and a few other utilities. 
+?*/
+
+CcuArrayItem* CcuArray::InvalidCell = 0;
+
+/*?
+Initialize a \typ{CcuArray} with size \var{size}.
+Entries are initialized to \var{value}.
+?*/
+CcuArray :: CcuArray (int size, CcuArrayItem* value)
+{
+	if (size > 0) {
+		Data = new CcuArrayItem* [size];
+		register CcuArrayItem** p = Data;
+		for (register int i = 0; i < size; ++i, ++p)
+			*p = value;
+	} else {
+		Data = 0;
+		size = 0;
+	}
+	
+	Length = size;
+
+}
+
+/*?nodoc?*/
+CcuArray :: CcuArray (const CcuArray& a)
+: Length (a.Length)
+{
+	if (Length == 0) {
+		Data = 0;
+	} else {
+		Data = new CcuArrayItem* [Length];
+		register CcuArrayItem** p;
+		register CcuArrayItem** q;
+		register int i;
+		for (p = Data, q = a.Data, i = Length ; i--; ++p, ++q)
+			*p = *q;
+	}
+}
+
+/*?nodoc?*/
+CcuArray :: ~CcuArray ()
+{
+	/* Free the data */
+	Clean ();
+}
+
+/*
+ *	Empty the array.
+ */
+/*?hidden?*/
+void
+CcuArray :: Clean ()
+{
+	if (Data)
+#ifndef CPLUS_BUG4
+		delete [] Data;
+#else
+		delete [Length] Data;
+#endif
+
+	Data = 0;
+	Length = 0;
+}
+
+
+/*?
+Set all entries to \var{value}.
+?*/
+void
+CcuArray :: Reset (CcuArrayItem* value)
+{
+	register CcuArrayItem** p;
+	register int i;
+	for (p = Data, i = Length ; i--; ++p)
+		*p = value;
+}
+
+/*?
+Copy the contents of the array \var{from} into this array.
+The old contents, if any, are freed, and new memory is allocated for the copy.
+?*/
+CcuArray&
+CcuArray :: operator = (const CcuArray& from)
+{
+	if (this != &from) {
+		Clean ();
+		Length = from.Length;
+		if (Length > 0 && from.Data) {
+			Data = new CcuArrayItem* [Length];
+			memcpy (Data, from.Data, Length * sizeof (CcuArrayItem*));
+		} else
+			Data = 0;
+	}
+	return *this;
+}
+
+/*?
+Change the size of the array to \var{size}. The new entries, if any,
+are set to \var{value}.
+This function reallocates the contents of the array.
+?*/
+void
+CcuArray :: Resize (int size, CcuArrayItem* value)
+{
+	if (size <= 0) {
+		Clean ();
+		return;
+	}
+
+	CcuArrayItem** NewData = new CcuArrayItem* [size];
+
+	/* if the new sequence is longer, copy and fill end, else just copy */
+	if (size > Length) {
+		if (Length)
+			memcpy (NewData, Data, Length * sizeof (CcuArrayItem*));
+
+		register CcuArrayItem** pfil = NewData + Length;
+		for (register int i = size - Length; i--; *pfil++ = value)
+			;
+	} else
+		memcpy (NewData, Data, size * sizeof (CcuArrayItem*));
+
+	
+	/* free old data and set new array */
+	Clean ();
+	Data = NewData;
+	Length = size;
+}
+
+
+/*?
+Return the address of the \var{i}th element.
+?*/
+CcuArrayItem**
+CcuArray :: operator + (register int i) const
+{
+	if (Check (i))
+		return Data+i;
+	else {
+		fprintf (stderr, "Index %d  out of array bounds: size was %d\n", i, Length);
+		return &InvalidCell;
+	}
+}
+
+
+/*?
+Get a reference to the \var{i}-th entry, so that this entry can be read or written.
+If \var{i} is outside the bounds, 
+the operator returns a reference to a static variable which initially contains 0.
+?*/
+CcuArrayItem*&
+CcuArray :: operator [] (register int i) const
+{
+	if (Check (i))
+		return Data [i];
+	else {
+		fprintf (stderr, "Index %d  out of array bounds: size was %d\n", i, Length);
+		return InvalidCell;
+	}
+}
+
+#ifdef DOC
+/*?class CcuArrayOf
+The generic class \typ{CcuArrayOf} is a derived class of \typ{CcuArray} that provides
+arrays of pointers to class objects. When parameterized by the class \typ{ITEM},
+the following functions are redefined:
+?*/
+
+/*?nextdoc?*/
+CcuArrayOf :: CcuArrayOf (int size, ITEM* value = 0)
+{
+}
+
+/*?nextdoc?*/
+void
+CcuArrayOf :: Reset (ITEM* value = 0)
+{
+}
+
+/*?nextdoc?*/
+void
+CcuArrayOf :: Resize (int size, ITEM* value = 0)
+{
+}
+
+/*?nextdoc?*/
+ITEM*&
+CcuArrayOf :: operator [] (int i) const
+{
+}
+
+/*?
+These functions are equivalent to their homonyms in the class \typ{CcuArray},
+except that they are customized in order to manipulate pointers to \typ{ITEM}
+instead of \typ{void*}.
+?*/
+ITEM**
+CcuArrayOf :: operator + (int i) const
+{
+}
+
+#endif	/* DOC */
+
-- 
cgit v1.1