Great Type Loophole Example, C++ (clang)

Language: Layout:

/*
  The Great Type Loophole

This example is part of the blog post http://alexpolt.github.io/type-loophole.html

The main function is at the bottom.
*/

#include <type_traits>
#include <utility>

#include <cstdio>
#include <typeinfo>

#include <string>
#include <vector>

/*************  luple.h ***************/

/* 
  This header is for the luple (a lightweight tuple) which is useful to work with a type list.
  Source code with comments: https://github.com/alexpolt/luple/blob/master/luple.h

The header for the type loophole comes next.
*/

namespace luple_ns {

template<typename... TT> struct type_list { static const int size = sizeof...(TT); };

template<typename T, int N, int M = 0> struct tlist_get;

template<int N, int M, typename T, typename... TT> struct tlist_get< type_list<T, TT...>, N, M > {
    static_assert(N < (int) sizeof...(TT)+1 + M, "type index out of bounds");
    using type = std::conditional_t< N == M, T, typename tlist_get< type_list<TT...>, N, M + 1 >::type >;
  };
  template<int N, int M> struct tlist_get< type_list<>, N, M > { using type = void; };
  template<int N> struct tlist_get< type_list<>, N, 0 > {};

template<typename T, int N>
  using tlist_get_t = typename tlist_get<T, N>::type;

template<typename T, typename U, int N = 0> struct tlist_get_n;

template<typename U, int N, typename T, typename... TT> struct tlist_get_n< type_list<T, TT...>, U, N > {
    static const int value = std::is_same< T, U >::value ? N : tlist_get_n< type_list<TT...>, U, N + 1 >::value;
  };
  template<typename U, int N> struct tlist_get_n< type_list<>, U, N > {
    static const int value = -1;
  };

template<typename T, int N> struct tuple_element {
    tlist_get_t<T, N> value;
  };

template<typename T, typename U> struct tuple_base;

template<typename... TT, int... NN>
  struct tuple_base< type_list<TT...>, std::integer_sequence<int, NN...> > : tuple_element< type_list<TT...>, NN >... {

using tlist = type_list<TT...>;

template<typename... UU, typename U = std::enable_if_t< sizeof...(UU) == sizeof...(NN) >>
    constexpr tuple_base ( UU&&... args ) : tuple_element< tlist, NN >{ std::forward<UU>(args) }... {}
    constexpr tuple_base ( TT const&... args ) : tuple_element< tlist, NN >{ args }... {}
    constexpr tuple_base ( TT&&... args ) : tuple_element< tlist, NN >{ std::move(args) }... {}
    constexpr tuple_base () {}
  };

template<typename T> struct tuple : tuple_base< T, std::make_integer_sequence<int, T::size> > {

using type_list = T;
    using base = tuple_base< T, std::make_integer_sequence<int, T::size> >;

template<int N> constexpr auto& get() {
      static_assert(N < T::size, "tuple::get -> out of bounds access");
      return tuple_element< T, N >::value;
    }

template<typename U> constexpr auto& get() {
      static_assert(tlist_get_n<T, U>::value != -1, "no such type in type list");
      return tuple_element< T, tlist_get_n<T, U>::value >::value;
    }

template<int N> constexpr auto& get() const {
      static_assert(N < T::size, "tuple::get -> out of bounds access");
      return tuple_element< T, N >::value;
    }

template<typename U> constexpr auto& get() const {
      static_assert(tlist_get_n<T, U>::value != -1, "no such type in type list");
      return tuple_element< T, tlist_get_n<T, U>::value >::value;
    }

using base::base;
  };

template<int N, typename T> constexpr auto& get ( tuple<T>& t ) { return t.template get<N>(); }
  template<typename U, typename T> constexpr auto& get ( tuple<T>& t ) { return t.template get<U>(); }

template<int N, typename T> constexpr auto& get ( tuple<T> const& t ) { return t.template get<N>(); }
  template<typename U, typename T> constexpr auto& get ( tuple<T> const& t ) { return t.template get<U>(); }

template<typename T> constexpr auto size ( tuple<T> const& t ) { return T::size; }
  template<typename U, typename T> constexpr auto index ( tuple<T> const& t ) { return tlist_get_n< T, U >::value; }

template<typename T, int N>
  using element_t = tlist_get_t< typename T::type_list, N >;

template<typename T> struct luple_impl {
    using type = tuple<T>;
  };

template<typename... TT> struct luple_impl< type_list< type_list<TT...> > > {
    using type = typename luple_impl< type_list<TT...> >::type;
  };

template<typename... TT>
  using luple = typename luple_impl< type_list<TT...> >::type;

template<int... N, typename T0, typename T1>
  void luple_do_impl (std::integer_sequence<int, N...>, T0& t, T1 fn) {
    char dummy[]{ (fn( get<N>(t) ), char{})... };
    (void)dummy;
  }

template<typename T0, typename T1>
  void luple_do (T0& t, T1 fn) {
    luple_do_impl( std::make_integer_sequence< int, T0::type_list::size >{}, t, fn );
  }
  
}

