grid_base_implementation.hpp

/*
 * grid_base_implementation.hpp
 *
 *  Created on: May 2, 2016
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_GRID_GRID_BASE_IMPLEMENTATION_HPP_
#define OPENFPM_DATA_SRC_GRID_GRID_BASE_IMPLEMENTATION_HPP_

#include "grid_base_impl_layout.hpp"
#include "copy_grid_fast.hpp"

template<unsigned int dim, typename T, typename S, typename layout_, template<typename> class layout_base >
class grid_base_impl
{
    typedef layout_ layout;

public:

    typedef layout_ layout_type;

    static constexpr unsigned int dims = dim;

    typedef grid_key_dx<dim> access_key;

    typedef typename T::type T_type;

protected:

    layout data_;

    grid_sm<dim,T> g1;

private:

    bool is_mem_init = false;

    bool isExternal;

#ifdef SE_CLASS1

    inline void check_init() const
    {
        if (is_mem_init == false)
        {
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " you must call SetMemory before access the grid\n";
            ACTION_ON_ERROR(GRID_ERROR_OBJECT);
        }
    }

    inline void check_bound(const grid_key_dx<dim> & v1) const
    {
        for (long int i = 0 ; i < dim ; i++)
        {
            if (v1.get(i) >= (long int)getGrid().size(i))
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << v1.get(i) << " >= " << getGrid().size(i) << "\n";
                ACTION_ON_ERROR(GRID_ERROR_OBJECT);
            }
            else if (v1.get(i) < 0)
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << v1.get(i) << " is negative " << "\n";
                ACTION_ON_ERROR(GRID_ERROR_OBJECT);
            }
        }
    }

    inline void check_bound(size_t v1) const
    {
        if (v1 >= getGrid().size())
        {
            std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << v1<< " >= " << getGrid().size() << "\n";
            ACTION_ON_ERROR(GRID_ERROR_OBJECT);
        }
    }

    template<typename Mem> inline void check_bound(const grid_base_impl<dim,T,Mem,layout,layout_base> & g,const grid_key_dx<dim> & key2) const
    {
        for (size_t i = 0 ; i < dim ; i++)
        {
            if (key2.get(i) >= (long int)g.getGrid().size(i))
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << key2.get(i) << " >= " << g.getGrid().size(i) << "\n";
                ACTION_ON_ERROR(GRID_ERROR_OBJECT);
            }
            else if (key2.get(i) < 0)
            {
                std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << "x=[" << i << "]=" << key2.get(i) << " is negative " << "\n";
                ACTION_ON_ERROR(GRID_ERROR_OBJECT);
            }
        }
    }

    template<typename Mem> inline void check_bound(const grid_base_impl<dim,T,Mem,layout,layout_base> & g,const size_t & key2) const
    {
        if (key2 >= g.getGrid().size())
        {
            std::cerr << "Error " __FILE__ << ":" << __LINE__ <<" grid overflow " << key2 << " >= " << getGrid().size() << "\n";
            ACTION_ON_ERROR(GRID_ERROR_OBJECT);
        }
    }

#endif

public:

    // Implementation of packer and unpacker for grid
    #include "grid_pack_unpack.ipp"

    typedef int yes_i_am_grid;

    typedef typename memory_traits_lin<typename T::type>::type memory_lin;

    // you can access all the properties of T
    typedef encapc<dim,T,layout> container;

    typedef T value_type;

    grid_base_impl() THROW
    :g1(0),isExternal(false)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    grid_base_impl(const grid_base_impl & g) THROW
    :isExternal(false)
    {
        this->operator=(g);
    }

    grid_base_impl(const size_t & sz) THROW
    :g1(sz),isExternal(false)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    grid_base_impl(const size_t (& sz)[dim]) THROW
    :g1(sz),isExternal(false)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
    }

    ~grid_base_impl() THROW
    {
        // delete this pointer
#ifdef SE_CLASS2
        check_delete(this);
#endif
    }

    grid_base_impl<dim,T,S,layout,layout_base> & operator=(const grid_base_impl<dim,T,S,layout,layout_base> & g)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif
        swap(g.duplicate());

        return *this;
    }

    grid_base_impl<dim,T,S,layout,layout_base> & operator=(grid_base_impl<dim,T,S,layout,layout_base> && g)
    {
        // Add this pointer
#ifdef SE_CLASS2
        check_new(this,8,GRID_EVENT,1);
#endif

        swap(g);

        return *this;
    }

    bool operator==(const grid_base_impl<dim,T,S,layout,layout_base> & g)
    {
        // check if the have the same size
        if (g1 != g.g1)
            return false;

        auto it = getIterator();

        while (it.isNext())
        {
            auto key = it.get();

            if (this->get_o(key) != this->get_o(key))
                return false;

            ++it;
        }

        return true;
    }

    grid_base_impl<dim,T,S,layout,layout_base> duplicate() const THROW
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        grid_base_impl<dim,T,S,layout,layout_base> grid_new(g1.getSize());

        grid_new.setMemory();

        // We know that, if it is 1D we can safely copy the memory
//      if (dim == 1)
//      {
//          grid_new.data_.mem->copy(*data_.mem);
//      }
//      else
//      {

            grid_key_dx_iterator<dim> it(g1);

            while(it.isNext())
            {
                grid_new.set(it.get(),*this,it.get());

                ++it;
            }
//      }

        // copy grid_new to the base

        return grid_new;
    }

    const grid_sm<dim,T> & getGrid() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return g1;
    }

    void setMemory()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        mem_setm<S,layout_base<T>,decltype(this->data_),decltype(this->g1)>::setMemory(data_,g1,is_mem_init);
    }

    void setMemory(S & m)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        isExternal = true;

        data_.setMemory(m);

        if (g1.size() != 0) data_.allocate(g1.size(),T::noPointers());

        is_mem_init = true;
    }

    void * getPointer()
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        if (data_.mem_r == NULL)
            return NULL;

        return data_.mem_r->get_pointer();
    }

    const void * getPointer() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        if (data_.mem_r == NULL)
            return NULL;

        return data_.mem_r->get_pointer();
    }

    template <unsigned int p, typename r_type=decltype(mem_get<p,layout_base<T>,layout,grid_sm<dim,T>,grid_key_dx<dim>>::get(data_,g1,grid_key_dx<dim>()))> inline r_type get(const grid_key_dx<dim> & v1)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
        return mem_get<p,layout_base<T>,decltype(this->data_),decltype(this->g1),decltype(v1)>::get(data_,g1,v1);
    }

    template <unsigned int p, typename r_type=decltype(mem_get<p,layout_base<T>,layout,grid_sm<dim,T>,grid_key_dx<dim>>::get(data_,g1,grid_key_dx<dim>()))>
    inline const r_type get(const grid_key_dx<dim> & v1) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
        return mem_get<p,layout_base<T>,decltype(this->data_),decltype(this->g1),decltype(v1)>::get(data_,g1,v1);
    }

    template <unsigned int p, typename r_type=decltype(mem_get<p,layout_base<T>,layout,grid_sm<dim,T>,grid_key_dx<dim>>::get_lin(data_,g1,0))>
    inline r_type get(const size_t lin_id)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(lin_id);
#endif
        return mem_get<p,layout_base<T>,decltype(this->data_),decltype(this->g1),grid_key_dx<dim>>::get_lin(data_,g1,lin_id);
    }

    template <unsigned int p, typename r_type=decltype(mem_get<p,layout_base<T>,layout,grid_sm<dim,T>,grid_key_dx<dim>>::get_lin(data_,g1,0))> inline const r_type get(size_t lin_id) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(lin_id);
#endif
        return mem_get<p,layout_base<T>,decltype(this->data_),decltype(this->g1),grid_key_dx<dim>>::get_lin(data_,g1,lin_id);
    }


    inline encapc<dim,T,layout> get_o(const grid_key_dx<dim> & v1)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
        return mem_geto<dim,T,layout_base<T>,decltype(this->data_),decltype(this->g1),decltype(v1)>::get(data_,g1,v1);
    }

    inline const encapc<dim,T,layout> get_o(const grid_key_dx<dim> & v1) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
        return mem_geto<dim,T,layout_base<T>,decltype(this->data_),decltype(this->g1),decltype(v1)>::get(const_cast<decltype(this->data_) &>(data_),g1,v1);
    }

    inline encapc<dim,T,layout> get_o(size_t v1)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
        return mem_geto<dim,T,layout_base<T>,decltype(this->data_),decltype(this->g1),decltype(v1)>::get_lin(data_,v1);
    }

    inline const encapc<dim,T,layout> get_o(size_t v1) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(v1);
#endif
        return mem_geto<dim,T,layout_base<T>,decltype(this->data_),decltype(this->g1),decltype(v1)>::get_lin(const_cast<decltype(this->data_) &>(data_),v1);
    }

    void fill(unsigned char fl)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        memset(getPointer(),fl,size() * sizeof(T));
    }

    void resize(const size_t (& sz)[dim])
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        grid_base_impl<dim,T,S,layout,layout_base> grid_new(sz);

        if (isExternal == true)
        {
/*          grid_new.setMemory(static_cast<S&>(data_.getMemory()));

            // Create an empty memory allocator for the actual structure

            setMemory();*/
            mem_setext<decltype(grid_new),S,layout_base<T>,decltype(data_)>::set(grid_new,*this,this->data_);
        }
        else
            grid_new.setMemory();


        // We know that, if it is 1D we can safely copy the memory
