DSArray.h

#ifndef UTIL_DS_ARRAY_H
#define UTIL_DS_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/misc/Memory.h>
#include <util/global.h>

namespace Util
{

   template <typename Data>
   class DSArray
   {

   public:

      DSArray();

      DSArray(const DSArray< Data >& other);

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

      virtual ~DSArray();

      void allocate(int capacity);

      void append(const Data &data);

      void resize(int size);

      void clear();

      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);

      void begin(ArrayIterator<Data> &iterator);

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

      Data& operator[] (int i);

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

      int capacity() const;

      int size() const;

      bool isAllocated() const;

   protected:

      Data *data_;

      int size_;

      int capacity_;

   };

   // Method definitions

   /*
   * Constructor.
   */
   template <class Data>
   DSArray<Data>::DSArray()
    : data_(0),
      size_(0),
      capacity_(0)
   {}

   /*
   * Copy constructor.
   */
   template <class Data>
   DSArray<Data>::DSArray(const DSArray< Data >& other)
    : data_(0),
      size_(0),
      capacity_(0)
   {
      // Precondition
      if (!other.isAllocated()) {
         UTIL_THROW("Other DSArray must be allocated.");
       }

      Memory::allocate<Data>(data_, other.capacity_);
      capacity_ = other.capacity_;
      size_ = other.size_;
      for (int i = 0; i < size_; ++i) {
         data_[i] = other.data_[i];
      }
   }

   /*
   * Assignment, element by element.
   *
   * Capacity of LHS DSArray must be zero or == capacity of RHS DSArray.
   */
   template <class Data>
   DSArray<Data>& DSArray<Data>::operator=(const DSArray<Data>& other)
   {
      // Check for self assignment
      if (this == &other) return *this;

      // Precondition
      if (!other.isAllocated()) {
         UTIL_THROW("Other DSArray must be allocated.");
      }

      if (!isAllocated()) {
         allocate(other.capacity_);
      } else if (capacity_ != other.capacity_) {
         UTIL_THROW("Cannot assign DSArrays of unequal capacity");
      }

      // Copy elements and set size
      for (int i = 0; i < other.size_; ++i) {
         data_[i] = other[i];
      }
      size_ = other.size_;

      return *this;
   }

   /*
   * Destructor.
   */
   template <class Data>
   DSArray<Data>::~DSArray()
   {
       size_ = 0;
       if (isAllocated()) {
          assert(capacity_);
          Memory::deallocate<Data>(data_, capacity_);
          capacity_ = 0;
       }
   }

   /*
   * Allocates the underlying C array.
   */
   template <class Data>
   void DSArray<Data>::allocate(int capacity)
   {
      if (isAllocated()) {
         UTIL_THROW("Cannot re-allocate a DSArray");
      }
      if (capacity <= 0) {
         UTIL_THROW("Cannot allocate a DSArray with capacity <= 0");
      }
      Memory::allocate<Data>(data_, capacity);
      capacity_ = capacity;
      size_ = 0;
   }

   /*
   * Serialize a DSArray to/from an Archive.
   */
   template <class Data>
   template <class Archive>
   void DSArray<Data>::serialize(Archive& ar, const unsigned int version)
   {
      int capacity;
      if (Archive::is_saving()) {
         if (!isAllocated()) {
            UTIL_THROW("Cannot save unallocated DSArray");
         }
         capacity = capacity_;
      }
      ar & capacity;
      ar & size_;
      if (Archive::is_loading()) {
         if (capacity <= 0) {
            UTIL_THROW("Invalid DSArray input capacity on load, capacity <= 0");
         }
         if (size_ < 0) {
            UTIL_THROW("Invalid DSArray input size on load, size < 0");
         }
         if (!isAllocated()) {
            allocate(capacity);
         }
         if (size_ > capacity_) {
            UTIL_THROW("Inconsistent DSArray size and capacity on load");
         }
      }
      for (int i = 0; i < size_; ++i) {
         ar & data_[i];
      }
   }

   template <class Data>
   inline
   void DSArray<Data>::begin(ArrayIterator<Data> &iterator)
   {
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + size_);
   }

   /*
   * Set a ConstArrayIterator to the beginning of this Array.
   */
   template <class Data>
   inline
   void DSArray<Data>::begin(ConstArrayIterator<Data> &iterator) const
   {
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + size_);
   }

   /*
   * Mimic C array subscripting.
   */
   template <class Data>
   inline Data& DSArray<Data>::operator[] (int i)
   {
      assert(i < size_);
      assert(i >= 0);
      return data_[i];
   }

   /*
   * Mimic C array subscripting.
   */
   template <class Data>
   inline const Data& DSArray<Data>::operator[] (int i) const
   {
      assert(i < size_);
      assert(i >= 0 );
      return data_[i];
   }

   /*
   * Append data to the end of the array.
   */
   template <class Data>
   inline void DSArray<Data>::append(const Data &data)
   {
      if (size_ == capacity_) {
         UTIL_THROW("Attempt to add to full DSArray");
      }
      data_[size_] = data;
      ++size_;
   }

   template <class Data>
   inline void DSArray<Data>::resize(int size)
   {  size_ = size; }

   /*
   * Set logical size to zero.
   */
   template <class Data>
   inline void DSArray<Data>::clear()
   {  size_ = 0; }

   /*
   * Return physical capacity of array.
   */
   template <class Data>
   inline int DSArray<Data>::capacity() const
   {  return capacity_; }

   /*
   * Return logical size of this array (i.e., number of elements).
   */
   template <class Data>
   inline int DSArray<Data>::size() const
   {  return size_; }

   /*
   * Return true if the DSArray has been allocated, false otherwise.
   */
   template <class Data>
   inline bool DSArray<Data>::isAllocated() const
   {  return (bool)data_; }

}
#endif