for_each.hpp

/****************************************************************************
 *  hipipe library
 *  Copyright (c) 2017, Cognexa Solutions s.r.o.
 *  Copyright (c) 2018, Iterait a.s.
 *  Author(s) Filip Matzner
 *
 *  This file is distributed under the MIT License.
 *  See the accompanying file LICENSE.txt for the complete license agreement.
 ****************************************************************************/
 
#pragma once
 
#include <hipipe/core/stream/template_arguments.hpp>
#include <hipipe/core/stream/transform.hpp>
#include <hipipe/core/utility/tuple.hpp>
 
namespace hipipe::stream {
 
namespace detail {
 
    // Wrap the given function so that its return value is ignored
    // and so that it can be forwarded to stream::transform.
    template<typename Fun, typename... FromTypes>
    struct wrap_void_fun_for_transform {
        Fun fun;
 
        utility::maybe_tuple<FromTypes...> operator()(FromTypes&... args)
        {
            static_assert(std::is_invocable_v<Fun, FromTypes&...>,
              "hipipe::stream::for_each: "
              "Cannot apply the given function to the given `from<>` columns.");
            std::invoke(fun, args...);
            // we can force std::move here because the old
            // data are going to be ignored anyway
            return {std::move(args)...};
        }
    };
 
}  // namespace detail
 
 
template<typename... FromColumns, typename Fun, int Dim = 1>
auto for_each(from_t<FromColumns...> f, Fun fun, dim_t<Dim> d = dim_t<1>{})
{
    static_assert(
      ((utility::ndims<typename FromColumns::data_type>::value >= Dim) && ...),
      "hipipe::stream::for_each: The dimension in which to apply the operation "
      " needs to be at most the lowest dimension of all the from<> columns.");
    // a bit of function type erasure to speed up compilation
    using FunT = std::function<
      void(utility::ndim_type_t<typename FromColumns::data_type, Dim>&...)>;
    // wrap the function to be compatible with stream::transform
    detail::wrap_void_fun_for_transform<
      FunT, utility::ndim_type_t<typename FromColumns::data_type, Dim>...>
        fun_wrapper{std::move(fun)};
    // apply the dummy transformation
    return stream::transform(f, to<FromColumns...>, std::move(fun_wrapper), d);
}
 
}  // namespace hipipe::stream