Tuple.hh File Reference

#include <cstring>
#include <functional>
#include <tuple>
#include <type_traits>

Go to the source code of this file.

Classes
struct	PTL::SmallerThanT< Tp, Up >
struct	PTL::CTValue< Tp, Value >
class	PTL::TupleElt< Height, Tp, false >
class	PTL::TupleElt< Height, Tp, true >
class	PTL::Tuple< Head, Tail... >
class	PTL::Tuple<>
class	PTL::IsEmpty< List >
class	PTL::IsEmpty< Tuple<> >
class	PTL::PushBackT< Tuple< Elements... >, NewElement >
class	PTL::PopFrontT< std::tuple< Head, Tail... > >
class	PTL::PushFrontT< std::tuple< Types... >, Element >
struct	PTL::Valuelist< T, Values >
struct	PTL::Front< FrontT, Types... >
struct	PTL::Back< Types..., BackT >
class	PTL::TransformT< List, MetaFun, false >
class	PTL::TransformT< List, MetaFun, true >
class	PTL::TransformT< Tuple< Elements... >, MetaFun, false >
struct	PTL::ForwardTupleAsArgs< N >
struct	PTL::ForwardTupleAsArgs< 0 >
struct	PTL::ForEachTupleArg< N >
struct	PTL::tuple_subset< Args >
struct	PTL::transform_tuple< Head, Tail >
struct	PTL::transform_tuple< Head >

Namespaces
namespace	PTL

Typedefs
template<typename... Tp>
using	PTL::TypeList = Tuple< Tp... >
template<typename List , typename NewElement >
using	PTL::PushBack = typename PushBackT< List, NewElement >::Type
template<typename List >
using	PTL::PopFront = typename PopFrontT< List >::Type
template<typename List , typename NewElement >
using	PTL::PushFront = typename PushFrontT< List, NewElement >::Type
template<typename List , template< typename T > class MetaFun>
using	PTL::Transform = typename TransformT< List, MetaFun >::Type

Functions
template<unsigned H, typename T >
T &	PTL::get_height (TupleElt< H, T > &te)
template<unsigned I, typename... Elements>
auto	PTL::get (Tuple< Elements... > &t) -> decltype(get_height< sizeof...(Elements) - I - 1 >(t))
template<typename... Types, typename V >
PushFront< std::tuple< Types... >, V >	PTL::pushFront (std::tuple< Types... > const &tuple, V const &value)
template<typename Func , typename Tuple >
void	PTL::for_each_tuple_arg (Func &&func, Tuple &&_tuple)
template<typename Func , typename Tuple , std::size_t Head>
auto	PTL::InvokeSequence_impl (const Func &func, const Tuple &data)
template<typename Func , typename Tuple , std::size_t Head, std::size_t... Tail>
auto	PTL::InvokeSequence_impl (const Func &func, const Tuple &data)
template<typename Func , typename Tuple , std::size_t N = std::tuple_size<Tuple>::value, typename Indices = std::make_index_sequence<N>>
auto	PTL::InvokeSequence (const Func &func, const Tuple &data)
template<typename Container , std::size_t... N>
auto	PTL::ContainerToTuple_impl (const Container &tasks, std::index_sequence< N... >)
template<std::size_t N, typename Container , typename Indices = std::make_index_sequence<N>>
auto	PTL::ContainerToTuple (const Container &tasks)
template<typename Head >
void	PTL::tuple_transform (const std::function< void(const Head &)> &pred, const std::tuple< Head > &data)
template<typename Head , typename... Tail>
void	PTL::tuple_transform (const std::function< void(const Head &)> &pred, const std::tuple< Head, Tail... > &data)
template<typename Func , typename... Elements, unsigned... Indices>
auto	PTL::applyImpl (Func func, std::tuple< Elements... > const &t, Valuelist< unsigned, Indices... >) -> decltype(func(std::get< Indices >(t)...))
template<typename Func , typename... Elements, unsigned N = sizeof...(Elements)>
auto	PTL::apply (Func func, std::tuple< Elements... > const &t) -> decltype(applyImpl(func, t, std::make_index_sequence< N >()))