//      if (dim == 1)
//      {
//          //! 1-D copy (This case is simple we use raw memory copy because is the fastest option)
//          grid_new.data_.mem->copy(*data_.mem);
//      }
//      else
//      {
        // It should be better to separate between fast and slow cases


            size_t sz_c[dim];
            for (size_t i = 0 ; i < dim ; i++)
                sz_c[i] = (g1.size(i) < sz[i])?g1.size(i):sz[i];

            grid_sm<dim,void> g1_c(sz_c);

            grid_key_dx_iterator<dim> it(g1_c);

            while(it.isNext())
            {
                // get the grid key
                grid_key_dx<dim> key = it.get();

                // create a copy element

                grid_new.get_o(key) = this->get_o(key);

                ++it;
            }
//      }

        // copy grid_new to the base

        this->swap(grid_new);
    }

    void remove(size_t key)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        if (dim != 1)
        {
#ifdef SE_CLASS1
            std::cerr << "Error: " << __FILE__ << " " << __LINE__ << " remove work only on dimension == 1 " << "\n";
#endif
            return;
        }

        // It is safe to do a memory copy

        data_.move(&this->template get<0>());
    }


    void swap(grid_base_impl<dim,T,S,layout,layout_base> & grid)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif

        mem_swap<T,layout_base<T>,decltype(data_),decltype(grid)>::swap(data_,grid.data_);

        // exchange the grid info
        g1.swap(grid.g1);

        // exchange the init status
        bool exg = is_mem_init;
        is_mem_init = grid.is_mem_init;
        grid.is_mem_init = exg;

        // exchange the is external status
        exg = isExternal;
        isExternal = grid.isExternal;
        grid.isExternal = exg;
    }

    void swap(grid_base_impl<dim,T,S,layout,layout_base> && grid)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        swap(grid);
    }

    template<typename Memory> inline void set(grid_key_dx<dim> dx, const encapc<1,T,Memory> & obj)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(dx);
