MeshIterator.h

#ifndef PSCF_MESH_ITERATOR_H
#define PSCF_MESH_ITERATOR_H
 
/*
* PSCF - Polymer Self-Consistent Field Theory
*
* Copyright 2016 - 2022, The Regents of the University of Minnesota
* Distributed under the terms of the GNU General Public License.
*/
 
#include <pscf/math/IntVec.h>           // member
 
namespace Pscf 
{
 
   using namespace Util;
 
   template <int D>
   class MeshIterator
   {
 
   public:
 
      MeshIterator();
 
      MeshIterator(const IntVec<D>& dimensions);
 
      // Compiler copy constructor.
 
      // Compiler default destructor.
 
      void setDimensions(const IntVec<D>& dimensions);
 
      void begin();
 
      void operator ++();
 
      bool atEnd() const;
 
      IntVec<D> position() const;
 
      int position(int i) const;
 
      int rank() const;
 
   private:
 
      IntVec<D> dimensions_;
 
      IntVec<D> position_;
 
      int rank_;
 
      int size_;
 
      void increment(int i);
 
   };
 
   // Explicit specialization declarations
 
   template<> 
   void MeshIterator<1>::operator ++();
 
   template<> 
   void MeshIterator<2>::operator ++();
 
   template<> 
   void MeshIterator<3>::operator ++();
 
   // Inline member functions
 
   // Return the entire IntVec<D>
   template <int D>
   inline IntVec<D> MeshIterator<D>::position() const
   {  return position_; }
 
   // Return one component of the position IntVec<D>
   template <int D>
   inline int MeshIterator<D>::position(int i) const
   {
      assert(i >=0);
      assert(i < D);
      return position_[i];
   }
 
   // Return the rank
   template <int D>
   inline int MeshIterator<D>::rank() const
   {  return rank_; }
 
   // Is this the end (i.e., one past the last point)?
   template <int D>
   inline bool MeshIterator<D>::atEnd() const
   { return (bool)(rank_ == size_); }
 
   // Inline explicit specializations 
 
   template <>
   inline void MeshIterator<1>::operator ++ ()
   {
      position_[0]++;
      if (position_[0] == dimensions_[0]) {
         position_[0] = 0;
      }
      rank_++;
   }
 
   template <>
   inline void MeshIterator<2>::operator ++ ()
   {
      position_[1]++;
      if (position_[1] == dimensions_[1]) {
         position_[1] = 0;
         increment(0);
      }
      rank_++;
   }
 
   template <>
   inline void MeshIterator<3>::operator ++ ()
   {
      position_[2]++;
      if (position_[2] == dimensions_[2]) {
         position_[2] = 0;
         increment(1);
      }
      rank_++;
   }
 
   #ifndef PSCF_MESH_ITERATOR_TPP
   // Suppress implicit instantiation
   extern template class MeshIterator<1>;
   extern template class MeshIterator<2>;
   extern template class MeshIterator<3>;
   #endif
 
}
#endif