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() = default;

    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
    {
      // this complicate syntax appears to guarantee that the tuple types
      // include a l-value reference when the dereference operator returns
      // a l-value reference, and a r-value when the dereference operator
      // returns one. Using `std::forward_as_reference()` instead,
      // r-values are saved as r-value references. Using `std::tuple()`
      // instead, all referenceness is stripped away, including l-value ones.
      return std::tuple<decltype(*std::get<Indices>(fIterators))...>(
        *std::get<Indices>(fIterators)...);
    }

  }; // class zip_iterator

  //----------------------------------------------------------------------------
  // This is more of a curiosity than anything else.
  template <std::size_t Lead>
  class zip_iterator<Lead> {

    using this_iterator_t = zip_iterator<Lead>;

  public:
    using difference_type = std::ptrdiff_t;
    using reference = std::tuple<>;
    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;

    zip_iterator() = default;

    std::tuple<> operator*() const { return {}; }

    this_iterator_t& operator++() { return *this; }

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

    // All these iterators look the same.
    template <std::size_t OtherLead, typename... OtherIter>
    bool operator!=(zip_iterator<OtherLead, OtherIter...> const& other) const
    {
      return false;
    }

    // All these iterators look the same.
    template <std::size_t OtherLead, typename... OtherIter>
    bool operator==(zip_iterator<OtherLead, OtherIter...> const& other) const
    {
      return true;
    }

  }; // 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)...};

  } // make_zip_begin_iterator()

  //----------------------------------------------------------------------------
  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)...};

  } // make_zip_end_iterator()

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

} // namespace util::details

//------------------------------------------------------------------------------
template <std::size_t Lead /* = 0U */, typename... Iterables>
auto util::zip(Iterables&&... iterables)
{

  return util::span(details::make_zip_begin_iterator<Lead>(iterables...),
                    details::make_zip_end_iterator<Lead>(iterables...));

} // util::zip()

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

#endif // LARCOREALG_COREUTILS_ZIP_H