TemplateMetaProgramming.h

Go to the documentation of this file.

/*
 * This file is part of ArmarX.
 *
 * Copyright (C) 2011-2016, High Performance Humanoid Technologies (H2T), Karlsruhe Institute of Technology (KIT), all rights reserved.
 *
 * ArmarX is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License version 2 as
 * published by the Free Software Foundation.
 *
 * ArmarX 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 this program. If not, see <http://www.gnu.org/licenses/>.
 *
 * @package    ArmarXCore
 * @author     Raphael Grimm ( raphael dot grimm at kit dot edu)
 * @date       2016
 * @copyright  http://www.gnu.org/licenses/gpl-2.0.txt
 *             GNU General Public License
 */
#pragma once
 
#include <cstddef>
#include <tuple>
#include <type_traits>
 
namespace armarx::meta
{
    template <class T, class... Ts>
    struct is_in_types : std::true_type
    {
    };
 
    template <class T, class T0, class... Ts>
    struct is_in_types<T, T0, Ts...> :
        std::bool_constant<std::is_same_v<T, T0> && is_in_types<T, Ts...>::value>
    {
    };
    template <class T, class... Ts>
    static constexpr bool is_in_types_v = is_in_types<T, Ts...>::value;
 
    /// @brief Removes rvalue ref from a type
    template <class T>
    struct RemoveRvalueReference
    {
        using type = T;
    };
 
    template <class T>
    struct RemoveRvalueReference<T&&>
    {
        using type = T;
    };
    template <class T>
    using RemoveRvalueReferenceT = typename RemoveRvalueReference<T>::type;
 
    /// @brief Helper for sfinae (is added in c++17)
    template <class...>
    using void_t = void;
 
    /**
     * @brief Traits about templates taking only types as parameters.
     *
     * \ingroup core-utility
     */
    struct TypeTemplateTraits
    {
        /**
         * @brief Whether a type T is the instance of a given template Template. (this is the case for false)
         */
        template <template <class...> class Template, class T>
        struct IsInstanceOf : std::false_type
        {
        };
 
        /**
         * @brief Whether a type T is the instance of a given template Template. (this is the case for true)
         */
        template <template <class...> class Template, class... Params>
        struct IsInstanceOf<Template, Template<Params...>> : std::true_type
        {
        };
 
        template <template <class...> class Template, class T>
        static constexpr bool IsInstanceOfV = IsInstanceOf<Template, T>::value;
 
        template <class T, template <class...> class... Templates>
        static constexpr bool IsInstanceOfAnyV = (IsInstanceOf<Templates, T>::value || ...);
 
        static_assert(!IsInstanceOfAnyV<int, RemoveRvalueReference, std::tuple>);
        static_assert(
            IsInstanceOfAnyV<RemoveRvalueReference<int>, RemoveRvalueReference, std::tuple>);
        static_assert(IsInstanceOfAnyV<std::tuple<int>, RemoveRvalueReference, std::tuple>);
 
        template <class T>
        struct DisassembleTemplate : std::false_type
        {
        };
 
        template <template <class...> class Template, class... Params>
        struct DisassembleTemplate<Template<Params...>> : std::true_type
        {
            template <template <class...> class NewTemplate>
            using ReplaceTemplate = NewTemplate<Params...>;
 
            template <class... NewParams>
            using ReplaceParameters = Template<NewParams...>;
        };
    };
 
    /**
     * @brief Get the type of the last element of a template parameter pack.
     */
    template <class T0, class... Ts>
    using last_type = typename std::decay<
        typename std::tuple_element<sizeof...(Ts), std::tuple<T0, Ts...>>::type>::type;
 
    /**
     * @brief Get the type of the first element of a template parameter pack.
     */
    template <class T0, class... Ts>
    using first_type = T0;
    /**
     * @brief Get the type of the second element of a template parameter pack.
     */
    template <class T0, class T1, class... Ts>
    using second_type = T1;
    /**
     * @brief Get the type of the third element of a template parameter pack.
     */
    template <class T0, class T1, class T2, class... Ts>
    using third_type = T2;
 
    template <std::size_t n, class... Ts>
    struct NthType
    {
    };
 
    template <std::size_t n, class T0, class... Ts>
    struct NthType<n, T0, Ts...>
    {
        using type =
            typename std::decay<typename std::tuple_element<n, std::tuple<T0, Ts...>>::type>::type;
    };
 
    /**
     * @brief Get the type of the nth element of a template parameter pack.
     */
    template <std::size_t n, class T0, class... Ts>
    using nth_type =
        typename std::decay<typename std::tuple_element<n, std::tuple<T0, Ts...>>::type>::type;
 
    /**
     * @brief Can be used to determine if there is an overload for std::to_string for a type T
     *
     * This is the default if there is no overload
     */
    template <class T, class = void>
    struct HasToString : std::false_type
    {
    };
 
    /**
     * @brief Can be used to determine if there is an overload for std::to_string for a type T
     *
     * This is the specialization if there is an overload.
     */
    template <class T>
    struct HasToString<
        T,
        typename std::enable_if<
            std::is_same<decltype(std::to_string(std::declval<T>()), int{}), int>::value>::type> :
        std::true_type
    {
    };
 
    //can't use this since gcc is broken / sfinae is bad in c++11
    //struct HasToString < T, void_t<decltype(std::to_string(std::declval<T>()))> > :std::true_type {};
 
 
    /**
     * @brief Can be used to determine if T has an at method accepting a type of IdxT
     *
     * This is the default if there is no method
     */
    template <class T, class IdxT, class = void>
    struct HasAtMethod : std::false_type
    {
    };
 
