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, to prohibit direct instantiation.
 
      // 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);
 
      Data const & operator [] (int i) const;
 
      Data* cArray();
 
      Data const * cArray() const;
 
   protected:
 
      Data* data_;
 
      int capacity_;
 
      Array();
 
   private:
 
      Array(Array const & other);
 
      Array<Data>& operator = (Array<Data> const & 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 begin 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 begin 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 Data const & 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 Data const * Array<Data>::cArray() const
   {  return data_; }
 
}
#endif