typelist.hh

// -*- tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*-
// vi: set et ts=4 sw=2 sts=2:
#ifndef DUNE_COMMON_TYPELIST_HH
#define DUNE_COMMON_TYPELIST_HH
 
#include <type_traits>
#include <tuple>
#include <utility>
 
namespace Dune {
 
  template<class T>
  struct MetaType {
    using type = T;
  };
 
  template<class... T>
  using TypeList = std::tuple<MetaType<T>...>;
 
 
 
  template<class T>
  struct IsTypeList : std::false_type {};
 
  template<class... T>
  struct IsTypeList<TypeList<T...> > : std::true_type {};
 
 
 
  template<class T>
  struct IsEmptyTypeList : std::is_same<T, TypeList<> > {};
 
 
 
  template<class T>
  struct TypeListSize {};
 
  template<class... T>
  struct TypeListSize<TypeList<T...>> : std::integral_constant<std::size_t, sizeof...(T)> {};
 
 
 
  template<std::size_t i, class T>
  struct TypeListElement {};
 
  template<std::size_t i, class... T>
  struct TypeListElement<i, TypeList<T...>>
  {
    using type = typename std::tuple_element<i, std::tuple<T...>>::type;
 
    using Type = type;
  };
 
  template<std::size_t i, class T>
  using TypeListEntry_t = typename TypeListElement<i, T>::type;
 
  namespace Impl {
 
    template<template<class...> class Target, class ToDoList, class... Processed>
    struct UniqueTypesHelper;
 
    template<template<class...> class Target, class... Processed>
    struct UniqueTypesHelper<Target, TypeList<>, Processed...>
    {
      using type = Target<Processed...>;
    };
 
    template<template<class...> class Target, class T0, class... T, class... Processed>
    struct UniqueTypesHelper<Target, TypeList<T0, T...>, Processed...>
    {
      using type = std::conditional_t<
        std::disjunction<std::is_same<T0, Processed>...>::value,
        typename UniqueTypesHelper<Target, TypeList<T...>, Processed...>::type,
        typename UniqueTypesHelper<Target, TypeList<T...>, T0, Processed...>::type>;
    };
 
    // Helper for unpacking Dune::TypeList
    template<template<class...> class Target, class TL>
    struct UnpackTypeList;
 
    template<template<class...> class Target, class... T>
    struct UnpackTypeList<Target, Dune::TypeList<T...>>
    {
      using type = Target<T...>;
    };
 
  } // namespace Impl
 
  template<template<class...> class Target, class TL>
  using UnpackTypeList_t = typename Impl::UnpackTypeList<Target, TL>::type;
 
  template<template<class...> class Target, class... T>
  using UniqueTypes_t = typename Impl::UniqueTypesHelper<Target, TypeList<T...>>::type;
 
  template<class NonUniqueTypeList>
  using UniqueTypeList_t = typename Impl::UniqueTypesHelper<TypeList, NonUniqueTypeList>::type;
 
  template<class... T>
  constexpr auto uniqueTypeList(TypeList<T...> list)
  {
    return typename Impl::UniqueTypesHelper<TypeList, TypeList<T...>>::type{};
  }
 
 
 
} // namespace Dune
 
#endif // DUNE_COMMON_TYPELIST_HH