fork(2) download

#include <utility>
#include <tuple>
 
template <typename T>
struct unqualified { typedef typename std::remove_cv< typename std::remove_reference<T>::type>::type type; };
 
template <typename... T>
struct stuff{ typedef stuff type;/* contains all the types! */ };
 
template <std::size_t...> 
struct indices_list { typedef indices_list type; };
 
template <std::size_t N, std::size_t... I>
struct indices : public indices<N-1, N-1, I...> { };
 
template <std::size_t... I>
struct indices<0, I...> : public indices_list<I...>{ };
 
template <typename T>
struct tuple_indices : public indices<std::tuple_size<typename unqualified<T>::type>::value> { };
 
template <typename TStuff>
auto awesome_tuple_dog( TStuff&& ) {
	// The first man gets the oyster, the second man gets the shell
	return std::tuple<>{};
}
 
template <typename TStuff, typename TFinalTuple>
auto awesome_tuple_dog( TStuff&&, TFinalTuple&& tuple ) {
	// A greater Tuple has been born..
	return std::forward<TFinalTuple>( tuple );
}
 
template <std::size_t ...I, std::size_t ...J, typename... Indices, typename Tuple0, typename Tuple1, typename... Tuplen>
auto awesome_tuple_dog( stuff<indices_list<I...>, indices_list<J...>, Indices...>, Tuple0&& t0, Tuple1&& t1, Tuplen&&... tn ) {
    // We know for a fact that "stuff" has ever single indices list we need, but some of it is hidden
    // behind variadics. We need to unpack every single last one of the indices we need and get the 'I...' we need...
    return awesome_tuple_dog( 
        stuff<Indices...>(), // deal with the next set of indices, and use them to unite the lesser tuples!
        std::make_tuple( std::get<I>( std::forward<Tuple0>( t0 ) )..., std::get<J>( std::forward<Tuple1>( t1 ) )... ),
        std::forward<Tuplen>( tn )... // keep going, consume the inferior tuples!
        );
}
 
template <typename... Tuplen>
auto awesome_tuple_cat( Tuplen&&... tn ) {
    // It doens't cut it to just have tuple_indices<Tuplen>()..., because that's another variadic who's contents
    // are hard to get at in another function. Need to wrap it up in a 'stuff'
    //return awesome_tuple_dog( tuple_indices<Tuplen>()..., std::forward<Tuple0>( t0 ), std::forward<Tuple1>( t1 ) );
    return awesome_tuple_dog( stuff<typename tuple_indices<Tuplen>::type...>(), std::forward<Tuplen>( tn )... );
}
 
int main () {
    std::tuple<bool, char> a;
    std::tuple<short, int> b;
    std::tuple<long long> c;
    struct {} _ = awesome_tuple_cat( );
    struct {} __ = awesome_tuple_cat( a, b );
    struct {} ___ = awesome_tuple_cat( a, b, c );
 
}

prog.cpp:23:34: warning: ‘awesome_tuple_dog’ function uses ‘auto’ type specifier without trailing return type [enabled by default]
 auto awesome_tuple_dog( TStuff&& ) {
                                  ^
prog.cpp:29:55: warning: ‘awesome_tuple_dog’ function uses ‘auto’ type specifier without trailing return type [enabled by default]
 auto awesome_tuple_dog( TStuff&&, TFinalTuple&& tuple ) {
                                                       ^
prog.cpp:35:125: warning: ‘awesome_tuple_dog’ function uses ‘auto’ type specifier without trailing return type [enabled by default]
 auto awesome_tuple_dog( stuff<indices_list<I...>, indices_list<J...>, Indices...>, Tuple0&& t0, Tuple1&& t1, Tuplen&&... tn ) {
                                                                                                                             ^
prog.cpp:46:40: warning: ‘awesome_tuple_cat’ function uses ‘auto’ type specifier without trailing return type [enabled by default]
 auto awesome_tuple_cat( Tuplen&&... tn ) {
                                        ^
prog.cpp: In function ‘int main()’:
prog.cpp:57:38: error: conversion from ‘std::tuple<>’ to non-scalar type ‘main()::<anonymous struct>’ requested
     struct {} _ = awesome_tuple_cat( );
                                      ^
prog.cpp:58:44: error: conversion from ‘std::tuple<bool, char, short int, int>’ to non-scalar type ‘main()::<anonymous struct>’ requested
     struct {} __ = awesome_tuple_cat( a, b );
                                            ^
prog.cpp: In instantiation of ‘auto awesome_tuple_dog(stuff<indices_list<I ...>, indices_list<J ...>, Indices ...>, Tuple0&&, Tuple1&&, Tuplen&& ...) [with unsigned int ...I = {0u, 1u}; unsigned int ...J = {0u, 1u}; Indices = {indices_list<0u>}; Tuple0 = std::tuple<bool, char>&; Tuple1 = std::tuple<short int, int>&; Tuplen = {std::tuple<long long int>&}]’:
prog.cpp:50:111:   required from ‘auto awesome_tuple_cat(Tuplen&& ...) [with Tuplen = {std::tuple<bool, char>&, std::tuple<short int, int>&, std::tuple<long long int>&}]’
prog.cpp:59:48:   required from here
prog.cpp:42:9: error: no matching function for call to ‘awesome_tuple_dog(stuff<indices_list<0u> >, std::tuple<bool, char, short int, int>, std::tuple<long long int>&)’
         );
         ^
prog.cpp:42:9: note: candidates are:
prog.cpp:23:6: note: template<class TStuff> auto awesome_tuple_dog(TStuff&&)
 auto awesome_tuple_dog( TStuff&& ) {
      ^
prog.cpp:23:6: note:   template argument deduction/substitution failed:
prog.cpp:42:9: note:   candidate expects 1 argument, 3 provided
         );
         ^
prog.cpp:29:6: note: template<class TStuff, class TFinalTuple> auto awesome_tuple_dog(TStuff&&, TFinalTuple&&)
 auto awesome_tuple_dog( TStuff&&, TFinalTuple&& tuple ) {
      ^
prog.cpp:29:6: note:   template argument deduction/substitution failed:
prog.cpp:42:9: note:   candidate expects 2 arguments, 3 provided
         );
         ^
prog.cpp:35:6: note: template<unsigned int ...I, unsigned int ...J, class ... Indices, class Tuple0, class Tuple1, class ... Tuplen> auto awesome_tuple_dog(stuff<indices_list<I ...>, indices_list<J ...>, Indices ...>, Tuple0&&, Tuple1&&, Tuplen&& ...)
 auto awesome_tuple_dog( stuff<indices_list<I...>, indices_list<J...>, Indices...>, Tuple0&& t0, Tuple1&& t1, Tuplen&&... tn ) {
      ^
prog.cpp:35:6: note:   template argument deduction/substitution failed:
prog.cpp:42:9: note:   candidate expects 3 arguments, 1 provided
         );
         ^
prog.cpp:42:9: note:   ‘stuff<indices_list<0u> >’ is not derived from ‘stuff<indices_list<I ...>, indices_list<J ...>, Indices ...>’
prog.cpp:59:48: error: conversion from ‘void’ to non-scalar type ‘main()::<anonymous struct>’ requested
     struct {} ___ = awesome_tuple_cat( a, b, c );
                                                ^

Standard output is empty