FSArray.h

#ifndef UTIL_FS_ARRAY_H
#define UTIL_FS_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/ArrayIterator.h>
#include <util/containers/ConstArrayIterator.h>
#include <util/global.h>
 
namespace Util
{
 
   template <typename Data, int Capacity>
   class FSArray 
   {
 
   public:
 
      FSArray();
 
      FSArray(FSArray<Data, Capacity> const & other); 
   
      FSArray<Data, Capacity>& operator=(FSArray<Data, Capacity> const & other);
 
      virtual ~FSArray();
 
      int capacity() const;
 
      int size() const;
 
      void begin(ArrayIterator<Data> &iterator);
 
      void begin(ConstArrayIterator<Data> &iterator) const;
 
      Data& operator[] (int i);
 
      Data const & operator[] (int i) const;
 
      void append(Data const & data);
 
      void clear();
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
      int packedSize();
 
   protected:
 
      Data data_[Capacity];
 
      int  size_;
 
   };
 
   /*
   * Constructor.
   */
   template <class Data, int Capacity>
   inline FSArray<Data, Capacity>::FSArray()
    : size_(0)
   {}
 
   /*
   * Copy constructor.
   *
   *\param other the FSArray to be copied.
   */
   template <class Data, int Capacity>
   FSArray<Data, Capacity>::FSArray(FSArray<Data, Capacity> const & other) 
   {
      size_  = other.size_;
      for (int i = 0; i < size_; ++i) {
         data_[i] = other.data_[i];
      }
   }
 
   /*
   * Assignment, element by element.
   *
   * Capacity of LHS FSArray must be >= size of RHS FSArray.
   *
   * \param other the RHS FSArray 
   */
   template <class Data, int Capacity>
   FSArray<Data, Capacity>& 
   FSArray<Data, Capacity>::operator=(FSArray<Data, Capacity> const & other) 
   {
 
      // Check for self assignment
      if (this == &other) return *this;
 
      // Copy elements
      size_ = other.size_;
      for (int i = 0; i < size_; ++i) {
         data_[i] = other[i];
      }
      return *this;
   }
 
   /*
   * Destructor.
   */
   template <class Data, int Capacity>
   FSArray<Data, Capacity>::~FSArray()
   {}
 
   /*
   * Return physical capacity of array.
   */
   template <class Data, int Capacity>
   int FSArray<Data, Capacity>::capacity() const
   { return Capacity; }
 
   /*
   * Return logical size of this array (i.e., number of elements).
   */
   template <class Data, int Capacity>
   int FSArray<Data, Capacity>::size() const
   { return size_; }
 
   /*
   * Set an ArrayIterator to the beginning of this Array.
   *
   * \param iterator ArrayIterator, initialized on output. 
   */
   template <class Data, int Capacity>
   void FSArray<Data, Capacity>::begin(ArrayIterator<Data> &iterator)
   {
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + size_);
   }
 
   /*
   * Set a ConstArrayIterator to the beginning of this Array.
   */
   template <class Data, int Capacity>
   void FSArray<Data, Capacity>::begin(ConstArrayIterator<Data> &iterator) const
   {
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + size_);
   }
 
   /*
   * Mimic C array subscripting.
   */
   template <class Data, int Capacity>
   Data& FSArray<Data, Capacity>::operator[] (int i) 
   {
      assert(i < size_);
      assert(i >= 0);
      return data_[i];
   }
 
   /*
   * Mimic C array subscripting.
   */
   template <class Data, int Capacity>
   Data const & FSArray<Data, Capacity>::operator[] (int i) const
   {
      assert(i < size_);
      assert(i >= 0);
      return data_[i];
   }
 
   /*
   * Append data to the end of the array.
   */
   template <class Data, int Capacity>
   inline void FSArray<Data, Capacity>::append(Data const & data) 
   {
      if (size_ == Capacity) {
         UTIL_THROW("Attempt to add to full FSArray");
      }
      data_[size_] = data;
      ++size_;
   }
 
   /*
   * Set logical size to zero.
   */
   template <class Data, int Capacity>
   inline void FSArray<Data, Capacity>::clear() 
   {  size_ = 0; }
 
   /*
   * Serialize a FSArray to/from an Archive.
   */
   template <class Data, int Capacity>
   template <class Archive>
   inline 
   void FSArray<Data, Capacity>::serialize(Archive& ar, 
                                           const unsigned int version)
   {
      ar & size_;
      if (size_ > Capacity) {
         UTIL_THROW("FSArray<Data, Capacity> with size > Capacity");
      }
      for (int i = 0; i < size_; ++i) {
         ar & data_[i];
      }
   }
 
   /*
   * Packed size of FSArray in a MemoryArchive, in bytes.
   */
   template <typename Data, int Capacity>
   inline int FSArray<Data, Capacity>::packedSize()
   {  return Capacity*sizeof(Data) + sizeof(int); }
 
} 
#endif