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> {};
 
    // Type trait to check whether a type represents
    // a real number.
    template<>
    struct is_real_type<real> : std::true_type {};
 
 
    // Check whether a structure is orderable,
    // by checking that it has a comparison operator<().
    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{};
 
 
    // Check whether a structure is indexable by a single integer index,
    // by checking that it has the operator[](0).
    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{};
 
 
    // Check whether a structure is iterable,
    // by checking that it has a method begin().
    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{};
 
 
    // Check whether a structure is considerable a vector,
    // by checking that it has an operator[] and a size() method.
    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{};
 
 
#ifdef THEORETICA_HAS_CPP20
 
    // Concept of a vector-like structure,
    // which supports random access with operator[]
    // and has a size() method.
    template<typename Structure>
    concept VectorType = requires (Structure v) {
        v[0];
        v.size();
    };
 
#endif
 
 
    // Check whether a structure is considerable a matrix,
    // by checking that it has an operator(), a rows() method
    // and a cols() method.
    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{};
 
 
#ifdef THEORETICA_HAS_CPP20
 
    // Concept of a matrix-like structure,
    // which supports random access with operator(i, j)
    // and has rows() and cols() methods.
    template<typename Structure>
    concept MatrixType = requires (Structure v) {
        v(0, 0);
        v.rows();
        v.cols();
    };
 
#endif
 
 
    namespace _internal {
 
        // Helper structure for vector_element_t
        template<typename Structure, typename = void>
        struct vector_element_or_void {
            using type = void;
        };
 
        // Helper structure for vector_element_t
        
        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])>;
        };
    }
 
    // Extract the type of a vector (or any indexable container) from its operator[],
    // returning void if the type has no operator[].
    template<typename Structure>
    using vector_element_or_void_t =
        typename _internal::vector_element_or_void<Structure>::type;
 
 
    // Extract the type of a vector (or any indexable container) from its operator[].
    template<typename Structure>
    using vector_element_t =
        std::remove_reference_t<decltype(std::declval<Structure>()[0])>;
 
 
    // Extract the type of a matrix (or any doubly indexable container) from its operator().
    template<typename Structure>
    using matrix_element_t =
        std::remove_reference_t<decltype(std::declval<Structure>()(0, 0))>;
 
 
    // Type trait to check whether an indexable container
    // has elements of the given type.
    template<typename Structure, typename Type>
    struct has_type_elements
    : std::is_same<vector_element_t<Structure>, Type> {};
 
 
    // Type trait to check whether an indexable container
    // has real elements.
    template<typename Structure>
    using has_real_elements = is_real_type<vector_element_t<Structure>>;
 
 
    // Enable a function overload if the template typename
    // is a real number type. The std::enable_if structure is used,
    // with type T which defaults to bool.
    template<typename Type, typename T = bool>
    using enable_real = std::enable_if_t<is_real_type<Type>::value, T>;
 
 
    // Enable a function overload if the template typename
    // is considerable a matrix. The std::enable_if structure
    // is used, with type T which defaults to bool.
    template<typename Structure, typename T = bool>
    using enable_matrix = std::enable_if_t<is_matrix<Structure>::value, T>;
 
 
    // Enable a function overload if the template typename
    // is considerable a vector. The std::enable_if structure
    // is used, with type T which defaults to bool.
    template<typename Structure, typename T = bool>
    using enable_vector = std::enable_if_t<is_vector<Structure>::value, T>;
 
 
    // Disable a function overload if the template typename
    // is considerable a vector. The std::enable_if structure
    // is used, with type T which defaults to bool.
    template<typename Structure, typename T = bool>
    using disable_vector = std::enable_if_t<!is_vector<Structure>::value, T>;
 
 
    namespace _internal {
 
        // Helper structure to extract the first type of a variadic template
        template<typename Arg, typename ...Other>
        struct get_first {
            using type = Arg;
        };
 
        // 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 <typename T> struct func_helper;
 
        template <typename R, typename... Args>
        struct func_helper<R(Args...)> {
 
            // Return type of the function
            using return_type = R;
 
            // Tuple of argument types
            using args_tuple = std::tuple<Args...>;
 
            // Type of the first argument
            using first_arg_type = typename get_first<Args...>::type;
 
            // Arity of the function (number of arguments)
            static constexpr std::size_t arity = sizeof...(Args);
        };
 
        template <typename R, typename... Args>
        struct func_helper<R(*)(Args...)> : func_helper<R(Args...)> {};
 
        template <typename C, typename R, typename... Args>
        struct func_helper<R(C::*)(Args...) const> : func_helper<R(Args...)> {};
 
        template <typename T>
        struct func_helper : func_helper<decltype(&T::operator())> {};
 
    }
 
 
    // Type trait to check whether the given function takes
    // a real number as its first argument.
    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
    >;
 
 
    // Enable a certain function overload if the given type
    // is a function taking as first argument a real number
    template<typename Function, typename T = bool>
    using enable_real_func =
        typename std::enable_if_t<is_real_func<Function>::value, T>;
 
 
    // Extract the return type of a Callable object, such as a function
    // pointer or lambda function.
    template<typename Function>
    using return_type_t = typename _internal::func_helper<Function>::return_type;
 
    // Extract the type of the first argument of a Callable object, such as a function
    // pointer or lambda function.
    template<typename Function>
    using first_arg_t = typename _internal::func_helper<Function>::first_arg_type;
 
}
 
#endif