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

      // Default destructor is okay.

      int size() const;

      int capacity() const;

      void begin(ArrayIterator<Data> &iterator);

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

      Data& operator[] (int i);

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

      Data* cArray();

      const Data* 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(const FArray<Data, Capacity>& other) 
   {
      for (int i = 0; i < Capacity; ++i) {
         data_[i] = other.data_[i];
      }
   }

   /*
   * 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=(const FArray<Data, Capacity>& 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;
   }

   // Default constructor is okay.

   /*
   * 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 const Data& 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>
   const Data* 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];
      }
   }

   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