grid_key.hpp

#ifndef GRID_KEY_DX
#define GRID_KEY_DX

#include "Grid/comb.hpp"
#include "Grid/grid_key_expression.hpp"
#include "Space/Shape/Point.hpp"

template<unsigned int dim>
class grid_key_dx
{
public:

    template<typename exp1> inline grid_key_dx(const grid_key_dx_expression<dim,exp1> & exp)
    {
        for (size_t i = 0 ; i < dim ; i++)
            this->k[i] = exp.value(i);
    }

    inline grid_key_dx()
    {}

    inline grid_key_dx(std::initializer_list<long int> p1)
    {
        size_t i = 0;
        for(long int x : p1)
        {
            set_d(i,x);
            i++;
            if (i >= dim)
                break;
        }
    }

    inline grid_key_dx(const grid_key_dx<dim> & key)
    :grid_key_dx(key.k)
    {
    }

    inline grid_key_dx(const size_t (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
            this->k[i] = k[i];
    }

    inline grid_key_dx(const long int (&k)[dim])
    {
        for (size_t i = 0 ; i < dim ; i++)
        {this->k[i] = k[i];}
    }

    template<typename ...T> inline grid_key_dx(const comb<dim> & cmb)
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = cmb[i];
    }

    template<typename ...T> inline grid_key_dx(const size_t v,const T...t)
    {
#ifdef SE_CLASS1
        if (sizeof...(t) != dim -1)
        {std::cerr << "Error grid_key: " << __FILE__ << " " << __LINE__ << " creating a key of dimension " << dim << " require " << dim << " numbers " << sizeof...(t) + 1 << " provided" << "\n";}
#endif
        k[dim-1] = v;
        invert_assign(t...);
    }

    inline void zero()
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = 0;
    }

    inline void one()
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = 1;
    }

    inline void invalid()
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] = -1;
    }

    inline bool isValid()
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (k[i] != -1)
                return true;
        }

        return false;
    }

    inline grid_key_dx<dim> & operator+=(const grid_key_dx<dim> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] += p.k[i];

        return *this;
    }

    inline grid_key_dx<dim> & operator-=(const grid_key_dx<dim> & p)
    {
        for (size_t i = 0 ; i < dim ; i++)
            k[i] -= p.k[i];

        return *this;
    }

    inline grid_key_dx_sum<dim,grid_key_dx<dim>,grid_key_dx<dim>> operator+(const grid_key_dx<dim> & p) const
    {
        grid_key_dx_sum<dim,grid_key_dx<dim>,grid_key_dx<dim>> exp_sum(*this,p);

        return exp_sum;
    }

    inline grid_key_dx_sum<dim,grid_key_dx<dim>,Point<dim,long int>> operator+(const Point<dim,long int> & p) const
    {
        grid_key_dx_sum<dim,grid_key_dx<dim>,Point<dim,long int>> exp_sum(*this,p);

        return exp_sum;
    }

    inline grid_key_dx_sum<dim,grid_key_dx<dim>,comb<dim>> operator+(const comb<dim> & cmb) const
    {
        grid_key_dx_sum<dim,grid_key_dx<dim>,comb<dim>> exp_sum(*this,cmb);

        return exp_sum;
    }

    inline grid_key_dx_sub<dim,grid_key_dx<dim>,grid_key_dx<dim>> operator-(const grid_key_dx<dim> & cmb) const
    {
        grid_key_dx_sub<dim,grid_key_dx<dim>,grid_key_dx<dim>> exp_sum(*this,cmb);

        return exp_sum;
    }

    template <typename T> inline grid_key_dx_sub<dim,grid_key_dx<dim>,grid_key_dx_expression<dim,T>> operator-(const grid_key_dx_expression<dim,T> & cmb) const
    {
        grid_key_dx_sub<dim,grid_key_dx<dim>,grid_key_dx_expression<dim,T>> exp_sum(*this,cmb);

        return exp_sum;
    }

    template<unsigned int dim_t> bool operator==(const grid_key_dx<dim_t> & key_t) const
    {
        if (dim != dim_t)
        {
            return false;
        }

        // Check the two key index by index

        for (size_t i = 0 ; i < dim ; i++)
        {
            if (k[i] != key_t.k[i])
            {
                return false;
            }
        }

        // identical key
        return true;
    }


    template<unsigned int dim_t> bool operator!=(const grid_key_dx<dim_t> & key_t)
    {
        return !this->operator==(key_t);
    }


    template<typename a, typename ...T>
    inline void set(a v, T...t)
    {
#ifdef SE_CLASS1
        if (sizeof...(t) != dim -1)
            std::cerr << "Error grid_key: " << __FILE__ << " " << __LINE__ << "setting a key of dimension " << dim << " require " << dim << " numbers " << sizeof...(t) + 1 << " provided" << std::endl;
#endif
        k[dim-1] = v;
        invert_assign(t...);
    }

    const long int(& get_k() const)[dim]
    {
        return k;
    }

    Point<dim,long int> toPointS() const
    {
        Point<dim,long int> p;

        for (size_t i = 0; i < dim ; i++)
        {
            p.get(i) = get(i);
        }

        return p;
    }

    std::string to_string()
    {
        return this->toPointS().toString();
    }

    Point<dim,size_t> toPoint() const
    {
        Point<dim,size_t> p;

        for (size_t i = 0; i < dim ; i++)
        {
            p.get(i) = get(i);
        }

        return p;
    }


    inline mem_id value(size_t i) const
    {
        return k[i];
    }

    inline mem_id get(size_t i) const
    {
        return k[i];
    }

    inline void set_d(size_t i, mem_id id)
    {
#ifdef SE_CLASS1

        if (i >= dim)
            std::cerr << "grid_key_dx error: " << __FILE__ << " " << __LINE__ << " try to access dimension " << i << " on a grid_key_dx of size " << dim << "\n";

#endif
        k[i] = id;
    }

private:

    mem_id k[dim];

    template<typename a, typename ...T>void invert_assign(a v,T...t)
    {
        k[sizeof...(T)] = v;
        invert_assign(t...);
    }

    template<typename a, typename ...T>void invert_assign(a v)
    {
        k[0] = v;
    }

    void invert_assign()
    {
    }

};


template<unsigned int dim, unsigned int p>
class grid_key_d
{
public:


    template<typename a, typename ...T>grid_key_d(a v,T...t)
    {
        k[dim-1] = v;
        invert_assign(t...);
    }

    template<typename a, typename ...T>void invert_assign(a v,T...t)
    {
        k[sizeof...(T)] = v;
        invert_assign(t...);
    }

    template<typename a, typename ...T>void invert_assign(a v)
    {
        k[0] = v;
    }

    mem_id k[dim];
};


#endif