AssnsAlgorithms.h

Go to the documentation of this file.

#ifndef canvas_Persistency_Common_AssnsAlgorithms_h
#define canvas_Persistency_Common_AssnsAlgorithms_h

#include "canvas/Persistency/Common/Assns.h"

// range library
#include "range/v3/algorithm/for_each.hpp"
#include "range/v3/view/all.hpp"
#include "range/v3/view/group_by.hpp"
#include "range/v3/view/map.hpp"
#include "range/v3/view/transform.hpp"

// C/C++ standard libraries
#include <iterator> // std::next()

namespace art {
  template <typename A, typename B, typename D, typename F>
  void
  for_each_group(art::Assns<A, B, D> const& assns, F func)
  {
    ranges::for_each(assns | ranges::view::all |
                       ranges::view::group_by([](auto a1, auto a2) {
                         return a1.first == a2.first;
                       }) |
                       ranges::view::transform([](auto pairs) {
                         return pairs | ranges::view::values;
                       }),
                     func);
  }

  /*
   * @brief  Helper functions to access associations in order
   * @tparam A type of association being read
   * @tparam F type of functor to be called on each LHS and associated RHS
   * @param assns the association being read
   * @param func functor to be called on each LHS and associated RHS
   *
   * This function performs the following:
   *  -- takes an association collection as the first argument
   *  -- calls the provided callable object
   * For example, given an art::Assns<L, R>, it will transform this
   * collection to a form that supports calling a function with two arguments
   * (auto const & left, auto rights)
   * The provided callable is invoked for each unique left.
   *
   */
  template <typename A, typename B, typename D, typename F>
  void
  for_each_group_with_left(art::Assns<A, B, D> const& assns, F func)
  {
    for_each_pair(assns, [&func](auto rng) {
      auto rights = rng | ranges::view::values;
      auto lefts = rng | ranges::view::keys;
      auto const& left = **ranges::begin(lefts);
      func(left, rights);
    });
  }

  template <typename A, typename B, typename D, typename F>
  void
  for_each_pair(art::Assns<A, B, D> const& assns, F func)
  {
    ranges::for_each(assns | ranges::view::all |
                       ranges::view::group_by(
                         [](auto a1, auto a2) { return a1.first == a2.first; }),
                     func);
  }

} // namespace art

#endif /* canvas_Persistency_Common_AssnsAlgorithms_h */

// Local Variables:
// mode: c++
// End: