![]() |
0.4.1
|
Algorithm iterating all combinations of a list. More...
Go to the source code of this file.
Data Structures | |
struct | NAV::CartesianProduct::increment_iterator< I > |
Helper struct to increment an iterator. More... | |
struct | NAV::CartesianProduct::increment_iterator< 0 > |
Helper struct to increment an iterator. More... | |
Namespaces | |
namespace | NAV |
namespace | NAV::CartesianProduct |
namespace | NAV::CartesianProduct::tuple_algos |
Functions | |
template<typename Tuple, typename Predicate> | |
bool | NAV::CartesianProduct::tuple_algos::any_of (Tuple &&tuple, Predicate pred) |
Any_of algorithm for tuples. | |
template<typename Function, typename... Ts, size_t... Is> | |
void | NAV::CartesianProduct::callFunction (Function function, std::tuple< Ts... > const &tuple, std::index_sequence< Is... >) |
Calls the function on the tuple. | |
template<typename Function, typename... Ranges> | |
void | NAV::cartesian_product (Function function, Ranges const &... ranges) |
Calls a function on all combinations over ranges. | |
template<typename SubList, size_t N, typename Function> | |
void | NAV::cartesian_product (Function function, std::array< SubList, N > list) |
Calls a function on all combinations over ranges defined in an array, e.g. std::array<std::vector> | |
template<typename SubList, size_t N, typename Function> | |
void | NAV::cartesian_product_idx (Function function, std::array< SubList, N > list) |
Calls a function on all combinations over ranges defined in an array, e.g. std::array<std::vector>. Instead of providing the list entry to the function, provides the index of it in the sub list. | |
template<typename... Ts> | |
auto | NAV::CartesianProduct::dereference (std::tuple< Ts... > const &tuple) |
Dereference a tuple. | |
template<typename Tuple, typename Predicate> | |
size_t | NAV::CartesianProduct::tuple_algos::find_if (Tuple &&tuple, Predicate pred) |
Find_if for tuples. | |
template<class F, class Tuple> | |
constexpr decltype(auto) | NAV::CartesianProduct::tuple_algos::for_each (Tuple &&t, F &&f) |
For-each algorithm for tuples. | |
template<class Tuple, class F, std::size_t... I> | |
F | NAV::CartesianProduct::tuple_algos::for_each_impl (Tuple &&t, F &&f, std::index_sequence< I... >) |
For-each implementation for tuples. | |
template<typename... Iterators> | |
void | NAV::CartesianProduct::next_combination (std::tuple< Iterators... > &iterators, std::tuple< Iterators... > const &beginIterators, std::tuple< Iterators... > const &endIterators) |
Gets the next combination of the tuples of iterators. | |
template<typename... Ts, typename Function> | |
auto | NAV::CartesianProduct::tuple_algos::transform (std::tuple< Ts... > const &inputs, Function function) |
Transform algorithm for tuples. | |
template<class Tuple, class F, std::size_t... Is> | |
auto | NAV::CartesianProduct::tuple_algos::transform_impl (Tuple &&t, F &&f, std::index_sequence< Is... >) -> decltype(std::make_tuple(std::forward< F >(f)(std::get< Is >(std::forward< Tuple >(t)))...)) |
Transform implementation for tuples. | |
Algorithm iterating all combinations of a list.
Definition in file CartesianProduct.hpp.