pspc/field/Field.h

#ifndef PSPC_FIELD_H
#define PSPC_FIELD_H
 
/*
* PSCF Package 
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <util/global.h>
 
namespace Pscf {
namespace Pspc
{
 
   using namespace Util;
 
   template <typename Data>
   class Field
   {
 
   public:
 
      Field();
 
      virtual ~Field();
 
      void allocate(int capacity);
 
      void deallocate();
 
      bool isAllocated() const;
 
      int capacity() const;
 
      Data & operator[] (int i);
 
      Data const & operator[] (int i) const;
 
      Data* cField();
 
      Data const * cField() const;
 
      template <class Archive>
      void serialize(Archive& ar, const unsigned int version);
 
   protected:
 
      Data* data_;
 
      int capacity_;
 
   private:
 
      Field(Field const & other);
 
      Field& operator = (Field const & other);
 
   };
 
   /*
   * Return allocated size.
   */
   template <typename Data>
   inline int Field<Data>::capacity() const
   {  return capacity_; }
 
   /*
   * Get an element by reference (C-array subscripting)
   */
   template <typename Data>
   inline Data& Field<Data>::operator[] (int i)
   {
      assert(data_ != 0);
      assert(i >= 0);
      assert(i < capacity_);
      return *(data_ + i);
   }
 
   /*
   * Get an element by const reference (C-array subscripting)
   */
   template <typename Data>
   inline Data const & Field<Data>::operator[] (int i) const
   {
      assert(data_ != 0);
      assert(i >= 0 );
      assert(i < capacity_);
      return *(data_ + i);
   }
 
   /*
   * Get a pointer to the underlying C array.
   */
   template <typename Data>
   inline Data* Field<Data>::cField()
   {  return data_; }
 
   /*
   * Get a pointer to const to the underlying C array.
   */
   template <typename Data>
   inline 
   Data const * Field<Data>::cField() const
   {  return data_; }
 
   /*
   * Return true if the Field has been allocated, false otherwise.
   */
   template <typename Data>
   inline bool Field<Data>::isAllocated() const
   {  return (bool)data_; }
 
   /*
   * Serialize a Field to/from an Archive.
   */
   template <typename Data>
   template <class Archive>
   void Field<Data>::serialize(Archive& ar, const unsigned int version)
   {
      int capacity;
      if (Archive::is_saving()) {
         capacity = capacity_;
      }
      ar & capacity;
      if (Archive::is_loading()) {
         if (!isAllocated()) {
            if (capacity > 0) {
               allocate(capacity);
            }
         } else {
            if (capacity != capacity_) {
               UTIL_THROW("Inconsistent Field capacities");
            }
         }
      }
      if (isAllocated()) {
         for (int i = 0; i < capacity_; ++i) {
            ar & data_[i];
         }
      }
   }
 
}
}
#include "Field.tpp"
#endif