Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 123]

Ctinympl::all_of< Sequence, F >	Determines whether every element in the sequence satisfies the given predicate
Ctinympl::variadic::all_of< F, Args >	Determines whether every element in the sequence satisfies the given predicate
Ctinympl::variadic::all_of< F, Args...>
Ctinympl::variadic::any_of< F, Args >	Determines whether any of the elements in the sequence satisfy the given predicate
Ctinympl::any_of< Sequence, F >	Determines whether any of the elements in the sequence satisfy the given predicate
Ctinympl::variadic::any_of< F, Args...>
Ctinympl::apply< F, Args >	Return the result type of the metafunction class F called with arguments Args.,,
Ctinympl::as_sequence< T >	Provide a customization points by allowing the user to specialize this class
Ctinympl::as_sequence< basic_string< T, ts...> >	Customization point to allow basic_string to work as a tinympl sequence
Ctinympl::as_sequence< Seq< Args...> >	Customization point to allow any variadic template type to work with tinympl
Ctinympl::as_sequence< vector< Args...> >	Customization point to allow vector to work as a tinympl sequence
Ctinympl::vector< Args >::at< i >	Access the i-th element
Ctinympl::value_map< KeyType, ValueType, Args >::at< k >	Return the value element with the given key
Ctinympl::at< I, Sequence >	Get the i-th element of a sequence
Ctinympl::map< Args >::at< T >	Return the value element with the given key
Ctinympl::variadic::at< i, Args >	Extract the i-th element of a variadic template
Ctinympl::variadic::at< I, Args...>
Ctinympl::vector< Args >::back	Return the last element of the vector
Ctinympl::basic_string< T, chars >	A vector of values of type T
Ctinympl::bind< F, Args >	Produce a template type by binding the given arguments on the passed template template
Ctinympl::variadic::copy< Out, Args >	Copy the elements from the input sequence to the output sequence
Ctinympl::copy< SequenceIn, Out >	Copy the elements from the input sequence to the output sequence
Ctinympl::variadic::copy< Out, Args...>
Ctinympl::copy_if< SequenceIn, F, Out >	Copy the elements of a given input sequence which satisfy a given predicate - the ordering is preserved
Ctinympl::variadic::copy_if< F, Out, Args >	Copy the elements of a given input sequence which satisfy a given predicate - the ordering is preserved
►Ctinympl::variadic::copy_if< bind< logical_not, bind< bind< equal_to, arg1, T >::template eval_t, arg1 > >::template eval, Out, Args...>
►Ctinympl::variadic::remove_if< bind< equal_to, arg1, T >::template eval_t, Out, Args...>
Ctinympl::variadic::remove< T, Out, Args...>
Ctinympl::variadic::remove< T, Out, Args >	Remove all the elements equal to T from the input sequence
►Ctinympl::variadic::copy_if< bind< logical_not, bind< bind< variadic::count, arg1, Us...>::template eval_t, arg1 > >::template eval, Out, Args...>
Ctinympl::variadic::remove_if< bind< variadic::count, arg1, Us...>::template eval_t, Out, Ts...>
►Ctinympl::variadic::copy_if< bind< logical_not, bind< F, arg1 > >::template eval, Out, Args...>
Ctinympl::variadic::remove_if< F, Out, Args...>
Ctinympl::variadic::remove_if< F, Out, Args >	Remove the elements from the input sequence if they satisfy a given predicate
Ctinympl::variadic::copy_if< bind< variadic::count, arg1, Us...>::template eval_t, Out, Ts...>
Ctinympl::variadic::copy_if< F, Out, Args...>
Ctinympl::copy_n< SequenceIn, N, Out >	Copy the first N elements from the input sequence
Ctinympl::variadic::copy_n< n, Out, Args >	Copy the first n elements from the input sequence
Ctinympl::variadic::copy_n< N, Out, Args...>
Ctinympl::count< Sequence, T >	Counts the number of elements in a sequence equal to a given one
Ctinympl::count_if< Sequence, F >	Counts the number of elements which satisfy a given predicate
Ctinympl::variadic::count_if< F, Args >	Counts the number of elements which satisfy a given predicate
►Ctinympl::variadic::count_if< bind< equal_to, arg1, T >::template eval_t, Args... >
Ctinympl::variadic::count< T, Args...>
Ctinympl::variadic::count< T, Args >	Counts the number of elements in a sequence equal to a given one
Ctinympl::variadic::count_if< F, Args...>
Ctinympl::divides< A, B >	Computes A/B where A and B are compile time constants
Ctinympl::equal_to< A, B >	Determines whether the types A and B are equal
Ctinympl::erase< First, Last, Seq, Out >	Remove a range in a given sequence
Ctinympl::value_map< KeyType, ValueType, Args >::erase< k >	Return a new map constructed by the current map removing the k key, if present, otherwise return the current map
Ctinympl::map< Args >::erase< Key >	Return a new map constructed by the current map removing the Key key, if present, otherwise return the current map
Ctinympl::variadic::erase< start, end, Out, Args >	Produce an output sequence from a variadic template by removin the elements in the given range
Ctinympl::variadic::erase< First, Last, Out, Args...>
►Ctinympl::erase< first, last, vector< Args...>, tinympl::vector >
Ctinympl::vector< Args >::erase< first, last >	Return a new vector constructed by erasing the elements in the range [first,last) of the current vector
Ctinympl::variadic::fill_n< n, T, Out >	Fills an output sequence with n equal elements
►Ctinympl::variadic::fill_n< N, T, Out >
Ctinympl::fill_n< N, T, Out >	Fills an output sequence with N equal elements
Ctinympl::find< Sequence, T >	Compute the index of the first element in the sequence which is equal to the given type T
Ctinympl::find_if< Sequence, F >
Ctinympl::variadic::find_if< F, Args >
►Ctinympl::variadic::find_if< bind< equal_to, arg1, T >::template eval_t, Args... >
Ctinympl::variadic::find< T, Args...>
Ctinympl::variadic::find< T, Args >	Compute the index of the first element in the sequence which is equal to the given type T
Ctinympl::variadic::find_if< F, Args...>
Ctinympl::vector< Args >::front	Return the first element of the vector
Ctinympl::variadic::generate_n< n, Gen, Out >	Generate n elements using a given generator metafunction
►Ctinympl::variadic::generate_n< N, Gen, Out >
Ctinympl::generate_n< N, Gen, Out >	Generate N elements using a given generator metafunction
Ctinympl::identity< T >	Returns the argument passed
Ctinympl::if_< C, A, B >	Returns A if C::value is true, otherwise B
Ctinympl::inherit< Args >	Construct a type inherited from the arguments
Ctinympl::value_map< KeyType, ValueType, Args >::insert< k, v >	Returns a new map with the new Key/Value pair, or this map if the key is already present in the map
Ctinympl::map< Args >::insert< Key, Value >	Returns a new map with the new Key/Value pair, or this map if the key is already present in the map
Ctinympl::insert< Pos, SubSeq, Seq, Out >	Insert a subsequence into a given sequence at a given position
Ctinympl::variadic::insert< pos, T, Out, Args >	Produce an output sequence from a variadic template inserting a new element at a given position
►Ctinympl::insert< i, sequence< Ts...>, vector< Args...>, tinympl::vector >
Ctinympl::vector< Args >::insert< i, Ts >	Return a new vector constructed by inserting the elements Ts... in the current vector starting at the index i
Ctinympl::value_map< KeyType, ValueType, Args >::insert_many< KeyValuePairs >	Calls insert many times to insert many Key/Value pairs
Ctinympl::map< Args >::insert_many< KeyValuePairs >	Calls insert many times to insert many Key/Value pairs
Ctinympl::is_bind_expression< T >	Determine whether a type is a bind expression
Ctinympl::is_pair< T >	Determine whether a type is an std::pair
Ctinympl::is_placeholder< T >	Determine whether a type is a placeholder. is_placeholder<T>::value is 0 if T is not a placeholder, otherwise is the index of the placeholder
Ctinympl::is_sequence< T, class >	Metafunction to determine if a given type is a sequence
Ctinympl::is_unique< Sequence >	Determines whether the input sequence contains only unique elements
Ctinympl::variadic::is_unique< Args >	Determines whether the input sequence contains only unique elements
Ctinympl::variadic::is_unique< Args...>
Ctinympl::value_map< KeyType, ValueType, Args >::is_valid_key_type< T >	Determines whether T is a valid key type, i.e. std::integral_constant<KeyType,KeyValue>
Ctinympl::value_map< KeyType, ValueType, Args >::is_valid_value_type< T >	Determines whether T is a valid value type, i.e. std::integral_constant<ValueType,Value>
Ctinympl::join< Args >	Merge two sequences
Ctinympl::left_fold< Sequence, F >	Collapses a sequence starting from left using a functor
Ctinympl::variadic::left_fold< Op, Args >	Collapses a sequence starting from left using a functor
Ctinympl::variadic::left_fold< F, Ts...>
►Ctinympl::left_fold< Seq, F >
Ctinympl::accumulate< Seq, F >	Alias for left_fold
Ctinympl::less< A, B >	Determines whether A is less than B
►Ctinympl::less< B, A >
Ctinympl::greater< A, B >	Determines whether A is greater than B
Ctinympl::lexicographical_compare< SequenceA, SequenceB, Comparator >	Compares two sequences using the given comparator
Ctinympl::logical_and< Args >	Computes the logical and of all its arguments
Ctinympl::logical_not< T >	Negate the argument
Ctinympl::logical_or< Args >	Computes the logical or of all its arguments
Ctinympl::make_basic_string< T, ptr >	Construct a basic_string from a constexpr pointer to a null-terminated string
Ctinympl::map< Args >	A compile time map from a type to another This class represents a compile time mapping between types. The mapping is specified using std::pair, that is every parameter of map must be an std::pair<KeyType,ValueType>
Ctinympl::max_element< Sequence, Cmp >	Compute the index of the largest element in a sequence
Ctinympl::min_element< Sequence, Cmp >	Compute the index of the smallest element in a sequence
Ctinympl::variadic::min_element< Cmp, Args >	Compute the index of the smallest element in a sequence
►Ctinympl::variadic::min_element< bind< Cmp, arg2, arg1 >::template eval_t, Args... >
Ctinympl::variadic::max_element< Cmp, Args...>
Ctinympl::variadic::max_element< Cmp, Args >	Compute the index of the largest element in a sequence
Ctinympl::variadic::min_element< Cmp, Args...>
Ctinympl::minus< A, B >	Computes A-B where A and B are compile time type constants
Ctinympl::modulus< A, B >	Computes A%B where A and B are compile time constants
Ctinympl::multiplies< Args >	Multiplies its arguments
Ctinympl::multiplies< Head, multiplies< Tail...>::type >
Ctinympl::negate< A >	Returns the opposite of the compile time constant A
►Ctinympl::negate< less< A, B >::type >
Ctinympl::greater_equal< A, B >	Determines whether A is greater than or equal to B
►Ctinympl::negate< less< B, A >::type >
Ctinympl::less_equal< A, B >	Determines whether A is less than or equal to B
Ctinympl::variadic::none_of< F, Args >	Determines whether none of the elements in the sequence satisfy the given predicate
Ctinympl::none_of< Sequence, F >	Determines whether none of the elements in the sequence satisfy the given predicate
Ctinympl::variadic::none_of< F, Args...>
Ctinympl::not_equal_to< A, B >	Determines whether the types A and B are not equal
Ctinympl::plus< Args >	Sums its arguments
Ctinympl::plus< Head, plus< Tail...>::type >
Ctinympl::vector< Args >::pop_back	Return a new vector constructed by removing the last element of the current vector
Ctinympl::vector< Args >::pop_front	Return a new vector constructed by removing the first element of the current vector
Ctinympl::vector< Args >::push_back< T >	Return a new vector constructed by inserting T on the back of the current vector
Ctinympl::vector< Args >::push_front< T >	Return a new vector constructed by inserting T on the front of the current vector
Ctinympl::remove< Sequence, T, Out >	Remove all the elements equal to T from the input sequence
Ctinympl::remove_if< Sequence, F, Out >	Remove the elements from the input sequence if they satisfy a given predicate
Ctinympl::replace< SequenceIn, Old, New, Out >	Replace all the elements in the input sequence equal to Old with New*
Ctinympl::basic_string< T, chars >::replace< pos, count, Str >	Return a new string constructed by replacing count characters starting at pos with the string Str
Ctinympl::replace_if< SequenceIn, F, T, Out >	Replace all the elements in the input sequence which satisfy a given predicate with a given type T
Ctinympl::variadic::replace_if< F, T, Out, Args >	Replace all the elements in the input sequence which satisfy a given predicate with a given type T
►Ctinympl::variadic::replace_if< bind< equal_to, arg1, Old >::template eval_t, New, Out, Args...>
Ctinympl::variadic::replace< Old, New, Out, Args...>
Ctinympl::variadic::replace< Old, New, Out, Args >	Replace all the elements in the input sequence equal to Old with New*
Ctinympl::variadic::replace_if< F, T, Out, Args...>
Ctinympl::variadic::reverse< Out, Args >	Reverse the input sequence
Ctinympl::reverse< Sequence, Out >	Reverse the input sequence
Ctinympl::variadic::reverse< Out, Args...>
Ctinympl::right_fold< Sequence, F >	Collapses a sequence starting from right using a functor
Ctinympl::variadic::right_fold< Op, Args >	Collapses a sequence starting from right using a functor
Ctinympl::variadic::right_fold< F, Ts...>
Ctinympl::sequence< Args >	The main sequence type
Ctinympl::set_difference< SequenceA, SequenceB, Out >	Computes the difference between two sets
Ctinympl::set_intersection< SequenceA, SequenceB, Out >	Computes the intersection between two sets
Ctinympl::set_union< SequenceA, SequenceB, Out >	Computes the union of two sets
Ctinympl::size< Seq >	Get the number of elements of a sequence
Ctinympl::variadic::size< Args >	Compute the size of a variadic template
Ctinympl::variadic::size< Args...>
Ctinympl::sizeof_< T >	Returns an std::integral_constant<std::size_t,V> where V is the compile time size of the input type
Ctinympl::variadic::sort< Cmp, Out, Args >	Sort the input sequence according to a given comparison function
Ctinympl::sort< Sequence, Out, Cmp >	Sort the input sequence according to a given comparison function
Ctinympl::variadic::sort< Cmp, Out, Args...>
Ctinympl::basic_string< T, chars >::substr< pos, count >	Return a substring long count starting at position pos
Ctinympl::transform< Sequence, F, Out >	Transform an input sequence using a transform function
Ctinympl::variadic::transform< F, Out, Args >	Transform an input sequence using a transform function
Ctinympl::variadic::transform< F, Out, Args...>
Ctinympl::transform_many< F, Out, Sequences >	Transform many input sequences using a function
►Ctinympl::transform_many< F, Out, Sequence1, Sequence2 >
Ctinympl::transform2< Sequence1, Sequence2, F, Out >	Transform two input sequences using a function
Ctinympl::transpose< SequenceOfSequences, OutOuter, OutInner >	Transpose a sequence of sequences
►Ctinympl::transpose< sequence< Sequences...>, OutSequence, ZipType >
Ctinympl::zip< OutSequence, ZipType, Sequences >	Construct a single sequence by zipping together multiple sequences
Ctinympl::variadic::unique< Out, Args >	Produces a sequence of unique elements from the input sequence, preserving the ordering
Ctinympl::unique< Sequence, Out >	Produces a sequence of unique elements from the input sequence, preserving the ordering
Ctinympl::variadic::unique< Out, Args...>
Ctinympl::variadic::unique< Out, Ts..., Us...>
Ctinympl::unordered_equal< SequenceA, SequenceB >	Determines whether it is possible to reorder the sequence A to match exactly the sequence B
Ctinympl::unordered_equal< sequence< As...>, sequence< Bs...> >
Ctinympl::value_map< KeyType, ValueType, Args >	A compile time map from a compile-time value to another This class represents a compile time mapping between values. The first two parameters are respectively the type of the key and of the values. The mapping is specified using std::pair, that is every parameter of map must be an std::pair< std::integral_constant<KeyType,key>,std::integral_constant<ValueType,value> >
Ctinympl::vector< Args >	A compile time vector of types Vector is the simplest tinympl sequence type. It provides standard modifiers and random access to its elements