type_traits.hpp

Go to the documentation of this file.

 
/*
 * This file is part of Algorithms library toolkit.
 * Copyright (C) 2017 Jan Travnicek (jan.travnicek@fit.cvut.cz)
 
 * Algorithms library toolkit is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 
 * Algorithms library toolkit is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 
 * You should have received a copy of the GNU General Public License
 * along with Algorithms library toolkit.  If not, see <http://www.gnu.org/licenses/>.
 */
 
#pragma once
 
#include <type_traits>
#include <utility>
#include <cstdlib>
 
namespace ext {
 
    template<class T>
    struct has_clone {
    private:
        template < class U >
        static std::true_type test ( U * data )
        requires ( std::is_pointer_v < decltype ( data->clone ( ) ) > );
        static std::false_type test ( ... );
    public:
        static const bool value = decltype ( has_clone::test ( std::declval < std::decay_t < T > * > ( ) ) )::value;
    };
 
 
    template < class F, class ... Ts, typename = decltype ( std::declval < F > ( ) ( std::declval < Ts > ( ) ... ) ) >
    std::true_type supports_test ( const F &, const Ts & ... );
 
    std::false_type supports_test ( ... );
 
    template < class > struct supports;
 
    template < class F, class ... Ts > struct supports < F ( Ts ... ) > : decltype ( supports_test ( std::declval < F > ( ), std::declval < Ts > ( ) ... ) ) { };
 
// ----------------------------------------------------------------------------------------------------
 
    template < typename T, typename ... Ts >
    using is_in = std::integral_constant < bool, ( std::is_same < T, Ts >::value || ... ) >;
 
// ----------------------------------------------------------------------------------------------------
 
    template < typename T, typename ... Ts >
    struct index_in;
 
    template < typename T >
    struct index_in < T > : std::integral_constant < size_t, 0 > { };
 
    template < typename T, typename U, typename ... Ts >
    struct index_in < T, U, Ts ... > : std::integral_constant < size_t, index_in < T, Ts ... >::value + 1 > { };
 
    template < typename T, typename ... Ts >
    struct index_in < T, T, Ts ... > : std::integral_constant < size_t, 0 > { };
 
// ----------------------------------------------------------------------------------------------------
 
    template < bool value>
    using boolean = typename std::conditional < value, std::true_type, std::false_type >::type;
 
    template < class ... Ts >
    struct casional;
 
    template < >
    struct casional < > {
        typedef void type;
    };
 
    template < class T >
    struct casional < T > {
        typedef T type;
    };
 
    template < class R, class ... Ts >
    struct casional < std::true_type, R, Ts ... > : public casional < R > {
    };
 
    template < class R, class ... Ts >
    struct casional < std::false_type, R, Ts ... > : public casional < Ts ... > {
    };
 
    // Helper which adds a reference to a type when given a reference_wrapper
    template < typename T >
    struct strip_reference_wrapper {
        typedef T type;
    };
 
    template < typename T >
    struct strip_reference_wrapper < std::reference_wrapper < T > > {
        typedef T & type;
    };
 
} /* namespace ext */