#include <cstdio>

//Comment this to use ref_holder
//instead of std::tr1::tuple 
//to pack argument references
#define USE_TUPLE

#ifdef USE_TUPLE
#include <tr1/tuple>
#endif

//forward declaration of function "func"
//simulates an #include<>
template<class ...Args>
void func(Args && ...args);

////////////////////////////////////////////////////
//       Move and forward implementation
////////////////////////////////////////////////////
template<class T>
struct remove_reference
{  typedef T type;   };

template<class T>
struct remove_reference<T&>
{  typedef T type;   };

// identity is an extension: it is not part of the standard.
template <class T>
struct identity 
{  typedef T type;   };

template <class T>
inline typename remove_reference<T>::type&& move_impl(T&& t)
{  return t;   }

template <class T>
inline T&& forward_impl(typename identity<T>::type&& t)
{  return t;   }


#ifndef USE_TUPLE

////////////////////////////////////////////////////
// ref_holder is a class that packs the arguments
// forwarded to a variadic function
//
// ref_holder<Args...> behaves similart to tuple<Args&&...>
////////////////////////////////////////////////////

template<typename... Args> 
class ref_holder;

//This is the implementation of the holder
template<int Idx, typename... Args>
struct ref_holder_impl; 

template<int Idx>
struct ref_holder_impl<Idx>
{};

template<int Idx, typename Head, typename... Tail>
struct ref_holder_impl<Idx, Head, Tail...>
   : public ref_holder_impl<Idx + 1, Tail...>
{
   typedef ref_holder_impl<Idx + 1, Tail...> Base;
   Head &&head_;

   explicit ref_holder_impl(Head &&head, Tail&&... tail)
      : Base(tail...), head_(head)
   {}
};

template<typename... Args> 
class ref_holder : public ref_holder_impl<0, Args...>
{
   typedef ref_holder_impl<0, Args...> Base;

   public:
   ref_holder() : Base()
   {}

   explicit ref_holder(Args&&... args) : Base(args...)
   {}
};

template<>
class ref_holder<>
{};

///////////////////////////////////////
// Returns the type of the ith reference
// Similar to get<> function of tuples
///////////////////////////////////////
template<int i, typename T>
struct get_ref_type;

template<int i, typename Head, typename... Tail>
struct get_ref_type<i, ref_holder<Head, Tail...> >
   : get_ref_type<i - 1, ref_holder<Tail...> >
{};

template<typename Head, typename... Tail>
struct get_ref_type<0, ref_holder<Head, Tail...> >
{  typedef Head&& type; };

template<int i, typename Head, typename... Tail>
inline Head &&get_ref_impl(ref_holder_impl<i, Head, Tail...>& t)
{  return t.head_;   }

template<int i, typename Head, typename... Tail>
inline Head &&get_ref_impl(const ref_holder_impl<i, Head, Tail...>& t)
{  return t.head_;   }

template<int i, typename... Args>
inline typename get_ref_type<i, ref_holder<Args...> >::type
get_ref(ref_holder<Args...>& t)
{  return get_ref_impl<i>(t);  }

template<int i, typename... Args>
inline typename get_ref_type<i, ref_holder<Args...> >::type
get_ref(const ref_holder<Args...>& t)
{  return get_ref_impl<i>(t);  }

#endif   //#ifndef USE_TUPLE

////////////////////////////////////////////////////
// Builds an index_tuple<0, 1, 2, ..., Num-1>, that will
// be used to "unpack" a ref_holder into comma-separated values
// in a function call. See "forward_obj::operator()()"
////////////////////////////////////////////////////

template<int... Indexes>
struct index_tuple{};

template<std::size_t Num, typename Tuple = index_tuple<> >
struct build_number_seq;

template<std::size_t Num, int... Indexes> 
struct build_number_seq<Num, index_tuple<Indexes...> >
   : build_number_seq<Num - 1, index_tuple<Indexes..., sizeof...(Indexes)> >
{};

template<int... Indexes>
struct build_number_seq<0, index_tuple<Indexes...> >
{  typedef index_tuple<Indexes...> type;  };

////////////////////////////////////////////////////
// Implementation of the variadic func
// This function prints if passed references are
// rvalue or rvalue references
////////////////////////////////////////////////////

//This function creates a functor (forward_obj) that perfectly
//forwards all parameters to the variadic function "func()"
template<class ...Args>
class forward_obj
{
   public:
   forward_obj(Args&&... args)
      : args_(args...)
   {}

   void operator()()
   {
      //Pass Indexes as an argument so that "call" can get_ref
      //a variadic list of integers as template arguments
      this->call(typename build_number_seq<sizeof...(Args)>::type());
   }

   template<int ...IdxPack>
   void call(const index_tuple<IdxPack...>&)
   {
      //Use the the variadic list of integers to get a
      //comma-separated list of parameters
      #ifdef USE_TUPLE
      func(forward_impl<Args>(std::tr1::get<IdxPack>(args_))...);
      #else
      func(forward_impl<Args>(get_ref<IdxPack>(args_))...);
      #endif
   }

   private:
      #ifdef USE_TUPLE
      std::tr1::tuple<Args&&...> args_;
      #else
      ref_holder<Args...> args_;
      #endif
};

///////////////////////////////////////////////////////////////
// This function creates a functor (forward_obj) that perfectly
// forwards all parameters to the variadic function "func()"
///////////////////////////////////////////////////////////////
template<class ...Args>
forward_obj<Args...> forward_func(Args && ...args)
{  return forward_obj<Args...>(forward_impl<Args>(args)...);   }

////////////////////////////////////////////////////
// Implementation of the variadic function "func"
// This function prints if passed references are
// rvalue or lvalue references
////////////////////////////////////////////////////
template<class T>
struct print_rvalue_or_lvalue;

template<class T>
struct print_rvalue_or_lvalue<T&&>
{  void operator()() {  std::printf("rvalue, ");   }  };

template<class T>
struct print_rvalue_or_lvalue<T&>
{  void operator()() {  std::printf("lvalue, ");   }  };

template<class T>
struct print_rvalue_or_lvalue<const T&>
{  void operator()() {  std::printf("clvalue, ");  }  };

//Recursive print object function
template<class ...Args>
struct print;

template<class Head, class ...Tail>
struct print<Head, Tail...>
{
   void operator()()
   {
      print_rvalue_or_lvalue<Head&&>()();
      print<Tail...>()();
   }
};

template<>
struct print<>
{  void operator()() {  std::printf("END\n");   }  };

template<class ...Args>
void func(Args && ...args)
{  print<Args...>()();  }

////////////////////////////////////////////////////
// Non-copyable and non-movable class
////////////////////////////////////////////////////
class non_copyable_non_movable
{
   non_copyable_non_movable(const non_copyable_non_movable&);
   non_copyable_non_movable(non_copyable_non_movable&&);
   non_copyable_non_movable & operator=(const non_copyable_non_movable&);
   non_copyable_non_movable & operator=(non_copyable_non_movable&&);
   public:
   non_copyable_non_movable(){}
};

////////////////////////////////////////////////////
//       Test
////////////////////////////////////////////////////
int main()
{
   /* This should print:
      END
      lvalue, END
      clvalue, END
      rvalue, END
      rvalue, lvalue, clvalue, END
      lvalue, clvalue, rvalue, END
   */
   non_copyable_non_movable a;
   const non_copyable_non_movable ca;
   forward_func()();
   forward_func(a)();
   forward_func(ca)();
   forward_func(move_impl(a))();
   forward_func(move_impl(a), a, ca)();
   forward_func(a, ca, move_impl(a))();
   return 0;
}