FArray.h

#ifndef UTIL_F_ARRAY_H
#define UTIL_F_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>
 
#ifdef UTIL_MPI
#include <util/mpi/MpiTraits.h>   
#include <util/mpi/MpiStructBuilder.h>   
#endif 
 
namespace Util
{
 
   template <typename Data, int Capacity>
   class FArray 
   {
 
   public:
 
      FArray();
 
      FArray(FArray<Data, Capacity> const & other);
   
      // Default destructor is okay.
 
      FArray<Data, Capacity>& operator = (FArray<Data, Capacity> const & other);
 
      int size() const;
 
      int capacity() const;
 
      void begin(ArrayIterator<Data> &iterator);
 
      void begin(ConstArrayIterator<Data> &iterator) const;
 
      Data& operator[] (int i);
 
      Data const & operator[] (int i) const;
 
      Data* cArray();
 
      Data const * cArray() const;
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
      int packedSize();
 
      #ifdef UTIL_MPI
      static void commitMpiType();
      #endif
 
   private:
 
      Data data_[Capacity];
 
   };
 
   /*
   * Constructor.
   */
   template <typename Data, int Capacity>
   FArray<Data, Capacity>::FArray()
   {}
 
   /*
   * Copy constructor.
   *
   *\param other the FArray to be copied.
   */
   template <typename Data, int Capacity>
   FArray<Data, Capacity>::FArray(FArray<Data, Capacity> const & other) 
   {
      for (int i = 0; i < Capacity; ++i) {
         data_[i] = other.data_[i];
      }
   }
 
   // Default destructor is okay.
 
   /*
   * Assignment, element by element.
   *
   * Capacity of LHS FArray must be >= size of RHS FArray.
   *
   * \param other the RHS FArray 
   */
   template <typename Data, int Capacity>
   FArray<Data, Capacity>& 
   FArray<Data, Capacity>::operator=(FArray<Data, Capacity> const & other) 
   {
 
      // Check for self assignment
      if (this == &other) return *this;
 
      // Copy elements
      for (int i = 0; i < Capacity; ++i) {
         data_[i] = other[i];
      }
      return *this;
   }
 
   /*
   * Return number of elements in this FArray.
   */
   template <typename Data, int Capacity>
   inline int FArray<Data, Capacity>::size() const
   {  return Capacity; }
 
   /*
   * Return number of elements in this FArray.
   */
   template <typename Data, int Capacity>
   inline int FArray<Data, Capacity>::capacity() const
   { return Capacity; }
 
   /*
   * Set an ArrayIterator to the beginning of this Array.
   */
   template <typename Data, int Capacity>
   inline 
   void FArray<Data, Capacity>::begin(ArrayIterator<Data> &iterator)
   {
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + Capacity);
   }
 
   /*
   * Set a ConstArrayIterator to the beginning of this Array.
   */
   template <typename Data, int Capacity>
   inline 
   void FArray<Data, Capacity>::begin(ConstArrayIterator<Data> &iterator) 
   const
   {
      iterator.setCurrent(data_);
      iterator.setEnd(data_ + Capacity);
   }
 
   /*
   * Mimic C array subscripting.
   */
   template <typename Data, int Capacity>
   inline Data& FArray<Data, Capacity>::operator[] (int i)
   {
      assert(i < Capacity);
      assert(i >= 0);
      return data_[i];
   }
 
   /*
   * Mimic C array subscripting.
   */
   template <typename Data, int Capacity>
   inline Data const & FArray<Data, Capacity>::operator[] (int i) const
   {
      assert(i < Capacity);
      assert(i >= 0 );
      return data_[i];
   }
 
   /*
   * Return pointer to underlying C array.
   */
   template <typename Data, int Capacity>
   inline Data* FArray<Data, Capacity>::cArray()
   {  return data_; }
 
   /*
   * Return pointer to const to underlying C array.
   */
   template <typename Data, int Capacity>
   Data const * FArray<Data, Capacity>::cArray() const
   {  return data_; }
 
   /*
   * Serialize a FArray to/from an Archive.
   */
   template <class Data, int Capacity>
   template <class Archive>
   void FArray<Data, Capacity>::serialize(Archive& ar, 
                                          const unsigned int version)
   {
      for (int i = 0; i < Capacity; ++i) {
         ar & data_[i];
      }
   }
 
   /*
   * Packed size of FArray in a MemoryArchive, in bytes.
   */
   template <typename Data, int Capacity>
   int FArray<Data, Capacity>::packedSize()
   {  return Capacity*sizeof(Data); }
 
   #ifdef UTIL_MPI
   /*
   * Commit associated MPI Datatype.
   */
   template <typename Data, int Capacity>
   void FArray<Data, Capacity>::commitMpiType() 
   {
      if (!MpiTraits< FArray<Data, Capacity > >::hasType) {
         MpiStructBuilder       builder;
         FArray<Data, Capacity> object;
   
         builder.setBase(&object);
         for (int i = 0; i < Capacity; ++i) {
            builder.addMember(&(object.data_[i]), MpiTraits<Data>::type);
         }
         builder.commit(MpiTraits< FArray<Data, Capacity> >::type);
         MpiTraits< FArray<Data, Capacity> >::hasType = true;
      }
   }
   #endif 
} 
#endif