brigand Namespace Reference

Namespaces
	detail
	lazy

Classes
struct	_1
struct	_2
struct	always
struct	and_
struct	args
struct	bind
struct	bitand_
struct	bitor_
struct	bitxor_
struct	complement
struct	defer
struct	divides
struct	double_
struct	empty_base
struct	equal_to
struct	eval_if
struct	eval_if_c
struct	greater
struct	greater_equal
struct	has_type
struct	identity
struct	if_
struct	if_c
struct	inherit
struct	inherit< empty_base >
struct	inherit< empty_base, empty_base >
struct	inherit< empty_base, T2 >
struct	inherit< T >
struct	inherit< T1, empty_base >
struct	inherit< T1, T2 >
struct	inherit< T1, T2, T3, Ts... >
struct	inherit<>
struct	less
struct	less_equal
struct	list
struct	make_integral
struct	max
struct	min
struct	minus
struct	modulo
struct	negate
struct	next
struct	no_such_type_
struct	not_
struct	not_equal_to
struct	or_
struct	pair
struct	pair_wrapper_
struct	pair_wrapper_< T, U >
struct	parent
struct	pin
struct	plus
struct	prev
struct	real_
struct	shift_left
struct	shift_right
struct	single_
struct	sizeof_
struct	times
struct	type_
struct	xor_

