Encap.hpp

/*
 * Encap.hpp
 *
 *  Created on: Feb 2, 2015
 *      Author: i-bird
 */

#ifndef ENCAP_HPP_
#define ENCAP_HPP_

#include "util/for_each_ref.hpp"
#include "util/copy_compare/meta_copy.hpp"
#include "boost/mpl/range_c.hpp"
#include <boost/fusion/container/vector.hpp>
#ifdef SE_CLASS2
#include "Memleak_check.hpp"
#endif
#include "util/se_util.hpp"
#include "util/copy_compare/copy_fusion_vector.hpp"
#include "util/copy_compare/compare_fusion_vector.hpp"
#include "memory_ly/memory_conf.hpp"

template<typename e_src, typename e_dst>
struct copy_cpu_encap_encap
{
    const e_src & src;
    e_dst & dst;


    inline copy_cpu_encap_encap(const e_src & src, e_dst & dst)
    :src(src),dst(dst)
    {
#ifdef SE_CLASS1
        // e_src and e_dst must have the same number of properties

        if (e_src::T_type::max_prop != e_dst::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };


#ifdef SE_CLASS1

    inline copy_cpu_encap_encap(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif

    template<typename T>
    inline void operator()(T& t) const
    {
        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(dst.template get<T::value>())>::type copy_rtype;

        meta_copy<copy_rtype>::meta_copy_(src.template get<T::value>(),dst.template get<T::value>());
    }
};


template<template<typename,typename> class op,typename e_src, typename e_dst, int ... prp>
struct copy_cpu_encap_encap_op_prp
{
    const e_src & src;
    e_dst & dst;


    inline copy_cpu_encap_encap_op_prp(const e_src & src, e_dst & dst)
    :src(src),dst(dst)
    {
#ifdef SE_CLASS1
        // e_src and e_dst must have the same number of properties

        if (e_src::T_type::max_prop != e_dst::T_type::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };


#ifdef SE_CLASS1

    inline copy_cpu_encap_encap_op_prp(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif

    template<typename T>
    inline void operator()(T& t) const
    {
        // Convert variadic to boost::vector
        typedef typename boost::mpl::vector_c<unsigned int,prp...> prpv;

        // element id to copy applying an operation
        typedef typename boost::mpl::at<prpv,T>::type ele_cop;

        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<decltype(src.template get< ele_cop::value >())>::type copy_rtype;

        meta_copy_op<op,copy_rtype>::meta_copy_op_(src.template get< ele_cop::value >(),dst.template get< ele_cop::value >());
    }
};




template<typename e_src, typename e_dst>
struct compare_cpu_encap_encap
{
    const e_src & src;
    const e_dst & dst;


    inline compare_cpu_encap_encap(const e_src & src, const e_dst & dst)
    :src(src),dst(dst)
    {
#ifdef SE_CLASS1
        // e_src and e_dst must have the same number of properties

        if (e_src::max_prop != e_dst::max_prop)
            std::cerr << "Error " << __FILE__ << ":" << __LINE__ << " the number of properties between src and dst must match";
#endif
    };


#ifdef SE_CLASS1

    inline compare_cpu_encap_encap(const e_src && src, const e_dst && dst)
    :src(src),dst(dst)
    {std::cerr << "Error: " <<__FILE__ << ":" << __LINE__ << " Passing a temporal object";};
#endif

    template<typename T>
    inline void operator()(T& t) const
    {
        typedef typename boost::fusion::result_of::at_c<typename e_src::type,T::value>::type copy_type;

        typedef typename boost::remove_reference<copy_type>::type copy_rtype;

        meta_compare<copy_rtype> cp(src.template get<T::value>(),dst.template get<T::value>());
    }
};

template<unsigned int p,typename Mem>
struct type_gpu_prop
{
    typedef Mem vtype;
    typedef typename boost::fusion::result_of::at< vtype,boost::mpl::int_<p> >::type rtype;
    typedef typename boost::remove_reference<rtype>::type mtype;
    typedef typename mtype::type type;
};

template<unsigned int dim,typename T,typename layout>
class encapc
{

};

template<unsigned int dim,typename T>
class encapc<dim,T,typename memory_traits_lin<T>::type >
{
public:

    typedef typename T::type type;

private:

    type & data_c;

    typedef typename memory_traits_lin<T>::type Mem;

public:

    typedef int yes_i_am_encap;

    typedef T T_type;

    static const int max_prop = T::max_prop;

    inline encapc(type & data_c)
    :data_c(data_c)
    {}

    inline type * operator&()
    {
        return &data_c;
    }

    template <unsigned int p, typename r_type=decltype(boost::fusion::at_c<p>(data_c))>
    inline r_type get()
    {
#ifdef SE_CLASS2
        check_valid(&boost::fusion::at_c<p>(data_c),sizeof(typename boost::mpl::at<type,boost::mpl::int_<p>>::type));
#endif
        return boost::fusion::at_c<p>(data_c);
    }

    template <unsigned int p, typename r_type=decltype(boost::fusion::at_c<p>(data_c))>
    inline const r_type get() const
    {
#ifdef SE_CLASS2
        check_valid(&boost::fusion::at_c<p>(data_c),sizeof(typename boost::mpl::at<type,boost::mpl::int_<p>>::type));
#endif
        return boost::fusion::at_c<p>(data_c);
    }

    template <unsigned int p> inline void set(decltype(boost::fusion::at_c<p>(data_c)) & ele)
    {
#ifdef SE_CLASS2
            check_valid(&boost::fusion::at_c<p>(data_c),sizeof(typename boost::mpl::at<type,boost::mpl::int_<p>>::type));
#endif
            return boost::fusion::at_c<p>(data_c) = ele;
    }

    template<unsigned int dim2> inline encapc<dim,T,Mem> & set(const encapc<dim2,T,Mem> & ec)
    {
        copy_cpu_encap_encap<encapc<dim2,T,Mem>,encapc<dim,T,Mem>> cp(ec,*this);

        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);

        return *this;
    }

    inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem> & ec)
    {
        copy_cpu_encap_encap<encapc<dim,T,Mem>,encapc<dim,T,Mem>> cp(ec,*this);

        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);

        return *this;
    }

    inline encapc<dim,T,Mem> & operator=(const T & obj)
    {
        copy_fusion_vector<typename T::type> cp(obj.data,data_c);

        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);

        return *this;
    }

