/*
The Great Type Loophole
This example is part of the blog post http://a...content-available-to-author-only...b.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://g...content-available-to-author-only...b.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://g...content-available-to-author-only...b.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 ( ) ) ; } ) ;
}
/*
  The Great Type Loophole

  This example is part of the blog post http://a...content-available-to-author-only...b.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://g...content-available-to-author-only...b.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://g...content-available-to-author-only...b.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() ); } );
}

