Tuple.h

#pragma once
 
#include <tuple>
 
namespace Cogs
{
  namespace Detail
  {
    template<int Index, class Search, class First, class... Types>
    struct get_internal
    {
      typedef typename get_internal<Index + 1, Search, Types...>::type type;
      static const int index = Index;
    };
 
    template<int Index, class Search, class... Types>
    struct get_internal<Index, Search, Search, Types...>
    {
      typedef get_internal type;
      static const int index = Index;
    };
  }
 
  template<class T, class... Types>
  T & get(std::tuple<Types...> & tuple)
  {
    return std::get<Detail::get_internal<0, T, Types...>::type::index>(tuple);
  }
 
  template<class T, class... Types>
  const T & get(const std::tuple<Types...> & tuple)
  {
    return std::get<Detail::get_internal<0, T, Types...>::type::index>(tuple);
  }
 
  namespace Detail
  {
    template<int... Is>
    struct seq {};
 
    template<int N, int... Is>
    struct gen_seq : gen_seq<N - 1, N - 1, Is...> {};
 
    template<int... Is>
    struct gen_seq<0, Is...> : seq<Is...>{};
 
    template<typename T, typename F, int... Is>
    void for_each(T && t, F f, seq<Is...>)
    {
      auto l = { (f(std::get<Is>(t)), 0)... };
      static_cast<void>(l);
    }
  }
 
  template<typename... Ts, typename F>
  void for_each_in_tuple(std::tuple<Ts...> & t, F f)
  {
    Detail::for_each(t, f, Detail::gen_seq<sizeof...(Ts)>());
  }
}