chaining.h

/*********************************************************************************************************************************************/
/*  DocWire SDK: Award-winning modern data processing in C++20. SourceForge Community Choice & Microsoft support. AI-driven processing.      */
/*  Supports nearly 100 data formats, including email boxes and OCR. Boost efficiency in text extraction, web data extraction, data mining,  */
/*  document analysis. Offline processing possible for security and confidentiality                                                          */
/*                                                                                                                                           */
/*  Copyright (c) SILVERCODERS Ltd, http://silvercoders.com                                                                                  */
/*  Project homepage: https://github.com/docwire/docwire                                                                                     */
/*                                                                                                                                           */
/*  SPDX-License-Identifier: AGPL-3.0-only OR LicenseRef-DocWire-Commercial                                                                  */
/*********************************************************************************************************************************************/
 
#ifndef DOCWIRE_CHAINING_H
#define DOCWIRE_CHAINING_H
 
#include "invocation_concepts.h"
#include "invocation_traits.h"
#include "ref_or_owned.h"
#include "tuple_utils.h"
 
namespace docwire::chaining
{
 
template<invocation_concepts::not_invocable V, invocation_concepts::invocable F>
struct value_to_function_binding
{
  ref_or_owned<V> value;
 
  ref_or_owned<F> function;
 
  template <typename... Args>
  auto operator()(Args&&... args)
  {
    return function.get()(value.get(), std::forward<Args>(args)...);
  }
 
  using invocation_args_t = tuple_utils::remove_first_t<invocation_traits::args_t<F>>;
};
 
template <invocation_concepts::not_invocable V, invocation_concepts::invocable F>
auto operator|(V&& value, F&& function)
{
  value_to_function_binding<std::decay_t<V>, std::decay_t<F>> binding
    { std::forward<V>(value), std::forward<F>(function) };
  if constexpr (invocation_traits::arity_v<decltype(binding)> == 0)
    return binding();
  else
    return binding;
}
 
template<invocation_concepts::invocable F1, invocation_concepts::invocable F2>
struct function_to_function_binding
{
  static_assert(invocation_traits::arity_v<F1> > 0);
 
  ref_or_owned<F1> function1;
 
  ref_or_owned<F2> function2;
 
  template <typename... Args>
  auto operator()(Args&&... args) const
  {
    constexpr auto f1_arg_count = invocation_traits::arity_v<F1> - 1; // exclude callback
    constexpr auto f2_arg_count = invocation_traits::arity_v<F2> - 1; // exclude callback argument;
    static_assert(f1_arg_count + f2_arg_count == sizeof...(args));
 
    auto args_tuple = std::make_tuple(std::forward<Args>(args)...);
 
    auto f2_args = tuple_utils::subrange<f1_arg_count, f2_arg_count>(args_tuple);
    auto callback = [this, f2_args](auto&& arg) {
      auto merged_args = std::tuple_cat(std::make_tuple(std::forward<decltype(arg)>(arg)), f2_args);
      return std::apply(
        function2.get(), merged_args);
    };
 
    auto f1_args = tuple_utils::subrange<0, f1_arg_count>(args_tuple);
    return std::apply(function1.get(), std::tuple_cat(f1_args, std::make_tuple(callback)));
  }
  
  using invocation_args_t =
    decltype(std::tuple_cat(
      std::declval<tuple_utils::remove_last_t<invocation_traits::args_t<F1>>>(),
      std::declval<tuple_utils::remove_first_t<invocation_traits::args_t<F2>>>()
    ));
};
 
template <invocation_concepts::invocable F1, invocation_concepts::invocable F2>
auto operator|(F1&& function1, F2&& function2)
{
  function_to_function_binding<std::decay_t<F1>, std::decay_t<F2>> binding
    { std::forward<F1>(function1), std::forward<F2>(function2) };
  if constexpr (invocation_traits::arity_v<decltype(binding)> == 0)
    return binding();
  else
    return binding;
}
 
template<invocation_concepts::invocable F, invocation_concepts::pushable C>
struct function_to_pushable_binding
{
  ref_or_owned<F> function;
 
  ref_or_owned<C> container;
 
  template <typename... Args>
  auto operator()(Args&&... args)
  {
    using F_args_t = invocation_traits::args_t<F>;
    static_assert(std::tuple_size_v<F_args_t> > 0);
    using F_last_arg_t = tuple_utils::last_element_t<F_args_t>;
    using callback_ret_type = invocation_traits::result_t<F_last_arg_t>;
    return function.get()(std::forward<Args>(args)..., [this](auto&& arg)->callback_ret_type
    {
      container.get().push_back(arg);
      if constexpr (!std::is_void_v<callback_ret_type>)
        return callback_ret_type{};
    });
  }
 
  using invocation_args_t = tuple_utils::remove_last_t<invocation_traits::args_t<F>>;
};
 
template <invocation_concepts::invocable F, invocation_concepts::pushable C>
auto operator|(F&& function, C&& container)
{
  function_to_pushable_binding<std::decay_t<F>, std::decay_t<C>> binding
    { std::forward<F>(function), std::forward<C>(container) };
  if constexpr (invocation_traits::arity_v<decltype(binding)> == 0)
    return binding();
  else
    return binding;
}
 
} // namespace docwire::chaining
 
#endif //DOCWIRE_CHAINING_H