diff options
Diffstat (limited to 'utils/Array.cc')
| -rw-r--r-- | utils/Array.cc | 228 |
1 files changed, 228 insertions, 0 deletions
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 */ + |