Array.h

#ifndef UTIL_ARRAY_H
#define UTIL_ARRAY_H

/*
* Util Package - C++ Utilities for Scientific Computation
*
* Copyright 2010 - 2017, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/

#include <util/containers/ArrayIterator.h>
#include <util/containers/ConstArrayIterator.h>
#include <util/global.h>

namespace Util
{

   template <typename Data>
   class Array
   {

   public:

      // Protected default constructor

      // Private unimplemented copy constructor, to prohibit copying.

      virtual ~Array();

      // Private unimplemented assignment operator, to prohibit assignment.

      int capacity() const;

      void begin(ArrayIterator<Data>& iterator);

      void begin(ConstArrayIterator<Data>& iterator) const;

      Data& operator [] (int i);

      const Data& operator [] (int i) const;

      Data* cArray();

      const Data* cArray() const;

   protected:

      Data* data_;

      int capacity_;

      Array();

   private:

      Array(const Array& other);

      Array<Data>& operator = (const Array<Data>& other);

   };

   /*
   * Default constructor.
   */
   template <typename Data>
   Array<Data>::Array()
    : data_(0),
      capacity_(0)
   {}

   /*
   * Destructor.
   */
   template <typename Data>
   Array<Data>::~Array()
   {}

   /*
   * Return allocated size.
   */
   template <typename Data>
   inline int Array<Data>::capacity() const
   {  return capacity_; }

   /*
   * Set an ArrayIterator to the beginning of this Array.
   */
   template <typename Data>
   inline void Array<Data>::begin(ArrayIterator<Data> &iterator)
   {
      assert(data_ != 0);
      assert(capacity_ > 0);
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + capacity_);
   }

   /*
   * Set a ConstArrayIterator to the beginning of this Array.
   */
   template <typename Data>
   inline void Array<Data>::begin(ConstArrayIterator<Data> &iterator) const
   {
      assert(data_ != 0);
      assert(capacity_ > 0);
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + capacity_);
   }

   /*
   * Get an element by reference (C-array subscripting)
   */
   template <typename Data>
   inline Data& Array<Data>::operator [] (int i)
   {
      assert(data_ != 0);
      assert(i >= 0);
      assert(i < capacity_);
      return *(data_ + i);
   }

   /*
   * Get an element by const reference (C-array subscripting)
   */
   template <typename Data>
   inline const Data& Array<Data>::operator [] (int i) const
   {
      assert(data_ != 0);
      assert(i >= 0 );
      assert(i < capacity_);
      return *(data_ + i);
   }

   /*
   * Get a pointer to the underlying C array.
   */
   template <typename Data>
   inline Data* Array<Data>::cArray()
   {  return data_; }

   /*
   * Get a pointer to const to the underlying C array.
   */
   template <typename Data>
   inline const Data* Array<Data>::cArray() const
   {  return data_; }

}
#endif