Typedefs
template<typename T , T... Values>
using	integral_list = brigand::list< std::integral_constant< T, Values >... >
using	empty_sequence = brigand::list<>
template<class A , template< class... > class B>
using	wrap = typename lazy::wrap< A, B >::type
template<typename... Ts>
using	append = typename detail::append_impl< Ts... >::type
template<typename T >
using	join = wrap< T, append >
template<typename T >
using	type_from = typename T::type
template<typename M , typename K >
using	lookup = typename lazy::lookup< M, K >::type
template<class... Ts>
using	map = typename detail::make_map< Ts... >::type
template<class T , std::size_t N, template< class... > class List = list>
using	filled_list = typename detail::filled_list_impl< T, List, N >::type
template<class L , std::size_t Index>
using	at_c = typename detail::at_impl< Index, L >::type
template<class Seq , typename K >
using	at = typename detail::at_dispatch< Seq, K, detail::has_at_method< Seq >::value >::type
using	_3 = args< 2 >
using	_4 = args< 3 >
using	_5 = args< 4 >
using	_6 = args< 5 >
using	_7 = args< 6 >
using	_8 = args< 7 >
using	_9 = args< 8 >
using	_state = _1
using	_element = _2
template<typename Lambda , typename... Args>
using	apply = typename detail::apply< Lambda, brigand::list< Args... > >::type
template<typename T , typename List >
using	substitute = typename detail::substitute_impl< T, List >::type
template<std::int8_t V>
using	int8_t = std::integral_constant< std::int8_t, V >
template<std::uint8_t V>
using	uint8_t = std::integral_constant< std::uint8_t, V >
template<std::int16_t V>
using	int16_t = std::integral_constant< std::int16_t, V >
template<std::uint16_t V>
using	uint16_t = std::integral_constant< std::uint16_t, V >
template<std::int32_t V>
using	int32_t = std::integral_constant< std::int32_t, V >
template<std::uint32_t V>
using	uint32_t = std::integral_constant< std::uint32_t, V >
template<std::int64_t V>
using	int64_t = std::integral_constant< std::int64_t, V >
template<std::uint64_t V>
using	uint64_t = std::integral_constant< std::uint64_t, V >
template<std::size_t V>
using	size_t = std::integral_constant< std::size_t, V >
template<std::ptrdiff_t V>
using	ptrdiff_t = std::integral_constant< std::ptrdiff_t, V >
template<typename List , typename Pred >
using	count_if = typename lazy::count_if< List, Pred >::type
template<class... T>
using	count = std::integral_constant< std::size_t, sizeof...(T)>
template<class L >
using	size = wrap< L, count >
template<class L , class... T>
using	push_front = typename detail::push_front_impl< L, T... >::type
template<class L >
using	front = typename detail::front_impl< L >::type
template<class L , class N = std::integral_constant<std::size_t, 1>>
using	pop_front = typename detail::pop_front_impl< L, N::value >::type
template<class L >
using	clear = typename detail::clear_impl< L >::type
template<typename L , typename I >
using	split_at = typename ::brigand::lazy::split_at< L, I >::type
template<class L , class... T>
using	push_back = typename detail::push_back_impl< L, T... >::type
template<class L >
using	back = at_c< L, size< L >::value-1 >
template<class L , class N = std::integral_constant<std::size_t, 1>>
using	pop_back = front< split_at< L, std::integral_constant< std::size_t, size< L >::value - N::value > >>
template<typename Sequence1 , typename OpSeq1 , typename... OpSeq2>
using	transform = typename detail::transform< sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2... >::type
template<typename L >
using	as_integral_list = transform< L, make_integral< brigand::_1 > >
template<typename L , template< class... > class Sequence>
using	as_sequence = typename detail::as_sequence_impl< L, Sequence >::type
template<typename L >
using	as_list = as_sequence< L, brigand::list >
template<typename... T>
using	pair_wrapper = typename pair_wrapper_< T... >::type
template<typename L >
using	as_pair = wrap< L, pair_wrapper >
template<typename... T>
using	tuple_wrapper = typename std::tuple< T... >
template<typename L >
using	as_tuple = wrap< L, tuple_wrapper >
template<bool B>
using	bool_ = std::integral_constant< bool, B >
template<typename Sequence , typename Predicate = detail::non_null>
using	all = typename detail::all_impl< Sequence, Predicate >::type
template<typename Sequence , typename Predicate = detail::non_null>
using	none = typename detail::none_impl< Sequence, Predicate >::type
template<typename Sequence , typename Predicate = detail::non_null>
using	any = typename detail::any_impl< Sequence, Predicate >::type
template<typename L >
using	reverse = typename detail::reverse_impl< L >::type
template<typename Sequence , typename Predicate = brigand::detail::non_null>
using	find = typename lazy::find< Sequence, Predicate >::type
template<typename Sequence , typename Predicate = detail::non_null>
using	reverse_find = typename ::brigand::lazy::reverse_find< Sequence, Predicate >::type
template<typename Sequence , typename Predicate = detail::non_null>
using	not_found = typename detail::empty_find< Sequence, Predicate >
template<typename Sequence , typename Predicate = detail::non_null>
using	found = typename detail::non_empty_find< Sequence, Predicate >
template<typename Sequence >
using	flatten = typename lazy::flatten< Sequence >::type
template<class Sequence , class State , class Functor >
using	fold = typename ::brigand::lazy::fold< Sequence, State, Functor >::type
template<class Sequence , class State , class Functor >
using	reverse_fold = typename ::brigand::lazy::reverse_fold< Sequence, State, Functor >::type
template<class Sequence , class Predicate , class NotFoundType = no_such_type_>
using	index_if = typename detail::index_if_impl<::brigand::found< Sequence, Predicate >::value, Sequence, Predicate, NotFoundType >::type
template<class Sequence , typename T >
using	index_of = index_if< Sequence, std::is_same< T, ::brigand::_1 > >
template<class T , T Start, T Stop>
using	range = typename detail::range_impl< T, Start, Stop-Start >::type
template<class T , T Start, T Stop>
using	reverse_range = typename detail::reverse_range_safe< T, Start, Stop >::type
template<class... Ts>
using	is_set = typename detail::is_set_impl< range< int, 0, sizeof...(Ts)>, Ts... >::type
template<typename L , typename Pred >
using	remove_if = typename lazy::remove_if< L, Pred >::type
template<typename L , typename T >
using	remove = typename lazy::remove< L, T >::type
template<typename L , typename Pred >
using	filter = typename lazy::filter< L, Pred >::type
template<class Seq , class Pred >
using	partition = pair< filter< Seq, Pred >, remove_if< Seq, Pred > >
template<typename Sequence , typename Predicate , typename NewType >
using	replace_if = typename ::brigand::lazy::replace_if< Sequence, Predicate, NewType >::type
template<typename Sequence , typename OldType , typename NewType >
using	replace = typename ::brigand::lazy::replace< Sequence, OldType, NewType >::type
template<typename TList , typename TDelim >
using	split = typename lazy::split< TList, TDelim >::type
template<class Seq1 , class Seq2 , class Comp = less<_1,_2>>
using	merge = append< clear< Seq1 >, typename detail::merge_impl< list<>, wrap< Seq1, list >, wrap< Seq2, list >, Comp >::type >
template<class Seq , class Comp = less<_1,_2>>
using	sort = append< clear< Seq >, typename detail::sort_impl< list<>, wrap< Seq, list >, Comp >::type >
template<template< class > class F, class N , class T >
using	repeat = typename ::brigand::lazy::repeat< F, N, T >::type
template<class L , class K >
using	has_key = typename detail::has_key_impl< L, K >::type
template<class Start , unsigned N, class Next = next<_1>, template< class... > class List = list>
using	make_sequence = typename detail::make_sequence_impl< List, Start, N, Next,(N<=8)>::type
template<class L , std::size_t Index>
using	erase_c = append< front< split_at< L, size_t< Index > >>, pop_front< back< split_at< L, size_t< Index > >> > >
template<class L , class K >
using	erase = typename detail::erase_dispatch< L, K, detail::has_erase_method< L >::value >::type
template<class L , class T >
using	insert = typename detail::insert_impl< L, T >::type
template<class L , class K >
using	contains = typename detail::contains_impl< L, K >::type
template<class... Ts>
using	set = typename detail::make_set< Ts... >::type
template<typename Map , template< class... > class Sequence = brigand::list>
using	values_as_sequence = transform< as_sequence< Map, Sequence >, detail::get_second< _1 > >
template<typename Map , template< class... > class Sequence = brigand::set>
using	keys_as_sequence = transform< as_sequence< Map, Sequence >, detail::get_first< _1 > >
template<typename Types , typename Node , typename Root = brigand::empty_base>
using	inherit_linearly = typename lazy::inherit_linearly< Types, Node, Root >::type

