DArray.h

#ifndef UTIL_D_ARRAY_H
#define UTIL_D_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/Array.h>
#include <util/misc/Memory.h>
#include <util/global.h>
 
namespace Util
{

   template <typename Data>
   class DArray : public Array<Data>
   {
 
   public:

      DArray();

      DArray(int capacity);

      DArray(DArray<Data> const & other);

      virtual ~DArray();

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

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

      void allocate(int capacity);

      void deallocate();

      void reallocate(int capacity);

      bool isAllocated() const;

      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
   protected:
 
      using Array<Data>::data_;
      using Array<Data>::capacity_;
 
   };
 
   // Inline member function definition
 
   /*
   * Return true iff the data pointer is non-null, false otherwise.
   */
   template <typename Data> inline
   bool DArray<Data>::isAllocated() const
   {  return (bool)data_; }
 
   // Non-inline member function definitions
 
   /*
   * Default constructor.
   */
   template <typename Data>
   DArray<Data>::DArray()
    : Array<Data>()
   {}
 
   /*
   * Allocating constructor.
   */
   template <typename Data>
   DArray<Data>::DArray(int capacity)
    : Array<Data>()
   {  allocate(capacity); }
 
   /*
   * Copy constructor.
   *
   * Allocates memory and copies all elements by value.
   *
   *\param other the DArray to be copied.
   */
   template <typename Data>
   DArray<Data>::DArray(DArray<Data> const & other)
    : Array<Data>()
   {
      if (!other.isAllocated()) {
         UTIL_THROW("Other DArray must be allocated.");
      }
      Memory::allocate(data_, other.capacity_);
      capacity_ = other.capacity_;
      for (int i = 0; i < capacity_; ++i) {
         data_[i] = other.data_[i];
      }
   }
 
   /*
   * Destructor.
   */
   template <typename Data>
   DArray<Data>::~DArray()
   {
      if (isAllocated()) {
         Memory::deallocate<Data>(data_, capacity_);
         capacity_ = 0;
      }
   }
 
   /*
   * Assignment, element-by-element.
   *
   * This operator will allocate memory if not allocated previously.
   */
   template <typename Data>
   DArray<Data>& DArray<Data>::operator = (DArray<Data> const & other)
   {
      // Check for self assignment
      if (this == &other) return *this;
 
      // Precondition - require that other (RHS) array is allocated
      if (!other.isAllocated()) {
         UTIL_THROW("Other DArray must be allocated.");
      }
 
      // Allocate this (LHS) array if necessary
      if (!isAllocated()) {
         allocate(other.capacity());
      }
 
      // Require equal capacities
      if (capacity_ != other.capacity_) {
         UTIL_THROW("Cannot assign DArrays of unequal capacity");
      }
 
      // Copy all elements
      for (int i = 0; i < capacity_; ++i) {
         data_[i] = other[i];
      }
 
      return *this;
   }
 
   /*
   * Assignment from an Array<Data> (deep copy).
   */
   template <typename Data>
   DArray<Data>& DArray<Data>::operator = (Array<Data> const & other)
   {
      // Check for self assignment
      if (dynamic_cast< Array<Data>* >(this) == &other) return *this;
 
      // Precondition - other RHS array must be allocated
      UTIL_CHECK(other.capacity() > 0);
 
      // If this LHS array is not allocated, then allocate
      if (!isAllocated()) {
         allocate(other.capacity());
      }
 
      // Copy elements
      UTIL_CHECK(capacity_ == other.capacity());
      for (int i = 0; i < capacity_; ++i) {
         data_[i] = other[i];
      }
 
      return *this;
   }
 
   /*
   * Allocate the underlying C array.
   */
   template <typename Data>
   void DArray<Data>::allocate(int capacity)
   {
      if (capacity <= 0) {
         UTIL_THROW("Attempt to allocate with capacity <= 0");
      }
      if (isAllocated()) {
         UTIL_THROW("Attempt to re-allocate a DArray");
      }
      Memory::allocate<Data>(data_, capacity);
      capacity_ = capacity;
   }
 
   /*
   * Deallocate the underlying C array.
   */
   template <typename Data>
   void DArray<Data>::deallocate()
   {
      if (!isAllocated()) {
         UTIL_THROW("Array is not allocated");
      }
      Memory::deallocate<Data>(data_, capacity_);
      capacity_ = 0;
   }
 
   /*
   * Reallocate and copy the underlying C array.
   */
   template <typename Data>
   void DArray<Data>::reallocate(int capacity)
   {
      UTIL_CHECK(capacity >= 0);
      if (capacity == capacity_) return;
      UTIL_CHECK(capacity > capacity_);
      if (isAllocated()) {
         Memory::reallocate<Data>(data_, capacity_, capacity);
      } else {
         Memory::allocate<Data>(data_, capacity);
      }
      capacity_ = capacity;
   }
 
   /*
   * Serialize a DArray to/from an Archive.
   */
   template <typename Data>
   template <class Archive>
   void DArray<Data>::serialize(Archive& ar, const unsigned int version)
   {
      int capacity;
      if (Archive::is_saving()) {
         capacity = capacity_;
      }
      ar & capacity;
      if (Archive::is_loading()) {
         if (!isAllocated()) {
            if (capacity > 0) {
               allocate(capacity);
            }
         } else {
            if (capacity != capacity_) {
               UTIL_THROW("Inconsistent DArray capacities");
            }
         }
      }
      if (isAllocated()) {
         for (int i = 0; i < capacity_; ++i) {
            ar & data_[i];
         }
      }
   }
 
}
#endif