Proto_LevelIterators.H

#ifdef CH_LANG_CC
/*
 *      _______              __
 *     / ___/ /  ___  __ _  / /  ___
 *    / /__/ _ \/ _ \/  V \/ _ \/ _ \
 *    \___/_//_/\___/_/_/_/_.__/\___/
 *    Please refer to Copyright.txt, in Chombo's root directory.
 */
#endif
#ifndef Proto_LEVELITERATORS_H_
#define Proto_LEVELITERATORS_H_
#include <vector>
#include "Proto.H"
#include "Proto_DataIndex.H"
#include "Proto_DisjointBoxLayout.H"

namespace Proto
{
    class DataIterator
    {
        protected:
        
        DisjointBoxLayout m_dbl;
        DataIndex m_current;
        DataIndex m_end;
        
        public:
        
        inline DataIterator(const DisjointBoxLayout& a_dbl);
        inline DataIterator& begin();
        inline DataIndex& end(){return m_end;};
        inline bool ok();
        inline DataIterator& operator++();
        inline const DataIndex& operator*() const;
        inline Point point() const;
        inline Box box() const; 
    };
    class NeighborIterator
    {
        protected:
        
        DisjointBoxLayout m_dbl;
        Box m_bx;
        BoxIterator m_bxit;
        Point m_shift;
        DataIndex m_current;
        DataIndex m_end;
        ProblemDomain m_dProbC;
        
        public:
        
        //NeighborIterator();
        inline NeighborIterator(const DisjointBoxLayout& a_dbl, const Box& a_bx);
        //~NeighborIterator();

        inline NeighborIterator& begin();
        inline const DataIndex& end() const{return m_end;};
        inline bool ok() const {return (m_current != m_end);}
        inline NeighborIterator& operator++();

        inline const DataIndex& operator*() const{return m_current;};
        inline Point point() const;
        inline Box srcBox() const;
        inline Box destBox() const;
        inline Point shift();
        // Processor ID for current iterate.
        inline int procID(){return m_dbl.procID(m_current);}; 
    };
#if 0

    class FineFRIterator
    {
        public:
            FineFRIterator(const DataIndex& a_fineIndex,
                    const Point& a_refRatio);
            ~FineFRIterator();

            inline void begin();
            inline DataIndex end();
            inline void operator++();
            inline DataIndex operator*{return m_fineIndex;};

            inline Point operator();

            inline Box box();

            inline Point srcShift();
        protected:
            DataIndex m_fineIndex;
            pair<int,int> m_currentRegister;
            //first element is 0 or 1 (LoHiSide), second element is dir.
    };
    class CoarseFRIterator
    {
        public:
            CoarseFRIterator(const& a_DisjointBoxLayout m_fineDBL,
                    const DataIndex& a_coarseDit,
                    const Point& a_refRatio);
            ~CoarseFRIterator();
            void begin();
            bool end();
            void operator++();
            DataIndex operator();
            Box box();
            Point srcShift();
            DataIndex fromIndex();
        protected:
            DataIndex m_coarseDit;
            DisjointBoxlayout m_fine;
            pair<LoHiSide,int> m_currentRegisterSet;
            BoxIterator m_bxit;
            // For each LoHiSide, direction, we iterate over a box corresponding to the
            // fine boxes coarsened to single Points inside the coarse box.
    }
#endif
#include "implem/Proto_LevelIteratorsImplem.H"
} // end Proto namespace.
#endif