zip.h

Go to the documentation of this file.

#ifndef LARCOREALG_COREUTILS_ZIP_H
#define LARCOREALG_COREUTILS_ZIP_H

#include "larcorealg/CoreUtils/span.h"

// C/C++ libraries
#include <cstddef>  // std::size_t
#include <iterator> // std::begin(), std::end()
#include <tuple>
#include <type_traits> // std::remove_cv_t<>, ...
#include <utility>     // std::forward(), std::index_sequence_for(), ...

namespace util {

  // -- BEGIN -- Parallel iterations -------------------------------------------

  template <std::size_t Lead, typename... Iterables>
  auto zip(Iterables&&... iterables);

  template <typename... Iterables>
  auto zip(Iterables&&... iterables)
  {
    return zip<0U>(std::forward<Iterables>(iterables)...);
  }

  // -- END -- Parallel iterations ---------------------------------------------

} // namespace util

//==============================================================================
//=== template implementation
//==============================================================================
//------------------------------------------------------------------------------
//--- util::zip()
//------------------------------------------------------------------------------
namespace util::details {

  //----------------------------------------------------------------------------
  template <std::size_t Lead, typename... Iters>
  class zip_iterator {

    static_assert(Lead < sizeof...(Iters), "The index (Lead) of the leading iterator is invalid.");

    using this_iterator_t = zip_iterator<Lead, Iters...>;

  public:
    // --- BEGIN -- Data types -------------------------------------------------

    using difference_type = std::ptrdiff_t;
    using reference = std::tuple<typename std::iterator_traits<Iters>::reference...>;
    using value_type = std::remove_cv_t<reference>;
    using pointer = std::add_pointer_t<std::remove_reference_t<reference>>;
    using iterator_category = std::forward_iterator_tag;

    // --- END -- Data types ---------------------------------------------------

    // --- BEGIN -- Constructors -----------------------------------------------

    zip_iterator(Iters&&... iterators) : fIterators(std::forward<Iters>(iterators)...) {}

    // --- END -- Constructors -------------------------------------------------

    // --- BEGIN -- Access -----------------------------------------------------

    auto operator*() const { return dereference_impl(std::index_sequence_for<Iters...>()); }

    template <std::size_t Index>
    decltype(auto) get() const
    {
      return std::get<Index>(fIterators);
    }

    // --- END -- Access -------------------------------------------------------

    // --- BEGIN -- Modification -----------------------------------------------

    this_iterator_t& operator++()
    {
      increment_impl(std::index_sequence_for<Iters...>());
      return *this;
    }

    this_iterator_t operator++(int)
    {
      this_iterator_t old(*this);
      operator++();
      return old;
    }

    // --- END -- Modification -------------------------------------------------

    // --- BEGIN -- Comparisons ------------------------------------------------

    template <std::size_t OtherLead, typename... OtherIter>
    bool operator!=(zip_iterator<OtherLead, OtherIter...> const& other) const
    {
      return get<Lead>() != other.template get<OtherLead>();
    }

    template <std::size_t OtherLead, typename... OtherIter>
    bool operator==(zip_iterator<OtherLead, OtherIter...> const& other) const
    {
      return get<Lead>() == other.template get<OtherLead>();
    }

    // --- END -- Comparisons --------------------------------------------------

  private:
    std::tuple<Iters...> fIterators; 

    template <typename... Args>
    static void expandStatements(Args&... args)
    {}

    template <std::size_t... Indices>
    void increment_impl(std::index_sequence<Indices...>)
    {
      expandStatements(++std::get<Indices>(fIterators)...);
    }

    template <std::size_t... Indices>
    auto dereference_impl(std::index_sequence<Indices...>) const
    {
      // std::tie returns a tuple of references, which is what we want.
      return std::tie(*std::get<Indices>(fIterators)...);
    }

  }; // class zip_iterator

  //----------------------------------------------------------------------------
  template <std::size_t Lead, typename... Iterables>
  auto make_zip_begin_iterator(Iterables&&... iterables)
  {
    using std::begin;
    return zip_iterator<Lead, decltype(begin(iterables))...>{begin(iterables)...};
  }

  //----------------------------------------------------------------------------
  template <std::size_t Lead, typename... Iterables>
  auto make_zip_end_iterator(Iterables&&... iterables)
  {
    using std::end;
    return zip_iterator<Lead, decltype(end(iterables))...>{end(iterables)...};
  }
} // namespace util::details

//------------------------------------------------------------------------------
template <std::size_t Lead /* = 0U */, typename... Iterables>
auto util::zip(Iterables&&... iterables)
{
  static_assert(sizeof...(Iterables) > 0, "Must zip at least one iterable.");
  return span{details::make_zip_begin_iterator<Lead>(iterables...),
              details::make_zip_end_iterator<Lead>(iterables...)};
}

//------------------------------------------------------------------------------

#endif // LARCOREALG_COREUTILS_ZIP_H