    inline bool operator==(const encapc<dim,T,Mem> & ec) const
    {
        compare_fusion_vector<typename T::type> cp(ec.data_c,data_c);

        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);

        return cp.result();
    }

    inline bool operator!=(const encapc<dim,T,Mem> & ec) const
    {
        return ! this->operator==(ec);
    }
};

template<unsigned int dim,typename Mem>
class encapc<dim,void,Mem>
{
public:

    // constructor require a key and a memory data
    encapc()
    {}

    template <unsigned int p> void get()
    {}

    template <unsigned int p, typename S> void set(S & ele)
    {}
};

template<unsigned int dim,typename T>
class encapc<dim,T,typename memory_traits_inte<T>::type>
{
    typedef typename memory_traits_inte<T>::type Mem;

    Mem & data;

    size_t k;

public:

    typedef typename T::type type;

    typedef int yes_i_am_encap;

    typedef T T_type;

    encapc(typename memory_traits_inte<T>::type & data, size_t k)
    :data(data),k(k)
    {}

    template <unsigned int p> typename type_gpu_prop<p,typename memory_traits_inte<T>::type>::type::reference get()
    {
        return boost::fusion::at_c<p>(data).mem_r->operator[](k);
    }

    template <unsigned int p> typename type_gpu_prop<p,typename memory_traits_inte<T>::type>::type::reference get() const
    {
        return boost::fusion::at_c<p>(data).mem_r->operator[](k);
    }

    inline encapc<dim,T,Mem> & operator=(const encapc<dim,T,Mem> & ec)
    {
        copy_cpu_encap_encap<encapc<dim,T,Mem>,encapc<dim,T,Mem>> cp(ec,*this);

        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);

        return *this;
    }

    inline encapc<dim,T,Mem> & operator=(const T & obj)
    {
        copy_fusion_vector_encap<typename T::type,decltype(*this)> cp(obj.data,*this);

        boost::mpl::for_each_ref< boost::mpl::range_c<int,0,T::max_prop> >(cp);

        return *this;
    }
};

#include "util/common.hpp"

template<typename T, typename Sfinae = void>
struct is_encap: std::false_type {};


template<typename T>
struct is_encap<T, typename Void< typename T::yes_i_am_encap>::type> : std::true_type
{};

#endif /* ENCAP_HPP_ */