common.hpp

#ifndef COMMON_HPP
#define COMMON_HPP

#include <type_traits>
#include <random>
#include "memory/memory.hpp"

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;
    }
}


// Compile time array functor needed to generate array at compile-time of type
// {0,0,0,0,0,.....}
// {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_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(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_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
{};

#endif