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(FPArray<Data, Capacity> const & other);
 
      ~FPArray();
 
      FPArray<Data, Capacity>& operator=(FPArray<Data, Capacity> const & 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);
 
      Data const & 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(FPArray<Data, Capacity> const & 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=(FPArray<Data, Capacity> const & 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 Data const & 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