tuple.hh File Reference

#include <iostream>
#include <tuple>
#include <awali/utils/hash.hh>

Go to the source code of this file.

Data Structures
struct	awali::internal::and_< F1 >
struct	awali::internal::and_< F1, F... >
struct	awali::internal::and_<>
struct	awali::internal::concat< index_sequence< I1... >, index_sequence< I2... > >
struct	awali::internal::concat_index_sequence< index_sequence< I1... >, index_sequence< I2... > >
struct	std::concat_tuple< std::tuple< T1... >, std::tuple< T2... > >
struct	std::cons_tuple< T1, std::tuple< T2... > >
struct	std::cst_tuple< T, N >
struct	std::cst_tuple< T, 1u >
struct	awali::internal::eval_if< C, F1, F2 >
struct	awali::internal::eval_if_c< c, F1, F2 >
struct	std::hash< std::tuple< Elements... > >
struct	awali::internal::if_< C, T1, T2 >
struct	awali::internal::if_c< c, T1, T2 >
struct	awali::internal::if_c< false, T1, T2 >
struct	awali::internal::index_sequence<... >
struct	awali::internal::int_range< off, index_sequence< I... > >
struct	awali::internal::make_index_range< S, L >
struct	awali::internal::make_index_range< S, -1U >
struct	awali::internal::make_index_range< S, 0 >
struct	awali::internal::make_index_sequence< N >
struct	awali::internal::make_index_sequence< 0 >
struct	awali::internal::make_index_sequence< 1 >
struct	awali::internal::or_< F1 >
struct	awali::internal::or_< F1, F... >
struct	awali::internal::or_<>
struct	awali::internal::reverseseq< index_sequence< I1 > >
struct	awali::internal::reverseseq< index_sequence< I1, I2... > >
struct	awali::internal::seqconcat< index_sequence< I1... >, index_sequence< I2... > >
struct	awali::internal::tuple_printer< Tuple, N >
struct	awali::internal::tuple_printer< Tuple, 1 >

Namespaces
	awali
	Main namespace of Awali.
	awali::internal
	Namespace containing implementation details of elements common to sttc and dyn layers (not stable).

Typedefs
template<class S1 , class S2 >
using	awali::internal::Concat = typename concat< S1, S2 >::type
template<typename S1 , typename S2 >
using	awali::internal::concat_sequence = typename concat_index_sequence< S1, S2 >::type
template<std::size_t N>
using	awali::internal::GenSeq = typename make_index_sequence< N >::type

Functions
template<bool... B>
constexpr bool	awali::all_ ()
template<bool... B>
constexpr bool	awali::any_ ()
	Static evaluation of the 'or' of the template parameters. More...
template<typename Fun , typename... Ts>
void	awali::internal::for_ (const std::tuple< Ts... > &ts, Fun f)
template<typename Fun , typename... Ts, size_t... I>
void	awali::internal::for_ (Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >)
auto	awali::internal::make_inv_tuple () -> std::tuple<>
template<typename T , typename... Ts>
auto	awali::internal::make_inv_tuple (T t, Ts &&... ts) -> decltype(std::tuple_cat(make_inv_tuple(std::forward< Ts >(ts)...), std::make_tuple(t)))
template<typename... Ts>
auto	awali::internal::make_inv_tuple (Ts &&... ts) -> decltype(reverse_tuple(std::make_tuple(std::forward< Ts >(ts)...)))
template<typename Fun , typename... Ts>
auto	awali::internal::map (const std::tuple< Ts... > &ts, Fun f) -> decltype(map_tuple_(f, ts, make_index_sequence< sizeof...(Ts)>()))
	Map a function on a tuple, return tuple of the results. More...
template<typename Fun , typename... Ts, size_t... I>
auto	awali::internal::map_tuple_ (Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >) -> decltype(map_variadic_(f, std::get< I >(ts)...))
template<typename Fun , typename T , typename... Ts>
auto	awali::internal::map_variadic_ (Fun f, T t, Ts &&... ts) -> decltype(std::tuple_cat(std::make_tuple(f(t)), map_variadic_(f, ts...)))
template<typename Fun >
auto	awali::internal::map_variadic_ (Fun) -> decltype(std::make_tuple())
template<typename... Args>
std::ostream &	std::operator<< (std::ostream &o, const std::tuple< Args... > &args)
template<typename... Args>
std::ostream &	awali::internal::print (const std::tuple< Args... > &args, std::ostream &o)
template<typename... Ts>
auto	awali::internal::reverse_tuple (const std::tuple< Ts... > &t) -> decltype(reverse_tuple(t, make_index_sequence< sizeof...(Ts)>()))
template<typename... Ts, std::size_t... I>
auto	awali::internal::reverse_tuple (const std::tuple< Ts... > &t, index_sequence< I... >) -> decltype(std::make_tuple(std::get< sizeof...(Ts) - 1 - I >(t)...))

---

Data Structure Documentation

awali::internal::if_c

struct awali::internal::if_c

template<bool c, class T1, class T2>
struct awali::internal::if_c< c, T1, T2 >

Data Fields
typedef T1	type

awali::internal::if_c< false, T1, T2 >

struct awali::internal::if_c< false, T1, T2 >

template<class T1, class T2>
struct awali::internal::if_c< false, T1, T2 >

Data Fields
typedef T2	type

awali::internal::index_sequence

struct awali::internal::index_sequence

template<std::size_t...>
struct awali::internal::index_sequence<... >

Data Fields
typedef index_sequence	type

awali::internal::reverseseq< index_sequence< I1 > >

struct awali::internal::reverseseq< index_sequence< I1 > >

template<size_t I1>
struct awali::internal::reverseseq< index_sequence< I1 > >

Data Fields
typedef index_sequence< I1 >	type

awali::internal::reverseseq< index_sequence< I1, I2... > >

struct awali::internal::reverseseq< index_sequence< I1, I2... > >

template<size_t I1, size_t... I2>
struct awali::internal::reverseseq< index_sequence< I1, I2... > >

Data Fields
	type

Function Documentation

operator<<()

template<typename... Args>

std::ostream& std::operator<<	(	std::ostream &	o,
		const std::tuple< Args... > &	args
	)