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(const PArray<Data>& other);

      PArray<Data>& operator = (const PArray<Data>& 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_; }

   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();
      }
   }

   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();
      }
   }

   template <typename Data>
   inline Data& PArray<Data>::operator [] (int i) const
   {
      assert(ptrs_);
      assert(i >= 0);
      assert(i < size_);
      return *(ptrs_[i]);
   }

} 
#endif