concept.hpp

Go to the documentation of this file.

#pragma once
#include <type_traits>
 
#define DEFINE_HAS_TYPE(name)                   \
    namespace details {                         \
        template<class T>                       \
        struct has_type_##name                  \
        {                                       \
        private:                                \
            template<typename V> static void impl(typename V::name*); \
            template<typename V> static bool impl(...);                                \
        public:                                                                         \
            static constexpr bool value = std::is_same<void, decltype(impl<T>(0))>::value;  \
        };                                      \
                                                \
        template <class T, bool = false>        \
        struct get_type_##name                  \
        {                                       \
            using type = invalid_tag;           \
        };                                      \
        template <class T>                      \
        struct get_type_##name<T, true>         \
        {                                       \
            using type = typename T::name;      \
        };                                      \
                                                \
        template <bool b>                       \
        struct assert_has_type_##name           \
        {                                       \
            static_assert(b, "Type does not have member type "#name); \
        };                                      \
                                                \
        template<>                              \
        struct assert_has_type_##name<true> : std::true_type \
        {};                                     \
    }                                           \
    template <class T>                          \
    inline constexpr bool has_type_##name##_v = \
        details::has_type_##name<T>::value;     \
    template <class T>                          \
    inline constexpr bool assert_has_type_##name##_v = \
        details::assert_has_type_##name<has_type_##name##_v<T>>::value; \
    template <class T>                          \
    using get_type_##name##_t =                 \
        typename details::get_type_##name<T, has_type_##name##_v<T>>::type;
 
 
#define DEFINE_HAS_FUNC(name)                   \
    namespace details {                         \
        template<class T>                       \
        struct has_func_##name                  \
        {                                       \
        private:                                \
            template<typename V> static void impl(decltype(&V::name)); \
            template<typename V> static bool impl(...);                                \
        public:                                                                         \
            static constexpr bool value = std::is_same<void, decltype(impl<T>(0))>::value;  \
        };                                      \
                                                \
        template <bool b>                       \
        struct assert_has_func_##name           \
        {                                       \
            static_assert(b,                    \
                    "Type does not have public, non-overloaded " \
                    "member function "#name     \
                    );                          \
        };                                      \
                                                \
        template<>                              \
        struct assert_has_func_##name<true> : std::true_type \
        {};                                     \
    }                                           \
    template <class T>                          \
    inline constexpr bool has_func_##name##_v =   \
        details::has_func_##name<T>::value;     \
    template <class T>                          \
    inline constexpr bool assert_has_func_##name##_v = \
        details::assert_has_func_##name<has_func_##name##_v<T>>::value; \
 
namespace ppl {
namespace util {
 
struct invalid_tag
{
    invalid_tag() =delete;
    ~invalid_tag() =delete;
    invalid_tag(const invalid_tag&) =delete;
    invalid_tag& operator=(const invalid_tag&) =delete;
    invalid_tag(invalid_tag&&) =delete;
    invalid_tag& operator=(invalid_tag&&) =delete;
};
 
DEFINE_HAS_TYPE(value_t);
DEFINE_HAS_TYPE(pointer_t);
DEFINE_HAS_TYPE(const_pointer_t);
DEFINE_HAS_TYPE(id_t);
DEFINE_HAS_TYPE(index_t);
DEFINE_HAS_TYPE(vec_t);
DEFINE_HAS_TYPE(mat_t);
DEFINE_HAS_TYPE(shape_t);
DEFINE_HAS_TYPE(dist_value_t);
 
DEFINE_HAS_FUNC(size);
DEFINE_HAS_FUNC(id);
 
DEFINE_HAS_FUNC(get_variable);
DEFINE_HAS_FUNC(get_distribution);
 
} // namespace util
} // namespace ppl
 
#undef DEFINE_HAS_FUNC
#undef DEFINE_HAS_TYPE