TupleTraits.h

Go to the documentation of this file.

//=========================================================================
//  Copyright (c) Kitware, Inc.
//  All rights reserved.
//  See LICENSE.txt for details.
//
//  This software is distributed WITHOUT ANY WARRANTY; without even
//  the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
//  PURPOSE.  See the above copyright notice for more information.
//=========================================================================
 
#ifndef smtk_TupleTraits_h
#define smtk_TupleTraits_h
 
#include <cstddef>
#include <tuple>
 
namespace smtk
{
 
namespace detail
{
template<typename T, typename Tuple>
struct tuple_if_unique;
 
template<typename T>
struct tuple_if_unique<T, std::tuple<>>
{
  using type = std::tuple<T>;
};
 
template<typename T, typename U, typename... Ts>
struct tuple_if_unique<T, std::tuple<U, Ts...>>
{
  using type = typename tuple_if_unique<T, std::tuple<Ts...>>::type;
};
 
template<typename T, typename... Ts>
struct tuple_if_unique<T, std::tuple<T, Ts...>>
{
  using type = std::tuple<>;
};
 
template<typename T, typename Tuple>
struct tuple_if_not_base;
 
template<typename T>
struct tuple_if_not_base<T, std::tuple<>>
{
  using type = std::tuple<T>;
};
 
template<typename T, typename U, typename... Ts>
struct tuple_if_not_base<T, std::tuple<U, Ts...>>
{
  using type = typename std::conditional<
    std::is_base_of<T, U>::value,
    std::tuple<>,
    typename tuple_if_not_base<T, std::tuple<Ts...>>::type>::type;
};
 
template<typename T, typename... Args>
struct remove_bases_from_tuple_lr;
 
template<>
struct remove_bases_from_tuple_lr<std::tuple<>>
{
  using type = std::tuple<>;
};
 
template<typename T>
struct remove_bases_from_tuple_lr<std::tuple<T>>
{
  using type = std::tuple<T>;
};
 
template<typename T, typename... Args>
struct remove_bases_from_tuple_lr<std::tuple<T, Args...>>
{
  using type = decltype(std::tuple_cat(
    std::declval<typename detail::tuple_if_not_base<T, std::tuple<Args...>>::type>(),
    std::declval<typename remove_bases_from_tuple_lr<std::tuple<Args...>>::type>()));
};
 
template<typename T>
struct untuple
{
  using type = T;
};
 
template<typename T>
struct untuple<std::tuple<T>>
{
  using type = typename untuple<T>::type;
};
} // namespace detail
 
template<typename T>
struct flatten_tuple;
 
template<>
struct flatten_tuple<std::tuple<>>
{
  using type = std::tuple<>;
};
 
template<typename T, typename... Args>
struct flatten_tuple<std::tuple<T, Args...>>
{
  using type = decltype(std::tuple_cat(
    std::declval<std::tuple<typename detail::untuple<T>::type>>(),
    std::declval<typename flatten_tuple<std::tuple<Args...>>::type>()));
};
 
template<typename... TupleArgs, typename... Args>
struct flatten_tuple<std::tuple<std::tuple<TupleArgs...>, Args...>>
{
  using type = decltype(std::tuple_cat(
    std::declval<std::tuple<TupleArgs...>>(),
    std::declval<typename flatten_tuple<std::tuple<Args...>>::type>()));
};
 
template<typename T, typename... Args>
struct unique_tuple;
 
template<>
struct unique_tuple<std::tuple<>>
{
  using type = std::tuple<>;
};
 
template<typename T>
struct unique_tuple<std::tuple<T>>
{
  using type = std::tuple<T>;
};
 
template<typename T, typename... Args>
struct unique_tuple<std::tuple<T, Args...>>
{
  using type = decltype(std::tuple_cat(
    std::declval<typename detail::tuple_if_unique<T, std::tuple<Args...>>::type>(),
    std::declval<typename unique_tuple<std::tuple<Args...>>::type>()));
};
 
template<typename T>
struct reverse_tuple;
 
template<typename T>
struct reverse_tuple<std::tuple<T>>
{
  using type = std::tuple<T>;
};
 
template<typename T, typename... Args>
struct reverse_tuple<std::tuple<T, Args...>>
{
  using type = decltype(std::tuple_cat(
    std::declval<typename reverse_tuple<std::tuple<Args...>>::type>(),
    std::declval<std::tuple<T>>()));
};
 
template<template<typename> class X, typename T>
struct recursive
{
  using type = typename X<T>::type;
};
 
template<template<typename> class X, typename... Args>
struct recursive<X, std::tuple<Args...>>
{
  using type = typename X<std::tuple<typename recursive<X, Args>::type...>>::type;
};
 
template<typename T>
struct remove_bases_from_tuple
{
  using type = typename detail::remove_bases_from_tuple_lr<typename reverse_tuple<
    typename detail::remove_bases_from_tuple_lr<typename reverse_tuple<T>::type>::type>::type>::
    type;
};
 
template<typename T, typename Tuple>
struct remove_from_tuple;
 
template<typename T, typename... Args>
struct remove_from_tuple<T, std::tuple<T, Args...>>
{
  using type = decltype(std::declval<typename remove_from_tuple<T, std::tuple<Args...>>::type>());
};
 
template<typename T, typename X, typename... Args>
struct remove_from_tuple<T, std::tuple<X, Args...>>
{
  using type = decltype(std::tuple_cat(
    std::declval<std::tuple<X>>(),
    std::declval<typename remove_from_tuple<T, std::tuple<Args...>>::type>()));
};
 
template<typename T>
struct remove_from_tuple<T, std::tuple<>>
{
  using type = std::tuple<>;
};
 
template<class T, class Tuple>
struct tuple_index;
 
template<class T, class... Types>
struct tuple_index<T, std::tuple<T, Types...>>
{
  constexpr static const std::size_t value = 0;
};
 
template<class T, class U, class... Types>
struct tuple_index<T, std::tuple<U, Types...>>
{
  constexpr static const std::size_t value = 1 + tuple_index<T, std::tuple<Types...>>::value;
};
 
template<typename T, typename Tuple>
struct tuple_contains;
 
template<typename T>
struct tuple_contains<T, std::tuple<>> : std::false_type
{
};
 
template<typename T, typename U, typename... Ts>
struct tuple_contains<T, std::tuple<U, Ts...>> : tuple_contains<T, std::tuple<Ts...>>
{
};
 
template<typename T, typename... Ts>
struct tuple_contains<T, std::tuple<T, Ts...>> : std::true_type
{
};
 
template<typename T>
struct identity
{
  typedef T type;
};
 
template<std::size_t...>
struct sequence
{
};
 
template<std::size_t N, std::size_t... S>
struct index_sequence : index_sequence<N - 1, N - 1, S...>
{
};
 
template<std::size_t... S>
struct index_sequence<0, S...>
{
  typedef sequence<S...> type;
};
 
namespace detail
{
 
template<std::size_t I, typename RI, template<typename T, typename R> class Reducer, typename Tuple>
struct tuple_reduce_ii;
 
template<typename RI, template<typename T, typename R> class Reducer, typename Tuple>
struct tuple_reduce_ii<0, RI, Reducer, Tuple>
{
  using type = RI;
};
 
template<std::size_t I, typename RI, template<typename T, typename R> class Reducer, typename Tuple>
struct tuple_reduce_ii
{
  static_assert(I > 0, "This template can never terminate the sequence.");
  using type = typename tuple_reduce_ii<
    I - 1,
    typename Reducer<
      typename std::tuple_element<std::tuple_size<Tuple>::value - 1, Tuple>::type,
      RI>::type,
    Reducer,
    Tuple>::type;
};
} // namespace detail
 
template<template<typename T, typename RI> class Reducer, typename Tuple, typename Start>
struct tuple_reduce
{
  using type = typename std::conditional<
    std::tuple_size<Tuple>::value == 0,
    Start,
    typename detail::tuple_reduce_ii<std::tuple_size<Tuple>::value, Start, Reducer, Tuple>::type>::
    type;
};
 
template<typename Functor, size_t I = 0, typename... Ts>
typename std::enable_if<I == sizeof...(Ts), void>::type apply(Functor& f, std::tuple<Ts...> tup)
{
}
 
template<typename Functor, size_t I = 0, typename... Ts>
typename std::enable_if<(I < sizeof...(Ts)), void>::type apply(Functor& f, std::tuple<Ts...> tup)
{
  f(I, std::get<I>(tup));
 
  // Go to next element
  apply<Functor, I + 1>(f, tup);
}
 
template<typename Tuple, std::size_t I = 0, typename Functor>
typename std::enable_if<I == std::tuple_size<Tuple>::value, void>::type tuple_evaluate(Functor& f)
{
  // Do nothing; no more tuple elements left.
  (void)f;
}
 
template<typename Tuple, std::size_t I = 0, typename Functor>
typename std::enable_if<(I < std::tuple_size<Tuple>::value), void>::type tuple_evaluate(Functor& f)
{
  // Process the I-th tuple element...
  f.template evaluate<typename std::tuple_element<I, Tuple>::type>(I);
 
  // ... and then go to next element
  smtk::tuple_evaluate<Tuple, I + 1>(f);
}
 
} // namespace smtk
 
#endif