type_traits.hh

Go to the documentation of this file.

 
#ifndef UTOPIA_CORE_TYPETRAITS_HH
#define UTOPIA_CORE_TYPETRAITS_HH
 
#include <cmath>
#include <iomanip>
#include <iostream> // needed for operator<< overloads
#include <limits>
#include <type_traits>
#include <vector>
#include <tuple>
#include <utility>
#include <string>
#include <sstream> // needed for making string representations of arb. types
#include <string_view>
 
#include <boost/hana/ext/std/tuple.hpp>
#include <boost/hana/for_each.hpp>
#include <boost/hana/tuple.hpp>
 
#include <armadillo>
 
/*
 * Implementation logic: prototype with two template parameters, <T, std::void_t<>> 
 *         holding boolean member that is false, and 
 *         specialization with <T, std::void_t<some, conditions, defining, concept>> 
 *         holding booleaen member which is true.
*/
 
namespace Utopia
{
namespace Utils
{
template < typename T, typename U = std::void_t<> >
struct remove_pointer
{
    using type = T;
};
 
template < typename T >
struct remove_pointer<
    T,
    std::enable_if_t< std::is_pointer_v< T >, std::void_t<> > >
{
    using type = typename remove_pointer< std::remove_pointer_t< T > >::type;
};
 
template < typename T >
using remove_pointer_t = typename remove_pointer< T >::type;
 
template < typename T >
struct remove_pointer< T,
                       std::enable_if_t< std::is_array_v< T >, std::void_t<> > >
{
    using type =
        typename remove_pointer< std::remove_all_extents_t< T > >::type;
};
 
template < typename T >
struct remove_qualifier
{
    using type =
        std::remove_cv_t< remove_pointer_t< std::remove_reference_t< T > > >;
};
 
template < typename T >
using remove_qualifier_t = typename remove_qualifier< T >::type;
 
template < typename T >
struct is_string : public std::false_type
{
};
 
template < typename... Ts >
struct is_string< std::basic_string< Ts... > > : public std::true_type
{
};
 
template< typename... Ts> 
struct is_string<std::basic_string_view<Ts...>> : public std::true_type{};
 
template <>
struct is_string< const char* > : public std::true_type
{
};
 
template <>
struct is_string< char* > : public std::true_type
{
};
 
template < typename T >
constexpr inline bool is_string_v = is_string< T >::value;
 
template < typename T, typename = std::void_t<> >
struct is_iterable : std::false_type
{
};
 
template < typename T >
struct is_iterable< T, std::void_t< typename T::iterator > > : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_iterable_v = is_iterable< T >::value;
 
template < class T, class U = std::void_t<> >
struct is_container : public std::false_type
{
};
 
template < typename T >
inline constexpr bool is_container_v = is_container< T >::value;
 
template < typename T >
struct is_container< T,
                     std::void_t< std::enable_if_t<
                         is_iterable_v< remove_qualifier_t< T > > and
                             not is_string_v< remove_qualifier_t< T > >,
                         int > > > : public std::true_type
{
}; // FIXME: there is something inconsistent in the **usage** of this
   // metafunction that requires the use of `remove_qualifier` in order to keep
   // the tests functional. The cause is not the metafunction itself, but its
   // use. Fix this when possible at some point.
 
template < typename T, typename = std::void_t<> >
struct is_associative_container : std::false_type
{
};
 
template < typename T >
struct is_associative_container<
    T,
    std::void_t< std::enable_if_t< is_container_v< T >, int >,
                 typename T::key_type,
                 typename T::key_compare > > : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_associative_container_v =
    is_associative_container< T >::value;
 
template < typename T, typename = std::void_t<> >
struct is_unordered_associative_container : std::false_type
{
};
 
template < typename T >
struct is_unordered_associative_container<
    T,
    std::void_t< std::enable_if_t< is_container_v< T >, int >,
                 typename T::key_type,
                 typename T::value_type,
                 typename T::hasher > > : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_unordered_associative_container_v =
    is_unordered_associative_container< T >::value;
 
template < typename T, typename = std::void_t<> >
struct is_linear_container : std::false_type
{
};
 
template < typename T >
struct is_linear_container<
    T,
    std::void_t<
        std::enable_if_t< not is_associative_container_v< T > and
                              not is_unordered_associative_container_v< T > and
                              is_container_v< T >,
                          int > > > : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_linear_container_v = is_linear_container< T >::value;
 
template < typename T, typename = std::void_t<> >
struct is_random_access_container : std::false_type
{
};
 
template < typename T >
struct is_random_access_container<
    T,
    std::void_t< std::enable_if_t<
        is_linear_container_v< T > and
        std::is_convertible_v< typename std::iterator_traits<
                                   typename T::iterator >::iterator_category,
                               std::random_access_iterator_tag > > > >
    : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_random_access_container_v =
    is_random_access_container< T >::value;
 
template < typename T, typename U = std::void_t<> >
struct has_vertex_descriptor : std::false_type
{
};
 
template < typename T >
struct has_vertex_descriptor< T, std::void_t< typename T::vertex_descriptor > >
    : std::true_type
{
};
 
template < typename T >
inline constexpr bool has_vertex_descriptor_v =
    has_vertex_descriptor< T >::value;
 
template < typename T, typename U = std::void_t<> >
struct has_edge_descriptor : std::false_type
{
};
 
template < typename T >
struct has_edge_descriptor< T, std::void_t< typename T::edge_descriptor > >
    : std::true_type
{
};
 
template < typename T >
inline constexpr bool has_edge_descriptor_v = has_edge_descriptor< T >::value;
 
template < typename T, typename U = std::void_t<> >
struct is_graph : std::false_type
{
};
 
template < typename T >
struct is_graph<
    T,
    std::void_t< std::enable_if_t< has_edge_descriptor_v< T > and
                                       has_vertex_descriptor_v< T >,
                                   int > > > : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_graph_v = is_graph< T >::value;
 
template < typename T >
struct get_size
    : std::integral_constant<
          std::size_t,
          std::numeric_limits< std::size_t >::max() > // scalar have an
                                                      // unrealistic size ->
                                                      // distinguish from size 1
                                                      // array/tuple...
{
};
 
template < typename T, std::size_t N >
struct get_size< std::array< T, N > > : std::integral_constant< std::size_t, N >
{
};
 
template < typename... Ts >
struct get_size< std::tuple< Ts... > >
    : std::integral_constant< std::size_t, sizeof...(Ts) >
{
};
 
template < typename A, typename B >
struct get_size< std::pair< A, B > > : std::integral_constant< std::size_t, 2 >
{
};
 
template < typename... Ts >
struct get_size< boost::hana::tuple< Ts... > >
    : std::integral_constant< std::size_t, sizeof...(Ts) >
{
};
 
template < arma::uword N, arma::uword M >
struct get_size< arma::mat::fixed< N, M > >
    : std::integral_constant< std::size_t, N * M >
{
};
 
template < arma::uword N, arma::uword M >
struct get_size< arma::imat::fixed< N, M > >
    : std::integral_constant< std::size_t, N * M >
{
};
 
template < arma::uword N, arma::uword M >
struct get_size< arma::s32_mat::fixed< N, M > >
    : std::integral_constant< std::size_t, N * M >
{
};
 
template < arma::uword N, arma::uword M >
struct get_size< arma::u32_mat::fixed< N, M > >
    : std::integral_constant< std::size_t, N * M >
{
};
 
template < arma::uword N, arma::uword M >
struct get_size< arma::umat::fixed< N, M > >
    : std::integral_constant< std::size_t, N * M >
{
};
 
template < arma::uword N, arma::uword M >
struct get_size< arma::fmat::fixed< N, M > >
    : std::integral_constant< std::size_t, N * M >
{
};
 
template < arma::uword N >
struct get_size< arma::vec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::ivec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::s32_vec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::uvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::u32_vec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::fvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::rowvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::irowvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::s32_rowvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::u32_rowvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::urowvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
template < arma::uword N >
struct get_size< arma::frowvec::fixed< N > >
    : std::integral_constant< std::size_t, N >
{
};
 
// Shorthand for get_size<T>::value
template < typename T >
inline constexpr std::size_t get_size_v = get_size< T >::value;
 
template < typename T, typename U = std::void_t<> >
struct is_array_like : std::false_type
{
};
 
template < typename T >
struct is_array_like<
    T,
    std::void_t<
        std::enable_if_t< get_size_v< T > !=
                              std::numeric_limits< std::size_t >::max() and
                          is_container_v< T > >,
        int > > : std::true_type
{
};
 
template < typename T >
inline constexpr bool is_array_like_v = is_array_like< T >::value;
 
template < typename T, std::size_t s >
struct has_static_size_base : std::true_type
{
};
 
template < typename T >
struct has_static_size_base< T, std::numeric_limits< std::size_t >::max() >
    : std::false_type
{
};
 
template < typename T >
struct has_static_size : has_static_size_base< T, get_size_v< T > >
{
};
 
template < typename T >
inline constexpr bool has_static_size_v = has_static_size< T >::value;
 
template < typename T, typename X = std::void_t<> >
class is_callable
{
  public:
    static constexpr bool value = false;
};
 
template < typename T >
class is_callable<
    T,
    std::void_t< std::enable_if_t< std::is_class_v< std::decay_t< T > >, T > > >
{
 
    struct Fallback
    {
        void
        operator()();
    };
 
    struct Derived
        : T
        , Fallback
    {
    };
 
    template < typename U, U >
    struct Check;
 
    typedef char True[1];  // typedef for an array of size one.
    typedef char False[2]; // typedef for an array of size two.
 
    template < typename S >
    static constexpr True&
    f(...);
 
    template < typename S >
    static constexpr False&
    f(Check< void (Fallback::*)(), &S::operator() >*);
 
  public:
    static constexpr bool value = (sizeof(f< Derived >(nullptr)) == 1);
};
 
template < typename T >
constexpr bool is_callable_v = is_callable< T >::value;
 
struct Nothing
{
};
 
}
}
 
#endif