AMReX_BoxIterator.H

Go to the documentation of this file.

#ifndef AMREX_BOXITERATOR_H_
#define AMREX_BOXITERATOR_H_
#include <AMReX_Config.H>
 
#include <AMReX_BLassert.H>
#include <AMReX_REAL.H>
#include <AMReX_SPACE.H>
#include <AMReX_IntVect.H>
 
#include <cstdlib>
 
namespace amrex
{
 
template<int dim>
class BoxND;
 
template<int dim>
class BoxIteratorND
{
public:
 
    BoxIteratorND () noexcept = default;
 
    explicit BoxIteratorND (const BoxND<dim>& a_bx) noexcept {
        define(a_bx);
    }
 
    void setBox (const BoxND<dim>& a_bx) noexcept {
        define(a_bx);
    }
 
    void define (const BoxND<dim>& a_bx) noexcept {
        if (a_bx.ok()) {
            m_current = a_bx.smallEnd();
            m_boxLo   = a_bx.smallEnd();
            m_boxHi   = a_bx.bigEnd();
        } else {
            m_current = IntVectND<dim>::TheUnitVector();
            m_boxLo   = IntVectND<dim>::TheUnitVector();
            m_boxHi   = IntVectND<dim>::TheZeroVector();
        }
    }
 
    BoxIteratorND begin () noexcept {
        m_current = m_boxLo;
        return *this;
    }
 
    [[nodiscard]] BoxIteratorND end () const noexcept {
        BoxIteratorND ret = *this;
        // set current of end to the past-the-end IntVect
        ret.m_current = m_boxLo;
        if (m_boxLo.allLE(m_boxHi)) {
            ret.m_current[dim-1] = m_boxHi[dim-1] + 1;
        }
        return ret;
    }
 
    void reset () noexcept {
        begin();
    }
 
    BoxIteratorND& operator++ () noexcept {
        next();
        return *this;
    }
 
    void next () noexcept {
        for (int i=0; i<dim; ++i) {
            ++m_current[i];
            if ((i+1<dim) && m_current[i] > m_boxHi[i]) {
                m_current[i] = m_boxLo[i];
                continue;
            }
            break;
        }
    }
 
    [[nodiscard]] const IntVectND<dim>& operator () () const noexcept {
        AMREX_ASSERT(m_current.allLE(m_boxHi));
        AMREX_ASSERT(m_current.allGE(m_boxLo));
        return m_current;
    }
 
    [[nodiscard]] IntVectND<dim> operator* () const noexcept {
        AMREX_ASSERT(m_current.allLE(m_boxHi));
        AMREX_ASSERT(m_current.allGE(m_boxLo));
        // Returning by value gives cleaner assembly output.
        return m_current;
    }
 
    [[nodiscard]] bool ok () const noexcept {
        return m_current.allLE(m_boxHi);
    }
 
    [[nodiscard]] friend
    bool operator != (const BoxIteratorND& b1, const BoxIteratorND& b2) noexcept {
        // Only check one value for better performance.
        return b1.m_current[dim-1] != b2.m_current[dim-1];
    }
 
private:
    IntVectND<dim> m_current = IntVectND<dim>::TheUnitVector();
    IntVectND<dim> m_boxLo   = IntVectND<dim>::TheUnitVector();
    IntVectND<dim> m_boxHi   = IntVectND<dim>::TheZeroVector();
};
 
using BoxIterator = BoxIteratorND<AMREX_SPACEDIM>;
 
}
#endif