common.hpp

#ifndef COMMON_HPP
#define COMMON_HPP
 
#include <type_traits>
#include <random>
#include "memory/memory.hpp"
#include "util/for_each_ref.hpp"
#include "util/variadic_to_vmpl.hpp"
 
constexpr int RUN_ON_DEVICE = 1024;
 
#define GCC_VERSION (__GNUC__ * 10000 \
                               + __GNUC_MINOR__ * 100 \
                               + __GNUC_PATCHLEVEL__)
 
 
template<unsigned int N,typename T>
struct static_array
{
    T sa[N];
};
 
namespace std
{
    // We need the definition of std::to_string that work on string
    inline static std::string to_string(std::string s)
    {
        return s;
    }
}
 
 
namespace openfpm
{
        template <class T>
        constexpr typename std::add_const<T>::type & as_const(T& t) noexcept
        {
                return t;
        }
 
        template <typename> struct Debug;
}
 
 // {3,3,3,3,3,3,.....}
 template<size_t index, size_t N> struct Fill_three {
    enum { value = 3 };
 };
 
 template<size_t index, size_t N> struct Fill_zero {
    enum { value = 0 };
 };
 
 template<size_t index, size_t N> struct Fill_two {
    enum { value = 2 };
 };
 
 template<size_t index, size_t N> struct Fill_one {
    enum { value = 1 };
 };
 
template<typename> struct Void
{
    typedef void type;
};
 
template<typename T, typename Sfinae = void>
struct has_attributes: std::false_type {};
 
 
template<typename T>
struct has_attributes<T, typename Void<decltype( T::attributes::name[0] )>::type> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct has_typedef_type: std::false_type {};
 
template<typename T>
struct has_typedef_type<T, typename Void< typename T::type>::type> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct has_vector_kernel: std::false_type {};
 
template<typename T>
struct has_vector_kernel<T, typename Void< typename T::vector_kernel >::type> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct has_set_d: std::false_type {};
 
template<typename T>
struct has_set_d<T, typename Void<decltype( std::declval<T>().set_d(0,0) )>::type> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct has_data: std::false_type {};
 
template<typename T>
struct has_data<T, typename Void<decltype( T::data )>::type> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct has_posMask: std::false_type {};
 
template<typename T>
struct has_posMask<T, typename Void<decltype( T::stag_mask )>::type> : std::true_type
{};
 
 
template<bool cond, typename T>
struct is_typedef_and_data_same
{
    enum
    {
        value = std::is_same<decltype(std::declval<T>().data),typename T::type>::value
    };
};
 
 
template<typename T>
struct is_typedef_and_data_same<false,T>
{
    enum
    {
        value = false
    };
};
 
 
template<typename T, typename Sfinae = void>
struct has_noPointers: std::false_type {};
 
 
template<typename T>
struct has_noPointers<T, typename Void<decltype( T::noPointers() )>::type> : std::true_type
{};
 
template<typename ObjType, typename Sfinae = void>
struct has_pack: std::false_type {};
 
template<typename ObjType>
struct has_pack<ObjType, typename Void<decltype( ObjType::pack() )>::type> : std::true_type
{};
 
template<typename ObjType, typename Sfinae = void>
struct has_toKernel: std::false_type {};
 
template<typename ObjType>
struct has_toKernel<ObjType, typename Void<decltype( std::declval<ObjType>().toKernel() )>::type> : std::true_type
{};
 
template<typename ObjType, typename Sfinae = void>
struct has_packRequest: std::false_type {};
 
template<typename ObjType>
struct has_packRequest<ObjType, typename Void<decltype( ObjType::packRequest() )>::type> : std::true_type
{};
 
 
template<typename ObjType, typename Sfinae = void>
struct has_packMem: std::false_type {};
 
template<typename ObjType>
struct has_packMem<ObjType, typename Void<decltype( ObjType::packMem() )>::type> : std::true_type
{};
 
template<typename T, bool = is_typedef_and_data_same<has_typedef_type<T>::value && has_data<T>::value,T>::value>
struct is_openfpm_native : std::false_type
{};
 
 
template<typename T>
struct is_openfpm_native<T,true> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct has_value_type_ofp: std::false_type {};
 
template<typename T>
struct has_value_type_ofp<T, typename Void< typename T::value_type>::type> : std::true_type
{};
 
 
template<size_t index, size_t N> struct MetaFunc {
   enum { value = index + N };
};
 
 
template<size_t index, size_t N> struct MetaFuncOrd {
   enum { value = index };
};
 
 
template<typename ObjType, typename Sfinae = void>
struct isDynStruct: std::false_type
{
    constexpr static bool value()
    {
        return false;
    }
};
 
template<typename ObjType>
struct isDynStruct<ObjType, typename Void<decltype( ObjType::isCompressed() )>::type> : std::true_type
{
    constexpr static bool value()
    {
        return ObjType::isCompressed();
    }
};
 
template<typename T, typename Sfinae = void>
struct is_Box: std::false_type {};
 
 
template<typename T>
struct is_Box<T, typename Void< typename T::yes_is_box>::type> : std::true_type
{};
 
template<typename T, typename Sfinae = void>
struct is_Point: std::false_type {};
 
 
template<typename T>
struct is_Point<T, typename Void< typename T::yes_is_point>::type> : std::true_type
{};
 
#endif