MergingTransformer.h

Go to the documentation of this file.

#ifndef MERGING_TRANSFORMER_H
#define MERGING_TRANSFORMER_H

#include <functional>
#include <string>
#include <vector>

#include "GaudiAlg/FunctionalDetails.h"
#include "GaudiAlg/FunctionalUtilities.h"

namespace Gaudi
{
  namespace Functional
  {

    template <typename Signature, typename Traits_ = Traits::useDefaults>
    class MergingTransformer;

    using details::vector_of_const_;

    template <typename Out, typename In, typename Traits_>
    class MergingTransformer<Out( const vector_of_const_<In>& ), Traits_>
        : public details::DataHandleMixin<std::tuple<Out>, void, Traits_>
    {
      using base_class = details::DataHandleMixin<std::tuple<Out>, void, Traits_>;

    public:
      using KeyValue  = std::pair<std::string, std::string>;
      using KeyValues = std::pair<std::string, std::vector<std::string>>;

      MergingTransformer( const std::string& name, ISvcLocator* locator, const KeyValues& inputs,
                          const KeyValue& output );

      // derived classes can NOT implement execute
      StatusCode execute() override final;

      virtual Out operator()( const vector_of_const_<In>& inputs ) const = 0;

    private:
      // if In is a pointer, it signals optional (as opposed to mandatory) input
      template <typename T>
      using InputHandle_t = details::InputHandle_t<Traits_, typename std::remove_pointer<T>::type>;
      std::vector<std::string> m_inputLocations; // TODO/FIXME: remove this duplication...
      std::vector<InputHandle_t<In>> m_inputs;   //   and make the handles properties instead...
    };

    template <typename Out, typename In, typename Traits_>
    MergingTransformer<Out( const vector_of_const_<In>& ), Traits_>::MergingTransformer( const std::string& name,
                                                                                         ISvcLocator* pSvcLocator,
                                                                                         const KeyValues& inputs,
                                                                                         const KeyValue& output )
        : base_class( name, pSvcLocator, output ), m_inputLocations( inputs.second )
    {
      // TODO/FIXME: replace vector of string property + call-back with a
      //             vector<handle> property ... as soon as declareProperty can deal with that.
      auto p = this->declareProperty( inputs.first, m_inputLocations );
      p->declareUpdateHandler( [=]( Gaudi::Details::PropertyBase& ) {
        this->m_inputs = details::make_vector_of_handles<decltype( this->m_inputs )>( this, m_inputLocations,
                                                                                      Gaudi::DataHandle::Reader );
        if ( std::is_pointer<In>::value ) { // handle constructor does not (yet) allow to set optional flag... so do it
                                            // explicitly here...
          std::for_each( this->m_inputs.begin(), this->m_inputs.end(), []( auto& h ) { h.setOptional( true ); } );
        }
      } );
      p->useUpdateHandler(); // invoke call-back now, to be sure the input handles are synced with the property...
    }

    template <typename Out, typename In, typename Traits_>
    StatusCode MergingTransformer<Out( const vector_of_const_<In>& ), Traits_>::execute()
    {
      vector_of_const_<In> ins;
      ins.reserve( m_inputs.size() );
      std::transform( m_inputs.begin(), m_inputs.end(), std::back_inserter( ins ),
                      details::details2::get_from_handle<In>{} );
      try {
        using details::as_const;
        details::put( std::get<0>( this->m_outputs ), as_const( *this )( as_const( ins ) ) );
      } catch ( GaudiException& e ) {
        ( e.code() ? this->warning() : this->error() ) << e.message() << endmsg;
        return e.code();
      }
      return StatusCode::SUCCESS;
    }
  }
}

#endif