span.h

Go to the documentation of this file.

#ifndef LARCOREALG_COREUTILS_SPAN_H
#define LARCOREALG_COREUTILS_SPAN_H

// Boost libraries
#include "boost/iterator/transform_iterator.hpp"

// C/C++ standard library
#include <iterator>    // std::begin(), std::end()
#include <type_traits> // std::decay_t<>, std::declval(), std::invoke_result_t<>
#include <utility>     // std::as_const()

namespace util {

  struct span_base {

    template <typename Cont>
    static decltype(auto) get_begin(Cont& cont)
    {
      using std::begin;
      return begin(cont);
    }

    template <typename Cont>
    static decltype(auto) get_end(Cont& cont)
    {
      using std::end;
      return end(cont);
    }

    template <typename Cont>
    using get_begin_iterator = std::decay_t<decltype(get_begin(std::declval<Cont>()))>;

    template <typename Cont>
    using get_end_iterator = std::decay_t<decltype(get_end(std::declval<Cont>()))>;

    template <typename Cont>
    static decltype(auto) get_cbegin(Cont& cont)
    {
      using std::cbegin;
      return cbegin(cont);
    }

    template <typename Cont>
    static decltype(auto) get_cend(Cont& cont)
    {
      using std::cend;
      return cend(cont);
    }

    template <typename Cont>
    using get_cbegin_iterator = std::decay_t<decltype(get_cbegin(std::declval<Cont>()))>;

    template <typename Cont>
    using get_cend_iterator = std::decay_t<decltype(get_cend(std::declval<Cont>()))>;

  }; // struct span_base

  template <typename BIter, typename EIter = BIter>
  struct span : public span_base, private std::pair<BIter, EIter> {

    using begin_iterator = BIter; 
    using end_iterator = EIter;   

    using span_t = span<begin_iterator, end_iterator>;

    using pair_t = std::pair<begin_iterator, end_iterator>;

    using value_type = typename begin_iterator::value_type;

    using reference = typename begin_iterator::reference;

    span(begin_iterator b, end_iterator e) : pair_t(b, e) {}

    template <typename SrcIterB, typename SrcIterE, typename Adaptor>
    span(SrcIterB&& b, SrcIterE&& e, Adaptor&& adaptor)
      : span(adaptor(std::forward<SrcIterB>(b)), adaptor(std::forward<SrcIterE>(e)))
    {}

    template <typename OBIter, typename OEIter>
    span(span<OBIter, OEIter> const& from) : span(from.begin(), from.end())
    {}

    // C++ boilerplate
    span(span_t const&) = default;
    span(span_t&&) = default;
    span_t& operator=(span_t const&) = default;
    span_t& operator=(span_t&&) = default;

    begin_iterator begin() const { return pair_t::first; }

    end_iterator end() const { return pair_t::second; }

    std::size_t size() const { return std::distance(begin(), end()); }

    bool empty() const { return begin() == end(); }

  }; // span

  // deduction guide for adapted span
  template <typename IterB, typename IterE, typename Adaptor>
  span(IterB&& b, IterE&& e, Adaptor&& adaptor)
    -> span<std::invoke_result_t<Adaptor, IterB>, std::invoke_result_t<Adaptor, IterE>>;

  // --- BEGIN -- Span helper functions ----------------------------------------

  template <typename BIter, typename EIter>
  auto make_span(BIter begin, EIter end)
  {
    return span{begin, end};
  }

  template <typename Cont>
  auto make_span(Cont& cont)
  {
    return span{span_base::get_begin(cont), span_base::get_end(cont)};
  }

  template <typename Cont>
  auto make_const_span(Cont& cont)
  {
    return span{span_base::get_cbegin(cont), span_base::get_cend(cont)};
  }

  // --- END -- Span helper functions ------------------------------------------

  // --- BEGIN -- Adapted span helper functions --------------------------------

  template <typename BIter, typename EIter, typename Adaptor>
  auto make_adapted_span(BIter begin, EIter end, Adaptor&& adaptor)
  {
    return util::span(adaptor(begin), adaptor(end));
  }

  template <typename Cont, typename Adaptor>
  auto make_adapted_span(Cont& cont, Adaptor&& adaptor)
  {
    return make_adapted_span(
      span_base::get_begin(cont), span_base::get_end(cont), std::forward<Adaptor>(adaptor));
  }

  // @see `make_adapted_span(Cont, Adaptor&&)`
  template <typename Cont, typename Adaptor>
  auto make_adapted_const_span(Cont& cont, Adaptor&& adaptor)
  {
    return make_adapted_span(
      span_base::get_cbegin(cont), span_base::get_cend(cont), std::forward<Adaptor>(adaptor));
  }

  // --- END -- Adapted span helper functions ----------------------------------

  // --- BEGIN -- Transformed span helper functions ----------------------------

  template <typename BIter, typename EIter, typename Op>
  auto make_transformed_span(BIter begin, EIter end, Op&& op)
  {
    auto adaptor = [&op](auto iter) { return boost::make_transform_iterator(iter, op); };
    return util::make_adapted_span(begin, end, adaptor);
  }

  template <typename Cont, typename Op>
  auto make_transformed_span(Cont& cont, Op&& op)
  {
    return make_transformed_span(
      span_base::get_begin(cont), span_base::get_end(cont), std::forward<Op>(op));
  }

  // @see `make_transformed_span(Cont, Op&&)`
  template <typename Cont, typename Op>
  auto make_transformed_const_span(Cont& cont, Op&& op)
  {
    return make_transformed_span(std::as_const(cont), std::forward<Op>(op));
  }

  // --- END -- Adapted span helper functions ----------------------------------

} // namespace util

#endif // LARCOREALG_COREUTILS_SPAN_H