iterator.h

Go to the documentation of this file.

#ifndef GRPPI_COMMON_ITERATOR_H
#define GRPPI_COMMON_ITERATOR_H

#include <utility>
#include <tuple>

namespace grppi{

namespace internal {

template <typename F, typename ... Iterators, template<typename...> class T, std::size_t ... I>
decltype(auto) apply_deref_increment(
    F && f, 
    T<Iterators...> & iterators, 
    std::index_sequence<I...>)
{
  return std::forward<F>(f)(*std::get<I>(iterators)++...);
}

} // namespace internal

template <typename F, typename ... Iterators, template <typename ...> class T>
decltype(auto) apply_deref_increment(
    F && f, 
    T<Iterators...> & iterators)
{
  constexpr std::size_t size = sizeof...(Iterators);
  return internal::apply_deref_increment(std::forward<F>(f), iterators,
      std::make_index_sequence<size>());
}

namespace internal {

template <typename F, typename ... Iterators, template <typename...> class T,
          std::size_t ... I>
decltype(auto) apply_increment(
    F && f,
    T<Iterators...> & iterators,
    std::index_sequence<I...>)
{
  return std::forward<F>(f)(std::get<I>(iterators)++...);
}

}

template <typename F, typename ... Iterators, template <typename...> class T>
decltype(auto) apply_increment(
    F && f,
    T<Iterators...> & iterators) 
{
  constexpr std::size_t size = sizeof...(Iterators);
  return internal::apply_increment(std::forward<F>(f), iterators,
      std::make_index_sequence<size>());
}

namespace internal {

template <typename F, typename T, std::size_t ... I>
decltype(auto) apply_iterators_indexed_impl(F && f, T && t, std::size_t i,
    std::index_sequence<I...>)
{
  return std::forward<F>(f)(std::get<I>(t)[i]...);
}

} // namespace internal

template <typename F, typename T>
decltype(auto) apply_iterators_indexed(F && f, T && t, std::size_t i)
{
  using tuple_raw_type = std::decay_t<T>;
  constexpr std::size_t size = std::tuple_size<tuple_raw_type>::value;
  return internal::apply_iterators_indexed_impl(std::forward<F>(f), 
      std::forward<T>(t), i, std::make_index_sequence<size>());
}

namespace internal {

template <typename T, std::size_t ... I>
auto iterators_next_impl(T && t, int n, std::index_sequence<I...>) {
  return make_tuple(
    std::next(std::get<I>(t), n)...
  );
}

} // namespace internal

template <typename T>
auto iterators_next(T && t, int n) {
  using tuple_raw_type = std::decay_t<T>;
  constexpr std::size_t size = std::tuple_size<tuple_raw_type>::value;
  return internal::iterators_next_impl(std::forward<T>(t), n,
      std::make_index_sequence<size>());
}




template <typename ... InputIt>
void advance_iterators(size_t delta, InputIt & ... in) {
  // This hack can be done in C++14.
  // It can be simplified in C++17 with folding expressions.
  using type = int[];
  type { 0, (in += delta, 0) ...};
} 

template <typename ... InputIt>
void advance_iterators(InputIt & ... in) {
  // This hack can be done in C++14.
  // It can be simplified in C++17 with folding expressions.
  using type = int[];
  type { 0, (in++, 0) ...};
} 


} // namespace grppi

#endif