Functions
template<class F , class... Ts>
F	for_each_args (F f, Ts &&...a)
template<typename List , typename Functor >
Functor	for_each (Functor f)
template<typename C , typename T , typename F >
std::enable_if< C::value, T && >::type	select (T &&t, F &&)
template<typename C , typename T , typename F >
std::enable_if<!C::value, F && >::type	select (T &&, F &&f)

Typedef Documentation

_3

typedef args< 2 > brigand::_3

_4

typedef args< 3 > brigand::_4

_5

typedef args< 4 > brigand::_5

_6

typedef args< 5 > brigand::_6

_7

typedef args< 6 > brigand::_7

_8

typedef args< 7 > brigand::_8

_9

typedef args< 8 > brigand::_9

_element

typedef _2 brigand::_element

_state

typedef _1 brigand::_state

all

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::all = typedef typename detail::all_impl<Sequence, Predicate>::type

any

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::any = typedef typename detail::any_impl<Sequence,Predicate>::type

append

template<typename... Ts>

using brigand::append = typedef typename detail::append_impl<Ts...>::type

apply

template<typename Lambda , typename... Args>

using brigand::apply = typedef typename detail::apply<Lambda, brigand::list<Args...> >::type

as_integral_list

template<typename L >

using brigand::as_integral_list = typedef transform<L, make_integral<brigand::_1> >

as_list

template<typename L >

using brigand::as_list = typedef as_sequence<L, brigand::list>

as_pair

template<typename L >

using brigand::as_pair = typedef wrap<L, pair_wrapper>

as_sequence

template<typename L , template< class... > class Sequence>

using brigand::as_sequence = typedef typename detail::as_sequence_impl<L, Sequence>::type

as_tuple

template<typename L >

using brigand::as_tuple = typedef wrap<L, tuple_wrapper>

at

template<class Seq , typename K >

using brigand::at = typedef typename detail::at_dispatch<Seq, K, detail::has_at_method<Seq>::value>::type

at_c

template<class L , std::size_t Index>

using brigand::at_c = typedef typename detail::at_impl<Index, L>::type

back

template<class L >

using brigand::back = typedef at_c<L, size<L>::value-1>

bool_

template<bool B>

using brigand::bool_ = typedef std::integral_constant<bool, B>

clear

template<class L >

using brigand::clear = typedef typename detail::clear_impl<L>::type

contains

template<class L , class K >

using brigand::contains = typedef typename detail::contains_impl<L, K>::type

count

template<class... T>

using brigand::count = typedef std::integral_constant<std::size_t, sizeof...(T)>

count_if

template<typename List , typename Pred >

using brigand::count_if = typedef typename lazy::count_if<List, Pred>::type

empty_sequence

typedef brigand::list<> brigand::empty_sequence

erase

template<class L , class K >

using brigand::erase = typedef typename detail::erase_dispatch<L, K, detail::has_erase_method<L>::value>::type

erase_c

template<class L , std::size_t Index>

