DRArray.h

#ifndef UTIL_DR_ARRAY_H
#define UTIL_DR_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>        // base class
#include <util/misc/ReferenceCounter.h>   // member
#include <util/misc/CountedReference.h>   // member
#include <util/global.h>
 
namespace Util {

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

      DRArray();

      DRArray(int capacity);

      DRArray(DRArray<Data> const & other);

      ~DRArray();

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

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

      void allocate(int capacity);

      void deallocate();

      void associate(DRArray<Data>& arr, int beginId, int capacity);

      void dissociate();

      bool isAllocated() const;

      bool isOwner() const;

      bool isAssociated() const;
 
   protected:
 
      using Array<Data>::data_;
      using Array<Data>::capacity_;

      ReferenceCounter refCounter_;

      CountedReference ref_;
 
   };
 
   // Inline member function definitions
 
   /*
   * Does this DRArray have data (either owned or associated) ?
   */
   template <typename Data> inline
   bool DRArray<Data>::isAllocated() const
   {  return (bool)data_; }
 
   /*
   * Does this object own data?
   */
   template <typename Data> inline
   bool DRArray<Data>::isOwner() const
   {  return ((bool) data_ && !ref_.isAssociated()); }
 
   /*
   * Does this object reference data that it does not own?
   */
   template <typename Data> inline
   bool DRArray<Data>::isAssociated() const
   {  return ((bool) data_ && ref_.isAssociated()); }
 
   // Non-inline member function definitions
 
   /*
   * Default constructor.
   */
   template <typename Data>
   DRArray<Data>::DRArray()
    : Array<Data>()
   {}
 
   /*
   * Allocating constructor.
   */
   template <typename Data>
   DRArray<Data>::DRArray(int capacity)
    : Array<Data>()
   {  allocate(capacity); }
 
   /*
   * Copy constructor.
   */
   template <typename Data>
   DRArray<Data>::DRArray(DRArray<Data> const & other)
    : Array<Data>()
   {
      if (!other.isAllocated()) {
         UTIL_THROW("Other DRArray must be allocated.");
      }
      allocate(other.capacity_);
      for (int i = 0; i < capacity_; ++i) {
         data_[i] = other.data_[i];
      }
   }
 
   /*
   * Destructor.
   */
   template <typename Data>
   DRArray<Data>::~DRArray()
   {
      if (data_) {
         if (ref_.isAssociated()) {
            ref_.dissociate();
         } else {
            if (refCounter_.hasRefs()) {
               int nRef = refCounter_.nRef();
               std::cout
                   << std::endl
                   << "Error: Destroying a DRArray that is referenced by "
                   << nRef << " other(s)" << std::endl;
            }
            Memory::deallocate<Data>(data_, capacity_);
         }
      }
      data_ = nullptr;
      capacity_ = 0;
   }
 
   /*
   * Assignment from another DRArray<Data> (deep copy).
   */
   template <typename Data>
   DRArray<Data>& DRArray<Data>::operator = (DRArray<Data> const & other)
   {
      // Check for self assignment
      if (this == &other) return *this;
 
      // Precondition - other array must be allocated
      UTIL_CHECK (other.isAllocated());
 
      // If this 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;
   }
 
   /*
   * Assignment from an Array<Data> (deep copy).
   */
   template <typename Data>
   DRArray<Data>& DRArray<Data>::operator = (Array<Data> const & other)
   {
      // Check for self assignment
      if (dynamic_cast< Array<Data>* >(this) == &other) return *this;
 
      // Precondition - other array must be allocated
      UTIL_CHECK(other.capacity() > 0);
 
      // If this 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 an underlying C array, which this container then owns.
   */
   template <typename Data>
   void DRArray<Data>::allocate(int capacity)
   {
      if (capacity <= 0) {
         UTIL_THROW("Attempt to allocate with capacity <= 0");
      }
      if (isAllocated()) {
         UTIL_THROW("Attempt to allocate a DRArray that already has data.");
      }
      Memory::allocate<Data>(data_, capacity);
      capacity_ = capacity;
   }
 
   /*
   * Deallocate a C array that is owned by this container.
   */
   template <typename Data>
   void DRArray<Data>::deallocate()
   {
      UTIL_CHECK(data_);
      UTIL_CHECK(!ref_.isAssociated());
      Memory::deallocate<Data>(data_, capacity_);
      capacity_ = 0;
      UTIL_CHECK(!refCounter_.hasRefs());
   }
 
   /*
   * Associate this object with a slice of a different DRArray.
   */
   template <typename Data>
   void DRArray<Data>::associate(DRArray<Data>& owner,
                                 int beginId, int capacity)
   {
      UTIL_CHECK(owner.isAllocated());
      UTIL_CHECK(owner.isOwner());
      UTIL_CHECK(beginId >= 0);
      UTIL_CHECK(capacity > 0);
      UTIL_CHECK(beginId + capacity <= owner.capacity());
      UTIL_CHECK(!data_);
      UTIL_CHECK(!ref_.isAssociated());
 
      // Copy data pointer and capacity
      data_ = owner.cArray() + beginId;
      capacity_ = capacity;
 
      // Associate private ReferencecCounter of the data owner with the
      // CountedReference ref_ member variable of this data user.
      ref_.associate(owner.refCounter_);
 
      // On exit from CountedReference::associate, the ReferenceCounter
      // is incremented and the CountedReference has a pointer to the
      // ReferenceCounter.
   }
 
   /*
   * Dissociate this object from array sliced owned by another object.
   */
   template <typename Data>
   void DRArray<Data>::dissociate()
   {
      UTIL_CHECK(data_);
      UTIL_CHECK(ref_.isAssociated());
 
      data_ = nullptr;
      capacity_ = 0;
      ref_.dissociate();
   }
 
} // namespace Util
#endif