metaprogramming.h

Go to the documentation of this file.

/* 
* Copyright (C) 2020-2026 MEmilio
*
* Authors: Daniel Abele
*
* Contact: Martin J. Kuehn <Martin.Kuehn@DLR.de>
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
*     http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef MIO_UTILS_METAPROGRAMMING_H
#define MIO_UTILS_METAPROGRAMMING_H
 
#include <type_traits>
#include <utility>
 
namespace ad
{
namespace internal
{
// Forward declaration of the AD type template
template <class Value, class Tape>
struct active_type;
} // namespace internal
} // namespace ad
 
namespace mio
{
 
namespace details
{
//non-copyable but trivally constructible and moveable type
struct NoCopy {
    NoCopy(const NoCopy&)            = delete;
    NoCopy()                         = default;
    NoCopy(NoCopy&&)                 = default;
    NoCopy& operator=(const NoCopy&) = delete;
    NoCopy& operator=(NoCopy&&)      = default;
};
 
//trivially constructible, copyable, moveable type
struct Empty {
};
} // namespace details
 
template <class T>
using is_small_integral = std::integral_constant<bool, (std::is_integral_v<T> && sizeof(T) <= 4)>;
template <class T>
using is_64bit_integral = std::integral_constant<bool, (std::is_integral_v<T> && sizeof(T) == 8)>;
 
template <bool Cond>
using not_copyable_if = std::conditional<Cond, details::NoCopy, details::Empty>;
 
template <bool Cond>
using not_copyable_if_t = typename not_copyable_if<Cond>::type;
 
namespace details
{
 
template <std::size_t Index, class Head, class... Tail>
struct type_at_index_impl {
    using type = typename type_at_index_impl<Index - 1, Tail...>::type;
};
template <class Head, class... Tail>
struct type_at_index_impl<0, Head, Tail...> {
    using type = Head;
};
} // namespace details
 
template <std::size_t Index, class... Types>
struct type_at_index {
    static_assert(Index < sizeof...(Types), "Index is too large for the list Types.");
    using type = typename details::type_at_index_impl<Index, Types...>::type;
};
 
template <std::size_t Index, class... Types>
using type_at_index_t = typename type_at_index<Index, Types...>::type;
 
namespace details
{
 
template <std::size_t Size, class Type>
constexpr std::size_t index_of_impl()
{
    // this works both as an overload for empty lists as well as a "not found"
    return Size;
}
template <std::size_t Size, class Type, class Head, class... Tail>
constexpr std::size_t index_of_impl()
{
    // check if the type matches, otherwise call itself, omitting Head
    // this is significantly cheaper to compile compared to using an index and carrying the entire list,
    // as that needs additional work for looking up "Types[Index]", e.g. through type_at_index
    if constexpr (std::is_same_v<Type, Head>) {
        return Size - sizeof...(Tail) - 1;
    }
    else {
        return index_of_impl<Size, Type, Tail...>();
    }
}
} // namespace details
 
template <class Type, class... Types>
struct is_type_in_list
    : std::conditional_t<(details::index_of_impl<sizeof...(Types), Type, Types...>() < sizeof...(Types)),
                         std::true_type, std::false_type> {
};
 
template <class Type, class... Types>
constexpr bool is_type_in_list_v = is_type_in_list<Type, Types...>::value;
 
template <class Type, class... Types>
struct index_of_type {
    static constexpr std::size_t value = details::index_of_impl<sizeof...(Types), Type, Types...>();
    static_assert(value < sizeof...(Types), "Type is not contained in given list.");
};
 
template <class Type, class... Types>
constexpr std::size_t index_of_type_v = index_of_type<Type, Types...>::value;
 
template <class... Types>
struct has_duplicates {
private:
    template <std::size_t... Indices>
    static constexpr bool has_duplicates_impl(std::index_sequence<Indices...>)
    {
        // index_of_type_v will always be equal to the index of the first occurance of a type,
        // while Indices contains its actual index. Hence, if there is any mismatch, then there is a duplicate.
        return ((index_of_type_v<Types, Types...> != Indices) || ...);
    }
 
public:
    static constexpr bool value = has_duplicates_impl(std::make_index_sequence<sizeof...(Types)>{});
};
 
template <class... Types>
constexpr bool has_duplicates_v = has_duplicates<Types...>::value;
 
template <class T, class = void>
struct is_ad_type : public std::false_type {
};
 
template <class Value, class Tape>
struct is_ad_type<ad::internal::active_type<Value, Tape>> : public std::true_type {
};
 
template <class T>
constexpr bool is_ad_type_v = is_ad_type<T>::value;
} // namespace mio
 
#endif // MIO_UTILS_METAPROGRAMMING_H