using brigand::erase_c = typedef append< front<split_at<L, size_t<Index> >>, pop_front<back<split_at<L, size_t<Index> >> > >

filled_list

template<class T , std::size_t N, template< class... > class List = list>

using brigand::filled_list = typedef typename detail::filled_list_impl<T, List, N>::type

filter

template<typename L , typename Pred >

using brigand::filter = typedef typename lazy::filter<L, Pred>::type

find

template<typename Sequence , typename Predicate = brigand::detail::non_null>

using brigand::find = typedef typename lazy::find<Sequence, Predicate>::type

flatten

template<typename Sequence >

using brigand::flatten = typedef typename lazy::flatten<Sequence>::type

fold

template<class Sequence , class State , class Functor >

using brigand::fold = typedef typename ::brigand::lazy::fold<Sequence, State, Functor>::type

found

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::found = typedef typename detail::non_empty_find<Sequence, Predicate>

front

template<class L >

using brigand::front = typedef typename detail::front_impl<L>::type

has_key

template<class L , class K >

using brigand::has_key = typedef typename detail::has_key_impl<L, K>::type

index_if

template<class Sequence , class Predicate , class NotFoundType = no_such_type_>

using brigand::index_if = typedef typename detail::index_if_impl<::brigand::found<Sequence, Predicate>::value, Sequence, Predicate, NotFoundType>::type

index_of

template<class Sequence , typename T >

using brigand::index_of = typedef index_if<Sequence, std::is_same<T, ::brigand::_1> >

inherit_linearly

template<typename Types , typename Node , typename Root = brigand::empty_base>

using brigand::inherit_linearly = typedef typename lazy::inherit_linearly<Types,Node,Root>::type

insert

template<class L , class T >

using brigand::insert = typedef typename detail::insert_impl<L, T>::type

int16_t

template<std::int16_t V>

using brigand::int16_t = typedef std::integral_constant<std::int16_t, V>

int32_t

template<std::int32_t V>

using brigand::int32_t = typedef std::integral_constant<std::int32_t, V>

int64_t

template<std::int64_t V>

using brigand::int64_t = typedef std::integral_constant<std::int64_t, V>

int8_t

template<std::int8_t V>

using brigand::int8_t = typedef std::integral_constant<std::int8_t, V>

integral_list

template<typename T , T... Values>

using brigand::integral_list = typedef brigand::list< std::integral_constant<T,Values>...>

is_set

template<class... Ts>

using brigand::is_set = typedef typename detail::is_set_impl<range<int, 0, sizeof...(Ts)>, Ts...>::type

join

template<typename T >

using brigand::join = typedef wrap<T,append>

keys_as_sequence

template<typename Map , template< class... > class Sequence = brigand::set>

using brigand::keys_as_sequence = typedef transform<as_sequence<Map, Sequence>, detail::get_first<_1> >

lookup

template<typename M , typename K >

using brigand::lookup = typedef typename lazy::lookup<M,K>::type

make_sequence

template<class Start , unsigned N, class Next = next<_1>, template< class... > class List = list>

using brigand::make_sequence = typedef typename detail::make_sequence_impl<List, Start, N, Next, (N<=8)>::type

map

template<class... Ts>

using brigand::map = typedef typename detail::make_map<Ts...>::type

merge

template<class Seq1 , class Seq2 , class Comp = less<_1,_2>>

using brigand::merge = typedef append<clear<Seq1>, typename detail::merge_impl<list<>, wrap<Seq1, list>, wrap<Seq2, list>, Comp>::type>

none

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::none = typedef typename detail::none_impl<Sequence,Predicate>::type

not_found

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::not_found = typedef typename detail::empty_find<Sequence, Predicate>

pair_wrapper

template<typename... T>

using brigand::pair_wrapper = typedef typename pair_wrapper_<T...>::type

partition

template<class Seq , class Pred >

using brigand::partition = typedef pair<filter<Seq, Pred>, remove_if<Seq, Pred> >

pop_back

template<class L , class N = std::integral_constant<std::size_t, 1>>

using brigand::pop_back = typedef front<split_at<L, std::integral_constant<std::size_t, size<L>::value - N::value> >>

pop_front

template<class L , class N = std::integral_constant<std::size_t, 1>>

using brigand::pop_front = typedef typename detail::pop_front_impl<L, N::value>::type

ptrdiff_t

template<std::ptrdiff_t V>

