copy_general.hpp

/*
 * aggregate_copy.hpp
 *
 *  Created on: Oct 31, 2015
 *      Author: i-bird
 */

#ifndef OPENFPM_DATA_SRC_UTIL_COPY_GENERAL_HPP_
#define OPENFPM_DATA_SRC_UTIL_COPY_GENERAL_HPP_

#include "util/common.hpp"
#include "util/util_debug.hpp"
#include "copy_compare_aggregates.hpp"
#include "util/for_each_ref.hpp"
#include <boost/mpl/range_c.hpp>
#include <iostream>
#include "util/cuda_util.hpp"
#include "data_type/aggregate.hpp"

template<typename Tdst, typename Tsrc>
struct max_
{
    static inline void operation(Tdst & dst, const Tsrc & src)
    {
        dst = (src > dst)?src:dst;
    }
};

template<typename Tdst, typename Tsrc>
struct min_
{
    static inline void operation(Tdst & dst, const Tsrc & src)
    {
        dst = (src < dst)?src:dst;
    }
};

template<typename Tdst, typename Tsrc>
struct add_
{
    __device__ __host__ static inline void operation(Tdst & dst, const Tsrc & src)
    {
        dst += src;
    }
};

#if defined(__clang__) && !defined(CUDA_ON_CPU)

template<typename Tsrc>
__host__ Tsrc atomicAdd(Tsrc * ptr, Tsrc value)
{
    std::cout << __FILE__ << ":" << __LINE__ << "Error: atomicAdd is supported only in device code not host" << std::endl;
    return 0;
}
#endif

template<typename Tdst, typename Tsrc>
struct add_atomic_
{
    __device__ __host__ static inline void operation(Tdst & dst, const Tsrc & src)
    {
        atomicAdd(&dst,src);
    }
};

template<typename Tdst, typename Tsrc>
struct replace_
{
    static inline void operation(Tdst & dst, const Tsrc & src)
    {
        dst = src;
    }
};

template<typename Tdst, typename Tsrc>
struct merge_
{
    static inline void operation(Tdst & dst, const Tsrc & src)
    {
        dst.add(src);
    }
};

template<typename T, unsigned int agg=2 * is_aggregate<T>::value + std::is_copy_assignable<T>::value>
struct copy_general
{
    inline copy_general(const T & src, T & dst)
    {
#ifndef DISABLE_ALL_RTTI
        std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << "  " << demangle(typeid(T).name()) << " does not have an operator= and is not an aggregate or an openfpm native structure, copy is not possible" << "\n";
#endif
    }
};

template<typename T>
struct copy_general<T,1>
{
    __device__ __host__ inline copy_general(const T & src, T & dst)
    {
        dst = src;
    }
};

template<typename T>
struct copy_general<T,2>
{
    inline copy_general(const T & src, T & dst)
    {
        copy_aggregate<T> cp(src,dst);

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

template<typename T>
struct copy_general<T,3>
{
    inline copy_general(const T & src, T & dst)
    {
        dst = src;
    }
};


template<template<typename,typename> class op, typename T, unsigned int agg=2 * is_aggregate<T>::value + std::is_copy_assignable<T>::value>
struct copy_general_op
{
    inline copy_general_op(const T & src, T & dst)
    {
#ifndef DISABLE_ALL_RTTI
        std::cerr << "Error: " << __FILE__ << ":" << __LINE__ << "  " << demangle(typeid(T).name()) << " does not have an operator " << demangle(typeid(op<T,T>).name()) << "defined" << std::endl;
#endif
    }
};

template<template<typename,typename> class op,typename T>
struct copy_general_op<op,T,1>
{
    __device__ __host__ inline copy_general_op(const T & src, T & dst)
    {
        op<T,T>::operation(dst,src);
    }
};

template<template<typename,typename> class op, typename T>
struct copy_general_op<op,T,3>
{
    __device__ __host__ inline copy_general_op(const T & src, T & dst)
    {
        copy_aggregate_op<op,T> cp(src,dst);

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


#endif /* OPENFPM_DATA_SRC_UTIL_COPY_GENERAL_HPP_ */