13 template <
size_t I,
typename T>
33 template <
typename S1,
typename S2>
struct concat;
35 template <std::size_t... I1, std::size_t... I2>
39 template <
typename S1,
typename S2>
43 template <std::
size_t N>
using GenSeq =
46 template <std::
size_t N>
52 template <std::
size_t off,
typename S2>
struct int_range;
54 template <std::size_t off, std::size_t... I>
63 template <std::
size_t S, std::
size_t L>
65 :
int_range<S, typename make_index_sequence<L>::type>
68 template <std::
size_t S>
70 template <std::
size_t S>
73 template <std::
size_t S, std::
size_t L>
76 template <
typename S1,
typename S2>
79 template <std::size_t... I1, std::size_t... I2>
83 template <
typename S1,
typename S2>
97 template <
typename S1,
typename S2>
100 template <std::size_t I1_1, std::size_t... I1, std::size_t... I2>
109 template <std::size_t I1_1, std::size_t I2_1,
110 std::size_t... I1, std::size_t... I2>
120 template <std::size_t I1_1, std::size_t... I1>
135 template <
typename S1,
typename S2>
140 template <
typename Fun,
typename... Ts>
142 for_(
const std::tuple<Ts...>& ts, Fun f)
147 template <
typename Fun,
typename... Ts,
size_t... I>
150 const std::tuple<Ts...>& ts,
153 using swallow =
int[];
154 (
void) swallow{ (f(std::get<I>(ts)), 0)... };
158 template <
typename Fun,
typename... Ts>
160 map(
const std::tuple<Ts...>& ts, Fun f)
166 template <
typename Fun,
typename... Ts,
size_t... I>
169 const std::tuple<Ts...>& ts,
176 template <
typename Fun>
179 -> decltype(std::make_tuple())
181 return std::make_tuple();
184 template <
typename Fun,
typename T,
typename... Ts>
187 -> decltype(std::tuple_cat(std::make_tuple(f(t)),
192 return std::tuple_cat(std::make_tuple(
r),
map_variadic_(f, ts...));
205 template <
typename Fun>
212 template <
typename Fun,
213 typename Cont,
typename... Conts>
216 const Cont& head,
const Conts&... tails)
218 for (
const typename Cont::value_type& h: head)
219 cross([&](
const typename Conts::value_type&... tails)
224 template <
typename Fun,
typename... Ts,
size_t... I>
227 const std::tuple<Ts...>& ts,
230 cross(f, std::get<I>(ts)...);
233 template <
typename Fun,
typename... Ts>
236 const std::tuple<Ts...>& ts)
258 template <
typename T,
typename... Ts>
261 -> decltype(std::tuple_cat(
make_gcc_tuple(std::forward<Ts>(ts)...), std::make_tuple(t)));
263 template <
typename T,
typename... Ts>
266 -> decltype(std::tuple_cat(
make_gcc_tuple(std::forward<Ts>(ts)...), std::make_tuple(t)))
268 return std::tuple_cat(
make_gcc_tuple(std::forward<Ts>(ts)...), std::make_tuple(t));
278 template <
typename... Ts>
286 template <
typename... Ts, std::size_t... I>
289 -> decltype(std::make_tuple(std::get<
sizeof...(Ts) - 1 - I>(t)...))
291 return std::make_tuple(std::get<
sizeof...(Ts) - 1 - I>(t)...);
296 #if VCSN_HAVE_CORRECT_LIST_INITIALIZER_ORDER
297 template <
typename... Ts>
300 -> decltype(std::make_tuple(std::forward<Ts>(ts)...))
302 return std::make_tuple(std::forward<Ts>(ts)...);
305 template <
typename... Ts>
308 -> decltype(
reverse_tuple(std::make_tuple(std::forward<Ts>(ts)...)))
310 return reverse_tuple(std::make_tuple(std::forward<Ts>(ts)...));
319 template <
typename Tuple, std::
size_t N>
322 static void print(
const Tuple& t, std::ostream& o)
325 o <<
", " << std::get<N-1>(t);
329 template <
typename Tuple>
332 static void print(
const Tuple& t, std::ostream& o)
338 template <
typename... Args>
339 std::ostream&
print(
const std::tuple<Args...>& args, std::ostream& o)
352 template <
bool c,
typename T1,
typename T2>
355 template <
typename T1,
typename T2>
358 template <
typename C,
typename T1,
typename T2>
362 template <
bool c,
typename F1,
typename F2>
365 template <
typename C,
typename F1,
typename F2>
369 template <
typename... F>
372 template <
typename F1,
typename... F>
373 struct and_<F1, F...> :
eval_if<F1, and_<F...>, std::false_type>::type {};
375 template <
typename F1>
376 struct and_<F1> :
eval_if<F1, std::true_type, std::false_type>::type {};
382 template <
typename... F>
385 template <
typename F1,
typename... F>
386 struct or_<F1, F...> :
eval_if<F1, std::true_type, or_<F...>>::type { };
388 template <
typename F1>
389 struct or_<F1> :
eval_if<F1, std::true_type, std::false_type>::type { };
409 template <
typename... Bool>
410 bool all(Bool&&... values)
413 using swallow =
int[];
416 (res = res && values, 0)...
430 template <
typename... Elements>
442 template <std::size_t... I>
447 using swallow =
int[];
void cross_tuple_(Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >)
Provide a variadic mul on top of a binary mul(), and one().
And condition on several typenames.
Or condition on several typenames.
static std::size_t hash_(const value_t &v, vcsn::detail::index_sequence< I... >)
typename concat_index_sequence< S1, S2 >::type concat_sequence
void for_(const std::tuple< Ts... > &ts, Fun f)
std::tuple< Elements... > value_t
static void print(const Tuple &t, std::ostream &o)
std::ostream & print(const std::tuple< Args... > &args, std::ostream &o)
auto map_variadic_(Fun) -> decltype(std::make_tuple())
auto make_gcc_tuple(Ts &&...ts) -> decltype(reverse_tuple(std::make_tuple(std::forward< Ts >(ts)...)))
Same as make_tuple, unless the evaluation of arguments if right-to-left, in which case reverse the re...
typename concat_index_sequence< index_sequence< I1_1 >, typename index_sequence_difference< index_sequence< I1... >, index_sequence<>>::type >::type type
typename index_sequence_difference< index_sequence< I1... >, index_sequence< I2... >>::type type
std::size_t operator()(const value_t &v) const
std::string type(const automaton &a)
The implementation type of a.
typename concat_index_sequence< index_sequence< I1_1 >, typename index_sequence_difference< index_sequence< I1... >, index_sequence< I2_1, I2... >>::type >::type type
static void print(const Tuple &t, std::ostream &o)
ValueSet::value_t tuple(const ValueSet &vs, const typename ValueSets::value_t &...v)
void cross(Fun f)
Variadic Cartesian product of containers.
Test if (c) then F1 else F2 and get the value.
auto reverse_tuple(const std::tuple< Ts... > &t) -> decltype(reverse_tuple(t, make_index_sequence< sizeof...(Ts)>()))
auto 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.
typename index_sequence_difference< typename S1::type, typename S2::type >::type sequence_difference
auto map_tuple_(Fun f, const std::tuple< Ts... > &ts, index_sequence< I... >) -> decltype(map_variadic_(f, std::get< I >(ts)...))
void cross_tuple(Fun f, const std::tuple< Ts... > &ts)
bool all(Bool &&...values)
constexpr bool any_()
Static evaluation of the 'or' of the template parameters.
typename make_index_range< S, L >::type make_index_range_t
typename index_sequence<>::type type
void hash_combine(std::size_t &seed, const T &v)
Get the list containing all the elements of I1 (contiguous sequence from 0 to N) not present in I2 (a...
typename std::tuple_element< I, T >::type tuple_element_t
C++14.
typename make_index_sequence< N >::type GenSeq