using brigand::ptrdiff_t = typedef std::integral_constant<std::ptrdiff_t, V>

push_back

template<class L , class... T>

using brigand::push_back = typedef typename detail::push_back_impl<L, T...>::type

push_front

template<class L , class... T>

using brigand::push_front = typedef typename detail::push_front_impl<L, T...>::type

range

template<class T , T Start, T Stop>

using brigand::range = typedef typename detail::range_impl<T, Start, Stop-Start>::type

remove

template<typename L , typename T >

using brigand::remove = typedef typename lazy::remove<L, T>::type

remove_if

template<typename L , typename Pred >

using brigand::remove_if = typedef typename lazy::remove_if<L, Pred>::type

repeat

template<template< class > class F, class N , class T >

using brigand::repeat = typedef typename ::brigand::lazy::repeat<F, N, T>::type

replace

template<typename Sequence , typename OldType , typename NewType >

using brigand::replace = typedef typename ::brigand::lazy::replace<Sequence, OldType, NewType>::type

replace_if

template<typename Sequence , typename Predicate , typename NewType >

using brigand::replace_if = typedef typename ::brigand::lazy::replace_if<Sequence, Predicate, NewType>::type

reverse

template<typename L >

using brigand::reverse = typedef typename detail::reverse_impl<L>::type

reverse_find

template<typename Sequence , typename Predicate = detail::non_null>

using brigand::reverse_find = typedef typename ::brigand::lazy::reverse_find<Sequence, Predicate>::type

reverse_fold

template<class Sequence , class State , class Functor >

using brigand::reverse_fold = typedef typename ::brigand::lazy::reverse_fold<Sequence, State, Functor>::type

reverse_range

template<class T , T Start, T Stop>

using brigand::reverse_range = typedef typename detail::reverse_range_safe<T, Start, Stop>::type

set

template<class... Ts>

using brigand::set = typedef typename detail::make_set<Ts...>::type

size

template<class L >

using brigand::size = typedef wrap<L, count>

size_t

template<std::size_t V>

using brigand::size_t = typedef std::integral_constant<std::size_t, V>

sort

template<class Seq , class Comp = less<_1,_2>>

using brigand::sort = typedef append<clear<Seq>, typename detail::sort_impl<list<>, wrap<Seq, list>, Comp>::type>

split

template<typename TList , typename TDelim >

using brigand::split = typedef typename lazy::split<TList, TDelim>::type

split_at

template<typename L , typename I >

using brigand::split_at = typedef typename ::brigand::lazy::split_at<L, I>::type

substitute

template<typename T , typename List >

using brigand::substitute = typedef typename detail::substitute_impl<T,List>::type

transform

template<typename Sequence1 , typename OpSeq1 , typename... OpSeq2>

using brigand::transform = typedef typename detail::transform<sizeof...(OpSeq2), Sequence1, OpSeq1, OpSeq2...>::type

tuple_wrapper

template<typename... T>

using brigand::tuple_wrapper = typedef typename std::tuple<T...>

type_from

template<typename T >

using brigand::type_from = typedef typename T::type

uint16_t

template<std::uint16_t V>

using brigand::uint16_t = typedef std::integral_constant<std::uint16_t, V>

uint32_t

template<std::uint32_t V>

using brigand::uint32_t = typedef std::integral_constant<std::uint32_t, V>

uint64_t

template<std::uint64_t V>

using brigand::uint64_t = typedef std::integral_constant<std::uint64_t, V>

uint8_t

template<std::uint8_t V>

using brigand::uint8_t = typedef std::integral_constant<std::uint8_t, V>

values_as_sequence

template<typename Map , template< class... > class Sequence = brigand::list>

using brigand::values_as_sequence = typedef transform<as_sequence<Map, Sequence>, detail::get_second<_1> >

wrap

template<class A , template< class... > class B>

using brigand::wrap = typedef typename lazy::wrap<A, B>::type

Function Documentation

for_each()

template<typename List , typename Functor >

Functor brigand::for_each

(

Functor

f

)

for_each_args()

template<class F , class... Ts>

F brigand::for_each_args	(	F	f,
		Ts &&...	a
	)

select() [1/2]

template<typename C , typename T , typename F >

std::enable_if< C::value, T && >::type brigand::select ( T &&  t, F &&    )

inline

select() [2/2]

template<typename C , typename T , typename F >

std::enable_if<!C::value, F && >::type brigand::select ( T &&  , F &&  f  )

inline