DataIterator.H

Go to the documentation of this file.

#ifdef CH_LANG_CC
/*
*      _______              __
*     / ___/ /  ___  __ _  / /  ___
*    / /__/ _ \/ _ \/  V \/ _ \/ _ \
*    \___/_//_/\___/_/_/_/_.__/\___/
*    Please refer to Copyright.txt, in Chombo's root directory.
*/
#endif

#ifndef _DATAITERATOR_H_
#define _DATAITERATOR_H_

#include "Vector.H"
#include "DataIndex.H"
#include "BoxLayout.H"
#include "SPMD.H"
#include "LayoutIterator.H"
#include "NamespaceHeader.H"


#ifdef CH_MPI


class DataIterator
{
  //Note: parallel version doesn't inherit LayoutIterator, serial version does
public:

  DataIterator();

  DataIterator(const BoxLayout& a_layout){*this = a_layout.dataIterator();}

  virtual ~DataIterator()
  {}


  inline const DataIndex& operator()() const ;

  DataIndex i() const { return this->operator()();}

  inline virtual void operator++();
  void incr() { ++(*this);}

  virtual bool ok() const;

  void begin();

  void reset();


  void end();

  int size() const { return m_indices->size();}

private:

  friend class BoxLayout;
  friend class DisjointBoxLayout;
  friend class TimedDataIterator;

  DataIterator(const BoxLayout& boxlayout, const int* layoutID);

  BoxLayout  m_layout;
  RefCountedPtr<Vector<DataIndex> > m_indices;
  int m_current;
};

inline DataIterator::DataIterator()
  : m_current(-1)
{}

inline const DataIndex& DataIterator::operator()() const
{
  CH_assert(ok());
  return m_indices->operator[](m_current);
}

inline void DataIterator::operator++()
{
  ++m_current;
}

inline bool DataIterator::ok() const
{
  return m_current < m_indices->size();
}

inline void DataIterator::reset()
{
  begin();
}

inline void DataIterator::begin()
{
  m_current=0;
}

#else

// serial version

class DataIterator : public LayoutIterator
{
public:
  virtual ~DataIterator()
  {}

  DataIterator()
  {}

  DataIterator(const BoxLayout& a_layout){*this = a_layout.dataIterator();}


  const DataIndex& operator()() const
  {
    return (const DataIndex&)(LayoutIterator::operator()());
  };


  DataIndex i() const {return this->operator()();}

  int size() const { return this->m_layout.size();}

private:
  friend class BoxLayout;
  friend class DisjointBoxLayout;
  friend class TimedDataIterator;

protected:
  DataIterator(const BoxLayout& boxlayout, const int* layoutID)
    :LayoutIterator(boxlayout, layoutID)
  {}
};

#endif  /*CH_MPI*/

#define DATAITERATOR(CLASS, BOXLAYOUT) \
        DataIterator dit = BOXLAYOUT .dataIterator(); \
        for(dit.begin(); dit.ok(); ++dit) {     \
        DataIndex di = dit();                   \
        MT_BEGIN1(CLASS, DataIndex, di)

#define ENDITERATOR(CLASS)  \
        MT_END1(CLASS, DataIndex, di) \
        }

#define DATAITERATOR1(CLASS, BOXLAYOUT, TYPE1, VAL1) \
        DataIterator dit = BOXLAYOUT .dataIterator(); \
        for(dit.begin(); dit.ok(); ++dit) {     \
        DataIndex di = dit();                   \
        MT_BEGIN2(CLASS, TYPE1, VAL1, DataIndex, di)

#define ENDITERATOR1(CLASS, TYPE1, VAL1)  \
        MT_END2(CLASS, TYPE1, VAL1, DataIndex, di) \
        }

#define DATAITERATOR2(CLASS, BOXLAYOUT, TYPE1, VAL1, TYPE2, VAL2) \
        DataIterator dit = BOXLAYOUT .dataIterator(); \
        for(dit.begin(); dit.ok(); ++dit) {     \
        DataIndex di = dit();                   \
        MT_BEGIN3(CLASS, TYPE1, VAL1, TYPE2, VAL2, DataIndex, di)

#define ENDITERATOR2(CLASS, TYPE1, VAL1, TYPE2, VAL2)  \
        MT_END3(CLASS, TYPE1, VAL1, TYPE2, VAL2, DataIndex, di) \
        }

#include "NamespaceFooter.H"
#endif

---