#endif

        // create the object to copy the properties
        copy_cpu_encap<dim,grid_base_impl<dim,T,S,layout,layout_base>,layout> cp(dx,*this,obj);

        // copy each property
        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);
    }

    inline void set(grid_key_dx<dim> dx, const T & obj)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(dx);
#endif

        this->get_o(dx) = obj;
    }


    inline void set(const grid_key_dx<dim> & key1,
                    const grid_base_impl<dim,T,S,layout,layout_base> & g,
                    const grid_key_dx<dim> & key2)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(key1);
        check_bound(g,key2);
#endif

        this->get_o(key1) = g.get_o(key2);
    }

    inline void set(const size_t key1,
                    const grid_base_impl<dim,T,S,layout,layout_base> & g,
                    const size_t key2)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(key1);
        check_bound(g,key2);
#endif

        this->get_o(key1) = g.get_o(key2);
    }

    template<typename Mem> inline void set(const grid_key_dx<dim> & key1,const grid_base_impl<dim,T,Mem,layout,layout_base> & g, const grid_key_dx<dim> & key2)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
#ifdef SE_CLASS1
        check_init();
        check_bound(key1);
        check_bound(g,key2);
#endif

        this->get_o(key1) = g.get_o(key2);
    }

    inline size_t size() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return g1.size();
    }

    inline grid_key_dx_iterator_sub<dim> getSubIterator(grid_key_dx<dim> & start, grid_key_dx<dim> & stop) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return g1.getSubIterator(start,stop);
    }

    inline grid_key_dx_iterator_sub<dim> getSubIterator(size_t m)
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return grid_key_dx_iterator_sub<dim>(g1,m);
    }

    inline grid_key_dx_iterator<dim> getIterator() const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return grid_key_dx_iterator<dim>(g1);
    }

    template<unsigned int Np>
    inline grid_key_dx_iterator<dim,stencil_offset_compute<dim,Np>>
    getIteratorStencil(const grid_key_dx<dim> (& stencil_pnt)[Np]) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        return grid_key_dx_iterator<dim,stencil_offset_compute<dim,Np>>(g1,stencil_pnt);
    }

    inline grid_key_dx_iterator_sub<dim> getIterator(const grid_key_dx<dim> & start, const grid_key_dx<dim> & stop) const
    {
#ifdef SE_CLASS2
        check_valid(this,8);
#endif
        // get the starting point and the end point of the real domain

        return grid_key_dx_iterator_sub<dim>(g1,start,stop);
    }


    long int who()
    {
#ifdef SE_CLASS2
        return check_whoami(this,8);
#else
        return -1;
#endif
    }
};


#endif /* OPENFPM_DATA_SRC_GRID_GRID_BASE_IMPLEMENTATION_HPP_ */