using luple_ns::luple;
using luple_ns::get;
using luple_ns::index;

/*************  end of luple.h ***************/

/*************  type-loophole.h ***************/

/* 
  This header is for the Great Type Loophole.
  Source code with comments: https://github.com/alexpolt/luple/blob/master/type-loophole.h
*/

namespace loophole_ns {

template<typename T, int N>
  struct tag {
    friend auto loophole(tag<T,N>);
    constexpr friend int cloophole(tag<T,N>);
  };

template<typename T, typename U, int N, bool B>
  struct fn_def {
    friend auto loophole(tag<T,N>) { return U{}; }
    constexpr friend int cloophole(tag<T,N>) { return 0; }
  };

template<typename T, typename U, int N>
  struct fn_def<T, U, N, true> {};

template<typename T, int N>
  struct c_op {
    template<typename U, int M> static auto ins(...) -> int;
    template<typename U, int M, int = cloophole(tag<T,M>{}) > static auto ins(int) -> char;

template<typename U, int = sizeof(fn_def<T, U, N, sizeof(ins<U, N>(0)) == sizeof(char)>)>
    operator U();
  };

template<typename T, int... NN>
  constexpr int fields_number(...) { return sizeof...(NN)-1; }

template<typename T, int... NN>
  constexpr auto fields_number(int) -> decltype(T{ c_op<T,NN>{}... }, 0) {
    return fields_number<T, NN..., sizeof...(NN)>(0);
  }

template<typename T, typename U>
  struct loophole_type_list;

template<typename T, int... NN>
  struct loophole_type_list< T, std::integer_sequence<int, NN...> > {
    using type = luple_ns::type_list< decltype(loophole(tag<T, NN>{}))... >;
  };

template<typename T>
  using as_type_list =
    typename loophole_type_list<T, std::make_integer_sequence<int, fields_number<T>(0)>>::type;

}

struct test1 { 
  test1() { 
    printf("test::test()\n"); 
  } 
};

struct data { 
  test1 t0;  
  std::string t1; 
  std::vector<int> t2; 
};

int main() {

using data_tlist = loophole_ns::as_type_list< data >;

using data_luple = luple< data_tlist >;

data d{ {}, "Hello World!", {1,2,3} };

auto& l = reinterpret_cast< data_luple& >( d );

printf("%s\n", get<std::string>(l).data());

for (auto i : get<2>(l)) printf("%d, ",i);
  puts("");

luple_ns::element_t<data_luple,1>& str = get<1>(l);

str = "Welcome the the New World!";

printf("%s\n\n", str.data());

luple_do(l, [i=0] ( auto& value ) mutable { printf( "field %d: %s\n", i++, typeid(value).name() ); } );
}

Show compiler warnings [ + ] Compiler args [ + ] Show input
Compilation time: 0.52 sec, absolute running time: 0.06 sec, cpu time: 0.01 sec, memory peak: 3 Mb, absolute service time: 0,62 sec