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"

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::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 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
    {
        // This is the type of the object we have to copy
        typedef typename boost::fusion::result_of::at_c<typename e_src::type,T::value>::type copy_type;

        // Remove the reference from the type to copy
        typedef typename boost::remove_reference<copy_type>::type copy_rtype;

        meta_copy<copy_rtype> cp(src.template get<T::value>(),dst.template get<T::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
    {
        // This is the type of the object we have to copy
        typedef typename boost::fusion::result_of::at_c<typename e_src::type,T::value>::type copy_type;

        // Remove the reference from the type to copy
        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_cpu_prop
{
    typedef typename mem::vtype vtype;
    typedef typename boost::fusion::result_of::at< vtype,boost::mpl::int_<p> >::type type;
};

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 Mem>
class encapc
{
public:
    typedef typename T::type type;

private:

    type & data_c;

public:

    typedef int yes_i_am_encap;

    typedef T T_type;

    static const int max_prop = T::max_prop;

    // constructor require a key and a memory data
    inline encapc(type & data_c)
    :data_c(data_c)
    {}

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

    template <unsigned int p> inline typename type_cpu_prop<p,Mem>::type get()
    {
#ifdef SE_CLASS2
        check_valid(&boost::fusion::at_c<p>(data_c),sizeof(typename type_cpu_prop<p,Mem>::type));
#endif
        return boost::fusion::at_c<p>(data_c);
    }

    template <unsigned int p> inline const typename type_cpu_prop<p,Mem>::type get() const
    {
#ifdef SE_CLASS2
        check_valid(&boost::fusion::at_c<p>(data_c),sizeof(typename type_cpu_prop<p,Mem>::type));
#endif
        return boost::fusion::at_c<p>(data_c);
    }

    // access the data
    template <unsigned int p> inline void set(typename type_cpu_prop<p,Mem>::type & ele)
    {
#ifdef SE_CLASS2
            check_valid(&boost::fusion::at_c<p>(data_c),sizeof(typename type_cpu_prop<p,T>::type));
#endif
            return boost::fusion::at_c<p>(data_c) = ele;
    }

    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()
    {}

    // access the data
    template <unsigned int p> void get()
    {}

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

template<unsigned int dim,typename T,typename Mem>
class encapg
{
    // constructor require a key
    Mem & data;
    size_t k;

public:

    typedef int yes_i_am_encap;

    typedef T T_type;

    // constructor require a key and a memory data
    encapg(Mem & data, size_t k)
    :data(data),k(k)
    {}

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

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

#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_ */