FPArray.h

#ifndef UTIL_FP_ARRAY_H
#define UTIL_FP_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, int Capacity>
   class FPArray 
   {

   public:

      FPArray();

      FPArray(const FPArray<Data, Capacity>& other);

      ~FPArray();

      FPArray<Data, Capacity>& operator=(const FPArray<Data, Capacity>& other);

      void append(Data &data);

      void clear();

      int capacity() const;

      int size() const;

      void begin(PArrayIterator<Data> &iterator);

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

      Data& operator[] (int i);

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

   protected:

      Data* ptrs_[Capacity];

      int  size_;

   };
      
   // Method definitions

   template <typename Data, int Capacity>
   inline FPArray<Data, Capacity>::FPArray()
    : size_(0)
   {}

   /*
   * Copy constructor, copy all pointers.
   */
   template<typename Data, int Capacity>
   FPArray<Data, Capacity>::FPArray(const FPArray<Data, Capacity>& other) 
   {

      // Copy pointer values
      int i;
      for (i = 0; i < other.size_; ++i) {
         ptrs_[i] = other.ptrs_[i];
      }
      size_ = other.size_;

      // Nullify any unused elements
      if (Capacity > size_) {
         for (i = size_; i < Capacity; ++i) {
            ptrs_[i] = 0;
         }
      }

   }

   /*
   * Assignment, element by element.
   */
   template <typename Data, int Capacity>
   FPArray<Data, Capacity>& 
   FPArray<Data, Capacity>::operator=(const FPArray<Data, Capacity>& other) 
   {

      // Check for self assignment
      if (this == &other) return *this;

      // Precondition
      if (Capacity < other.size_) {
         UTIL_THROW("LHS FPArray is too small");
      }

      // Copy pointers
      for (int i = 0; i < other.size_; ++i) {
         ptrs_[i] = other[i];
      }
      size_ = other.size_;

      // Nullify any unused elements
      if (Capacity > size_) {
         for (int i = size_; i < Capacity; ++i) {
            ptrs_[i] = 0;
         }
      }

      return *this;
   }
 
   template <typename Data, int Capacity>
   FPArray<Data, Capacity>::~FPArray()
   {}

   template <typename Data, int Capacity>
   inline int FPArray<Data, Capacity>::capacity() const
   { return Capacity; }

   /*
   * Return logical size of this array.
   */
   template <typename Data, int Capacity>
   inline int FPArray<Data, Capacity>::size() const
   { return size_; }

   /*
   * Set a PArrayIterator to the beginning of this Array.
   */
   template <typename Data, int Capacity>
   inline 
   void FPArray<Data, Capacity>::begin(PArrayIterator<Data> &iterator)
   {
      iterator.setCurrent(const_cast<Data**>(ptrs_));
      iterator.setEnd(const_cast<Data**>(ptrs_ + size_));
   }

   /*
   * Set a PArrayIterator to the beginning of this Array.
   */
   template <typename Data, int Capacity>
   inline 
   void FPArray<Data, Capacity>::begin(ConstPArrayIterator<Data> &iterator) const
   {
      iterator.setCurrent(const_cast<Data**>(ptrs_));
      iterator.setEnd(const_cast<Data**>(ptrs_ + size_));
   }

   /*
   * Mimic C array subscripting.
   *
   * \param  i array index
   * \return reference to element i
   */
   template <typename Data, int Capacity>
   inline Data& FPArray<Data, Capacity>::operator[] (int i)
   {
      assert(i < size_);
      assert(i >= 0);
      return *ptrs_[i];
   }

   /*
   * Mimic C array subscripting.
   *
   * \param i array index
   * \return const reference to element i
   */
   template <typename Data, int Capacity>
   inline const Data& FPArray<Data, Capacity>::operator[] (int i) const
   {
      assert(i < size_);
      assert(i >= 0 );
      return *ptrs_[i];
   }

   /*
   * Append data to the end of the array.
   *
   * \param data Data to add to end of array.
   */
   template <typename Data, int Capacity>
   inline void FPArray<Data, Capacity>::append(Data &data) 
   {
      if (size_ == Capacity) {
         UTIL_THROW("Attempt to add to full FPArray");
      }
      ptrs_[size_] = &data;
      ++size_;
   }

   /*
   * Set logical size to zero.
   */
   template <typename Data, int Capacity>
   inline void FPArray<Data, Capacity>::clear() 
   { 
      size_ = 0; 
      for (int i=0; i < Capacity; ++i) {
         ptrs_[i] = 0;
      }
   }

} 
#endif