grid_key_dx_iterator.hpp

/*
 * grid_key_dx_iterator.hpp
 *
 *  Created on: Dec 15, 2015
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_
#define OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_



template<unsigned int dim>
class grid_key_dx_iterator
{
#ifdef DEBUG
    // Actual status of the iterator, when the iterator is not initialized cannot be used
    // and reinitialize must be called
    bool initialized = false;
#endif

    grid_sm<dim,void> grid_base;

    size_t get_gk(size_t i) const
    {
        return gk.get(i);
    }

protected:

    grid_key_dx<dim> gk;

public:

    grid_key_dx_iterator()
    {
#ifdef DEBUG
        initialized = false;
#endif
    }

    grid_key_dx_iterator(const grid_key_dx_iterator<dim> & g_it)
    : grid_base(g_it.grid_base)
    {

        for (size_t i = 0 ; i < dim ; i++)
        {
            gk.set_d(i,g_it.get_gk(i));
        }

#ifdef DEBUG
        initialized = true;
#endif
    }

    template<typename T> grid_key_dx_iterator(const grid_sm<dim,T> & g)
    : grid_base(g)
    {
        reset();

#ifdef DEBUG
        initialized = true;
#endif
    }

    grid_key_dx_iterator<dim> operator=(const grid_key_dx_iterator<dim> & key_it)
    {
        grid_base = key_it.grid_base;


        for (size_t i = 0 ; i < dim ; i++)
        {gk.set_d(i,key_it.get_gk(i));}

        return *this;
    }

    grid_key_dx_iterator<dim> & operator++()
    {

        size_t id = gk.get(0);
        gk.set_d(0,id+1);


        size_t i = 0;
        for ( ; i < dim-1 ; i++)
        {
            size_t id = gk.get(i);
            if (id >= grid_base.size(i))
            {
                // ! overflow, increment the next index

                gk.set_d(i,0);
                id = gk.get(i+1);
                gk.set_d(i+1,id+1);
            }
            else
            {
                break;
            }
        }

        return *this;
    }

    void set(int d, size_t sz)
    {
        // set the counter dim to sz

        gk.set_d(d,sz);
    }

    bool isNext()
    {
        if (gk.get(dim-1) < (long int)grid_base.size(dim-1))
        {

            return true;
        }

        return false;
    }

    const grid_key_dx<dim> & get()
    {
        return gk;
    }

    void reinitialize(const grid_key_dx_iterator<dim> & key)
    {
        grid_base = key.grid_base;
        reset();
    }

    void reset()
    {

        for (size_t i = 0 ; i < dim ; i++)
        {gk.set_d(i,0);}
    }
};


#endif /* OPENFPM_DATA_SRC_GRID_ITERATORS_GRID_KEY_DX_ITERATOR_HPP_ */