PArray.h

#ifndef UTIL_P_ARRAY_H
#define UTIL_P_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/PArrayIterator.h>
#include <util/containers/ConstPArrayIterator.h>
#include <util/global.h>
 
namespace Util
{
 
   template <typename Data>
   class PArray
   {
 
   public:
 
      // Protected default constructor
 
      virtual ~PArray();
 
      int capacity() const;
 
      int size() const;
 
      void begin(PArrayIterator<Data>& iterator) const;
 
      void begin(ConstPArrayIterator<Data>& iterator) const;
 
      Data& operator [] (int i) const;
 
   protected:
 
      PArray();
 
      Data** ptrs_;
 
      int capacity_;
 
      int size_;
 
   private:
 
      PArray(PArray<Data> const & other);
 
      PArray<Data>& operator = (PArray<Data> const & other);
 
   };
 
   /*
   * Constructor.
   */
   template <typename Data>
   inline PArray<Data>::PArray()
    : ptrs_(0),
      capacity_(0),
      size_(0)
   {}
 
   /*
   * Destructor.
   */
   template <typename Data>
   PArray<Data>::~PArray()
   {}
 
   /*
   * Return allocated size.
   */
   template <typename Data>
   inline int PArray<Data>::capacity() const
   {  return capacity_; }
 
   /*
   * Return logical size.
   */
   template <typename Data>
   inline int PArray<Data>::size() const
   {  return size_; }
 
   /*
   * Set an PArrayIterator to the beginning of this PArray.
   */
   template <typename Data>
   inline void PArray<Data>::begin(PArrayIterator<Data>& iterator) const
   {
      if (ptrs_ && size_ > 0) {
         iterator.setCurrent(ptrs_);
         iterator.setEnd(ptrs_ + size_);
      } else {
         iterator.setNull();
      }
   }
 
   /*
   * Set an ConstPArrayIterator to the beginning of this PArray.
   */
   template <typename Data>
   inline 
   void PArray<Data>::begin(ConstPArrayIterator<Data>& iterator) const
   {
      if (ptrs_ && size_ > 0) {
         iterator.setCurrent(ptrs_);
         iterator.setEnd(ptrs_ + size_);
      } else {
         iterator.setNull();
      }
   }
 
   /*
   * Subscript - return a reference.
   */
   template <typename Data>
   inline Data& PArray<Data>::operator [] (int i) const
   {
      assert(ptrs_);
      assert(i >= 0);
      assert(i < size_);
      return *(ptrs_[i]);
   }
 
} 
#endif