MultiOperate.hpp

#ifndef __FIBER_MULTIDIMENSIONAL_OPERATE_HPP
#define __FIBER_MULTIDIMENSIONAL_OPERATE_HPP
 
#include "MultiIndex.hpp"
 
namespace Fiber
{
 
 
template <Dims_t Dims, class MultidimensionalOperator, int SkipDims = -1>
class   MultiOp : public MultiOp<Dims-1, MultidimensionalOperator, SkipDims>
{
protected:
        template <Dims_t  HigherDims>
        void    iterate(const MultiIndex<Dims>&Start, const MultiIndex<Dims>&End, const MultiIndex<HigherDims>&CurrentIndex)
        {
        const MultiIndex<Dims-1>&SubStart = Start,
                                &SubEnd   = End;
 
                for(index_t i = Start.maxidx(); i< End.maxidx(); i++)
                {
                MultiIndex<HigherDims> MyIndex = CurrentIndex;
                        MyIndex[ Dims-1 ] = i;
                        this->MultiOp<Dims-1, MultidimensionalOperator, SkipDims>::iterate( SubStart, SubEnd, MyIndex);
                }
        }
 
public:
        void    iterate(const MultiIndex<Dims>&Start, const MultiIndex<Dims>&End)
        {
                iterate( Start, End, Start);
        }
 
        MultiOp()
        {}
 
        template <class T>
        MultiOp(const T&t)
        : MultiOp<Dims-1, MultidimensionalOperator, SkipDims>(t)
        {}
};
 
 
template <class MultidimensionalOperator, int SkipDims >
class   MultiOp<1, MultidimensionalOperator, SkipDims> : public MultidimensionalOperator
{
protected:
        template <Dims_t HigherDims>
        void    iterate(const MultiIndex<1>&Start, const MultiIndex<1>&End, const MultiIndex<HigherDims>&CurrentIndex)
        {
                for(index_t i = Start[0]; i< End[0]; i++)
                {
                MultiIndex<HigherDims> MyIndex = CurrentIndex;
                        MyIndex[0] = i;
                        MultidimensionalOperator::apply( MyIndex );
                }
        }
 
public:
        void    iterate(const MultiIndex<1>&Start, const MultiIndex<1>&End)
        {
                iterate( Start, End, Start);
        }
 
 
        MultiOp()
        {}
 
        template <class T>
        MultiOp(const T&t)
        : MultidimensionalOperator(t)
        {}
};
 
 
 
template <Dims_t  Dims, class MultidimensionalOperator>
class   MultiOp<Dims, MultidimensionalOperator, Dims> : public MultiOp<Dims-1, MultidimensionalOperator, Dims>
{
protected:
        template <int HigherDims>
        void    iterate(const MultiIndex<Dims>&Start, const MultiIndex<Dims>&End, const MultiIndex<HigherDims>&CurrentIndex)
        {
        const MultiIndex<Dims-1>&SubStart = Start,
                                &SubEnd   = End;
 
                MultiOp<Dims-1, MultidimensionalOperator, Dims>::iterate( SubStart, SubEnd, CurrentIndex);
        }
 
public:
        void    iterate(const MultiIndex<Dims>&Start, const MultiIndex<Dims>&End)
        {
                iterate( Start, End, Start);
        }
 
        MultiOp()
        {}
 
        template <class T>
        MultiOp(const T&t)
        : MultiOp<Dims-1, MultidimensionalOperator, Dims>(t)
        {}
};
 
template <class MultidimensionalOperator>
class   MultiOp<1, MultidimensionalOperator, 1> : public MultidimensionalOperator
{
protected:
        template <Dims_t HigherDims>
        void    iterate(const MultiIndex<1>&Start, const MultiIndex<1>&End, const MultiIndex<HigherDims>&CurrentIndex)
        {
                MultidimensionalOperator::apply( CurrentIndex );
        }
 
public:
        MultiOp()
        {}
 
        template <class T>
        MultiOp(const T&t)
        : MultidimensionalOperator(t)
        {}
 
        void    iterate(const MultiIndex<1>&Start, const MultiIndex<1>&End)
        {
                iterate( Start, End, Start);
        }
};
 
 
template <Dims_t Dims, class MultidimensionalOperator, int SkipDims = -1>
class   MultiOperate : public MultiOp<Dims, MultidimensionalOperator, SkipDims+1>
{
public:
        typedef MultiOp<Dims, MultidimensionalOperator, SkipDims+1> Base_t;
 
        using Base_t::iterate;
 
        void    iterate(const MultiIndex<Dims>&End)
        {
        MultiIndex<Dims> Start;
                iterate( Start, End);
        }
 
        MultiOperate()
        {}
 
        MultiOperate(const MultiIndex<Dims>&End)
        {
                iterate( End );
        }
 
        MultiOperate(const MultiIndex<Dims>&Start, const MultiIndex<Dims>&End)
        {
                iterate( Start, End);
        }
 
 
        template <class T>
        MultiOperate(const T&t)
        : Base_t(t)
        {}
 
        template <class T>
        MultiOperate(const T&t, const MultiIndex<Dims>&End)
        : Base_t(t)
        {
                iterate( End );
        }
 
        template <class T>
        MultiOperate(const T&t, const MultiIndex<Dims>&Start, const MultiIndex<Dims>&End)
        : Base_t(t)
        {
                iterate( Start, End);
        }
 
};
 
 
} /* namespace Fiber */
 
#endif /*  __FIBER_MULTIDIMENSIONAL_OPERATE_HPP */