#ifndef __ARRAY_H
#define __ARRAY_H
/**
 * array
 *
 * Implements a simple array with size in a constant attribute. Objects (or
 * basic data-types) are stored by value, just like in an ordinary array.
 */
template<class T>
class array
{
  T *A_data;
  public:
  /**
   * constructor
   *
   * Constructs an array of given size.
   *
   * @param<sz>  The size of the array
   * @precond    0 < sz
   */
  array(unsigned int sz) : size(sz), A_data(new T[sz]) {}
  /**
   * operator[]
   *
   * Allows the objects in the array to be selected using the array[i] syntax.
   *
   * @param<i>  The index of the object to be selected
   * @return    A reference to the selected object
   * @precond   0 <= i < size
   */
  T &operator[](unsigned int i) {return(A_data[i]);}
  /**
   * operator[] const
   *
   * Same as above, except doesn't allow to change the data contained within.
   *
   * @param<i>  The index of the object to be selected
   * @return    A const reference to the selected object
   * @precond   0 <= i < size
   */
  const T &operator[](unsigned int i) const {return(A_data[i]);}
  /**
   * operator=
   *
   * Copies the values from another array, until either array ends.
   *
   * @param<rv>  A const reference to the array on the right side of the
   *             equals-sign
   * @return     A const reference to this array after the operation
   * @precond    The substitution parameter of rv must match that of this array
   */
  array &operator=(const array &rv)
  {
    for(unsigned int i = 0; i < size && i < rv.size; i++)
      A_data[i] = rv[i];
    return(*this);
  }
  /**
   * destructor
   *
   * Releases the memory of the array and as such deletes all contained objects
   */
  ~array() {delete[] A_data;}
  /**
   * size
   *
   * Holds the size of the array in a constant. Since it is a public attribure,
   * it can be accessed straight without a function call.
   *
   * @example  array<int> arr(10);
   *           cout << arr.size << endl;
   */
  const unsigned int size;
};
/**
 * ptrArray
 *
 * Implements an array that stores pointers to objects (or basic data-types).
 * Has a public constant size-attribute.
 *
 * @todo  Add a constructor, which takes a variable argument list and
 *        initializes the array from the objects in that list
 */
template<class T>
class ptrArray
{
  T **A_data;
  public:
  /**
   * constructor
   *
   * Constructs an array of given size.
   *
   * @param<sz>  The size of the array
   * @precond    0 < sz
   */
  ptrArray(unsigned int sz) : size(sz), A_data(new T*[sz]) {}
  /**
   * operator[]
   *
   * Returns a reference to the pointer of the selected object.
   *
   * @param<i>  The index of the object to be selected
   * @return    A reference to the pointer of the object
   * @precond   0 <= i < size
   */
  T *&operator[](unsigned int i) {return(A_data[i]);}
  /**
   * operator[] const
   *
   * Same as above, but doesn't allow any modifications to the pointer.
   *
   * @param<i>  The index of the object to be selected
   * @return    A const reference to the pointer of the object
   * @precond   0 <= i < size
   */
  const T *&operator[](unsigned int i) const {return(A_data[i]);}
  /**
   * operator=
   *
   * Copies the pointers from another array, until either array ends.
   *
   * @param<rv>  A const reference to the array on the right side of the
   *             equals-sign
   * @return     A reference to this array
   * @precond    The substitution parameter of rv must match that of this array
   */
  ptrArray &operator=(const ptrArray &rv)
  {
    for(unsigned int i = 0; i < size && i < rv.size; i++)
      A_data[i] = rv[i];
    return(*this);
  }
  /**
   * pop
   *
   * Returns a pointer to the selected object and removes if from the array.
   *
   * @param<i>  The index of the object to be popped
   * @return    A pointer to the object
   * @precond   0 <= i < size
   */
  T *pop(unsigned int i) {T *temp = A_data[i]; A_data[i] = 0; return(temp);}
  /**
   * set
   *
   * Sets the given array location to point to the given object. Takes the
   * object by reference.
   *
   * @param<i>    The index of the location to be pointed to the object
   * @param<obj>  A reference to the object
   * @return      void
   * @precond     0 <= i < size
   */
  void set(unsigned int i, T &obj) {A_data[i] = &obj; return;}
  /**
   * set
   *
   * Same as above, except this one takes the object by pointer.
   *
   * @param<i>    The index of the location to be pointed to the object
   * @param<obj>  A pointer to the object
   * @return      void
   * @precond     0 <= i < size
   */
  void set(unsigned int i, T *obj) {A_data[i] = obj; return;}
  /**
   * destructor
   *
   * Releases the memory used to store the pointers to the objects.
   */
  ~ptrArray() {delete[] A_data;}
  /**
   * size
   *
   * Holds the size of the array in a constant. Since it is a public attribure,
   * it can be accessed straight without a function call.
   *
   * @example  array<int> arr(10);
   *           cout << arr.size << endl;
   */
  const unsigned int size;
};
#endif