ScalarTransformer.h

Go to the documentation of this file.

#ifndef SCALAR_TRANSFORMER_H
#define SCALAR_TRANSFORMER_H

#include "GaudiAlg/Transformer.h"

namespace Gaudi::Functional {

  // Scalar->Vector adapted N->1 algorithm
  template <typename ScalarOp, typename TransformerSignature, typename Traits_ = Traits::useDefaults>
  class ScalarTransformer;
  template <typename ScalarOp, typename Out, typename... In, typename Traits_>
  class ScalarTransformer<ScalarOp, Out( const In&... ), Traits_> : public Transformer<Out( const In&... ), Traits_> {

    const ScalarOp& scalarOp() const { return static_cast<const ScalarOp&>( *this ); }

  public:
    using Transformer<Out( const In&... ), Traits_>::Transformer;

    Out operator()( const In&... in ) const override final {
      const auto inrange = details::zip::const_range( in... );
      Out        out;
      out.reserve( inrange.size() );
      auto& scalar = scalarOp();
      for ( const auto&& tuple : inrange ) {
        details::invoke_optionally(
            [&out]( auto&& arg ) { details::insert( out, std::forward<decltype( arg )>( arg ) ); },
            std::apply( [&]( const auto&... i ) { return scalar( details::deref( i )... ); }, tuple ) );
      }
      details::applyPostProcessing( scalar, out );
      return out;
    }
  };

  // Scalar->Vector adapted N->M algorithm
  template <typename ScalarOp, typename TransformerSignature, typename Traits_ = Traits::useDefaults>
  class MultiScalarTransformer;
  template <typename ScalarOp, typename... Out, typename... In, typename Traits_>
  class MultiScalarTransformer<ScalarOp, std::tuple<Out...>( const In&... ), Traits_>
      : public MultiTransformer<std::tuple<Out...>( const In&... ), Traits_> {

    const ScalarOp& scalarOp() const { return static_cast<const ScalarOp&>( *this ); }

  public:
    using MultiTransformer<std::tuple<Out...>( const In&... ), Traits_>::MultiTransformer;

    std::tuple<Out...> operator()( const In&... in ) const override final {
      const auto         inrange = details::zip::const_range( in... );
      std::tuple<Out...> out;
      std::apply( [sz = inrange.size()]( auto&&... o ) { ( o.reserve( sz ), ... ); }, out );
      auto& scalar = scalarOp();
      for ( const auto&& indata : inrange ) {
        std::apply(
            [&scalar, &indata]( auto&... out ) {
              details::invoke_optionally(
                  [&out...]( auto&& outdata ) {
                    std::apply(
                        [&out...]( auto&&... outdata1 ) {
                          ( details::insert( out, std::forward<decltype( outdata1 )>( outdata1 ) ), ... );
                        },
                        std::forward<decltype( outdata )>( outdata ) );
                  },
                  std::apply( [&scalar]( const auto&... args ) { return scalar( details::deref( args )... ); },
                              indata ) );
            },
            out );
      }
      details::applyPostProcessing( scalar, out );
      return out;
    }
  };
} // namespace Gaudi::Functional

#endif