    /**
     * @brief Can be used to determine if T has an at method accepting a type of IdxT
     *
     * This is the specialization if there is a method
     */
    template <class T, class IdxT>
    struct HasAtMethod<T,
                       IdxT,
                       typename std::enable_if<
                           std::is_same<decltype(std::declval<T>().at(std::declval<IdxT>()), int{}),
                                        int>::value>::type> : std::true_type
    {
    };
 
    //can't use this since gcc is broken / sfinae is bad in c++11
    //struct HasAtMethod< T, IdxT,void_t<decltype(std::declval<T>().at(std::declval<IdxT>()))>> : std::true_type {};
 
#define ARMARX_META_MAKE_HAS_MEMBER_FNC_CHECK(CHECKNAME, FNCNAME, FNCSIG)                          \
    template <class T>                                                                             \
    class CHECKNAME                                                                                \
    {                                                                                              \
        struct one                                                                                 \
        {                                                                                          \
        };                                                                                         \
        struct two                                                                                 \
        {                                                                                          \
            one a, b;                                                                              \
        };                                                                                         \
        template <class C, C>                                                                      \
        struct classAndFncPtr;                                                                     \
        template <class C>                                                                         \
        static one has(classAndFncPtr<FNCSIG, &C::FNCNAME>*);                                      \
        template <class T2>                                                                        \
        static two has(...);                                                                       \
                                                                                                   \
    public:                                                                                        \
        static constexpr bool value = sizeof(has<T>(0)) == sizeof(one);                            \
    };                                                                                             \
    template <class T>                                                                             \
    static constexpr bool CHECKNAME##_v = CHECKNAME<T>::value
 
    template <std::size_t...>
    struct IndexSequence
    {
        using type = IndexSequence;
    };
} // namespace armarx::meta
 
namespace armarx::meta::detail
{
    template <class S1, class S2>
    struct ConcatIndexSequences;
 
    template <std::size_t... I1, std::size_t... I2>
    struct ConcatIndexSequences<IndexSequence<I1...>, IndexSequence<I2...>> :
        IndexSequence<I1..., (sizeof...(I1) + I2)...>
    {
    };
 
    template <std::size_t N>
    struct MakeIndexSequence;
 
    template <>
    struct MakeIndexSequence<0> : IndexSequence<>
    {
    };
 
    template <>
    struct MakeIndexSequence<1> : IndexSequence<0>
    {
    };
 
    template <std::size_t N>
    struct MakeIndexSequence :
        detail::ConcatIndexSequences<typename MakeIndexSequence<N / 2>::type,
                                     typename MakeIndexSequence<N - N / 2>::type>
    {
    };
 
    template <std::size_t Lo, class>
    struct AddToIndexSequence;
 
    template <std::size_t Lo, std::size_t... Is>
    struct AddToIndexSequence<Lo, IndexSequence<Is...>>
    {
        using type = IndexSequence<Lo + Is...>;
    };
 
    template <std::size_t Lo, std::size_t Hi>
    struct MakeIndexRange : AddToIndexSequence<Lo, typename MakeIndexSequence<Hi - Lo>::type>
    {
    };
} // namespace armarx::meta::detail
 
namespace armarx::meta
{
    template <std::size_t N>
    using MakeIndexSequence = typename detail::MakeIndexSequence<N>::type;
 
    template <std::size_t Lo, std::size_t Hi>
    using MakeIndexRange = typename detail::MakeIndexRange<Lo, Hi>::type;
 
    template <class... Ts>
    using MakeIndexSequenceFor = MakeIndexSequence<sizeof...(Ts)>;
} // namespace armarx::meta
 
namespace armarx::meta::detail
{
    /**
     * @see armarx::meta::DecayAll
     */
    template <class T>
    struct DecayAll
    {
        using type = typename std::decay<T>::type;
    };
 
    /**
     * @see armarx::meta::DecayAll
     */
    template <class T>
    struct DecayAll<T*>
    {
        using type = typename DecayAll<T>::type;
    };
 
    /**
     * @see armarx::meta::DecayAll
     */
    template <class T, std::size_t N>
    struct DecayAll<T[N]>
    {
        using type = typename DecayAll<T>::type;
    };
} // namespace armarx::meta::detail
 
namespace armarx::meta
{
    /**
     * @brief Similar to std::decay but also decays ptr and array
     */
    template <class T>
    using DecayAll = detail::DecayAll<typename std::decay<T>::type>;
 
    template <class T>
    struct Wrapper
    {
        using type = T;
    };
 
    template <class Base, class... Ds>
    struct IsBaseOf : std::true_type
    {
    };
 
    template <class Base, class D0, class... Ds>
    struct IsBaseOf<Base, D0, Ds...> :
        std::integral_constant<bool,
                               std::is_base_of<Base, D0>::value && IsBaseOf<Base, Ds...>::value>
    {
    };
} // namespace armarx::meta
 
namespace armarx::meta
{
    template <class T, class... Others>
    static constexpr bool is_any_of_v = (std::is_same_v<T, Others> || ...);
}
 
namespace armarx::meta
{
    // from https://stackoverflow.com/questions/22758291/how-can-i-detect-if-a-type-can-be-streamed-to-an-stdostream
    template <typename S, typename T>
    class is_streamable
    {
        template <typename SS, typename TT>
        static auto test(int)
            -> decltype(std::declval<SS&>() << std::declval<TT>(), std::true_type());
 
        template <typename, typename>
        static auto test(...) -> std::false_type;
 
    public:
        static const bool value = decltype(test<S, T>(0))::value;
    };
} // namespace armarx::meta