utility.hh

#ifndef DUNE_COMMON_STD_UTILITY_HH
#define DUNE_COMMON_STD_UTILITY_HH
 
#include <cstddef>
 
#include <type_traits>
#include <utility>
 
#include <dune/common/typetraits.hh>
 
namespace Dune
{
 
  namespace Std
  {
 
 
#if __cpp_lib_integer_sequence >= 201304
 
    using std::integer_sequence;
    using std::index_sequence;
    using std::make_integer_sequence;
    using std::make_index_sequence;
 
#else // __cpp_lib_integer_sequence >= 201304
 
    // integer_sequence
    // ----------------
 
    template< class T, T... Ints >
    class integer_sequence
    {
      static_assert( std::is_integral< T >::value, "Template parameter T is required to be an integral type" );
 
    public:
 
      typedef T value_type;
 
      static constexpr std::size_t size () { return sizeof...( Ints ); }
    };
 
 
    template< std::size_t... Ints >
    using index_sequence = integer_sequence< std::size_t, Ints... >;
 
#ifndef DOXYGEN
 
    namespace impl {
 
      template<typename T, T i, T n, T... indices>
      struct _make_integer_sequence
        : public _make_integer_sequence<T,i+1,n,indices...,i>
      {};
 
      template<typename T, T n, T... indices>
      struct _make_integer_sequence<T,n,n,indices...>
      {
        using type = integer_sequence<T,indices...>;
      };
 
    }
 
#endif // DOXYGEN
 
    template<typename T, T n>
    using make_integer_sequence = typename impl::_make_integer_sequence<T,0,n>::type;
 
    template<std::size_t n>
    using make_index_sequence = make_integer_sequence<std::size_t,n>;
 
#endif // __cpp_lib_integer_sequence >= 201304
 
    template<typename... T>
    using index_sequence_for = make_index_sequence<typename Dune::SizeOf<T...>{}>;
 
 
 
  } // namespace Std
 
} // namespace Dune
 
#endif // #ifndef DUNE_COMMON_STD_UTILITY_HH