core_traits.h

Go to the documentation of this file.

 
 
#ifndef THEORETICA_CORE_TRAITS_H
#define THEORETICA_CORE_TRAITS_H
 
#include <type_traits>
#include <tuple>
#include "constants.h"
 
 
namespace theoretica {
 
 
    // Implement a simple void_t trait in C++14.
    namespace _internal {
        template<typename ...Args>
        struct make_void { typedef void type; };
        template<typename ...Args>
        using void_t = typename make_void<Args...>::type;
    }
 
 
    template<typename Type>
    struct is_real_type : std::is_floating_point<Type> {};
 
    template<>
    struct is_real_type<real> : std::true_type {};
 
 
    template<typename Structure, typename = _internal::void_t<>>
    struct is_orderable : std::false_type{};
 
    // The @internal directive is used to avoid documenting this overload
    template<typename Structure>
    struct is_orderable
    <Structure, _internal::void_t<
        decltype(std::declval<Structure>() < std::declval<Structure>())>
    > : std::true_type{};
 
 
    template<typename Structure, typename = _internal::void_t<>>
    struct is_indexable : std::false_type{};
 
    template<typename Structure>
    struct is_indexable
    <Structure, _internal::void_t<
        decltype(std::declval<Structure>()[0])>
    > : std::true_type{};
 
 
    template<typename Structure, typename = _internal::void_t<>>
    struct is_iterable : std::false_type{};
 
    template<typename Structure>
    struct is_iterable
    <Structure, _internal::void_t<
        decltype(std::declval<Structure>().begin())>
    > : std::true_type{};
 
 
    template<typename Structure, typename = _internal::void_t<>>
    struct is_vector : std::false_type{};
 
    template<typename Structure>
    struct is_vector
    <Structure, _internal::void_t<
        decltype(std::declval<Structure>()[0]),
        decltype(std::declval<Structure>().size())>
    > : std::true_type{};
 
 
    template<typename Structure, typename = _internal::void_t<>>
    struct is_matrix : std::false_type{};
 
    template<typename Structure>
    struct is_matrix
    <Structure, _internal::void_t<
        decltype(std::declval<Structure>()(0, 0)),
        decltype(std::declval<Structure>().rows()),
        decltype(std::declval<Structure>().cols())>
    > : std::true_type{};
 
 
    namespace _internal {
 
        template<typename Structure, typename = void>
        struct vector_element_or_void {
            using type = void;
        };
 
        template<typename Structure>
        struct vector_element_or_void
            <Structure, _internal::void_t<decltype(std::declval<Structure&>()[0])>> {
            using type = std::remove_reference_t<decltype(std::declval<Structure>()[0])>;
        };
    }
 
    template<typename Structure>
    using vector_element_or_void_t =
        typename _internal::vector_element_or_void<Structure>::type;
 
 
    template<typename Structure>
    using vector_element_t =
        std::remove_reference_t<decltype(std::declval<Structure>()[0])>;
 
 
    template<typename Structure>
    using matrix_element_t =
        std::remove_reference_t<decltype(std::declval<Structure>()(0, 0))>;
 
 
    template<typename Structure, typename Type>
    struct has_type_elements
    : std::is_same<vector_element_t<Structure>, Type> {};
 
 
    template<typename Structure>
    using has_real_elements = is_real_type<vector_element_t<Structure>>;
 
 
    template<typename Structure, typename T = bool>
    using enable_matrix = std::enable_if_t<is_matrix<Structure>::value, T>;
 
 
    template<typename Structure, typename T = bool>
    using enable_vector = std::enable_if_t<is_vector<Structure>::value, T>;
 
 
    template<typename Function>
    struct extract_func_args;
 
    template<typename Function, typename... Args>
    struct extract_func_args<Function(Args...)> {
        using type = std::tuple<Args...>;
    };
 
 
    namespace _internal {
 
        // Helper structure for is_real_func and related traits
        template<typename Function, typename T, typename = void>
        struct return_type_or_void {
            using type = void;
        };
 
        // Helper structure for is_real_func and related traits
        template<typename Function, typename T>
        struct return_type_or_void
            <Function, T, _internal::void_t<decltype(std::declval<Function>()(T(0.0)))>> {
            using type = decltype(std::declval<Function>()(T(0.0)));
        };
 
 
        // Helper structure for extracting information from Callables
        template<class T>
        struct func_helper : public func_helper<decltype(&T::operator())> {};
 
        template<class ReturnType, class... Args>
        struct func_helper<ReturnType(Args...)> {
 
            using return_type = ReturnType;
            using args_type = std::tuple<Args...>;
        };
 
        template<class ReturnType, class... Args>
        struct func_helper<ReturnType(*)(Args...)> {
 
            using return_type = ReturnType;
            using args_type = std::tuple<Args...>;
        };
 
        template<class Class, class ReturnType, class... Args>
        struct func_helper<ReturnType(Class::*)(Args...) const> {
 
            using return_type = ReturnType;
            using args_type = std::tuple<Args...>;
        };
    }
 
 
    template<typename Function>
    using is_real_func =
    std::conditional_t<
        is_real_type <
            typename _internal::return_type_or_void<Function, real>::type
        >::value,
        std::true_type, std::false_type
    >;
 
 
    template<typename Function, typename T = bool>
    using enable_real_func =
        typename std::enable_if_t<is_real_func<Function>::value, T>;
 
 
    template<typename Function>
    using return_type_t = typename _internal::func_helper<Function>::return_type;
 
}
 
#endif