ExpressionParserUser.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
/* Dear emacs, this is -*-c++-*- */
#ifndef _ExpressionParserUser_H_
#define _ExpressionParserUser_H_
 
#include <memory>
#include <string>
#include <vector>
#include <functional>
#include <type_traits>
#include <array>
#include "AthenaBaseComps/IDynamicDataConsumer.h"
#include "GaudiKernel/StatusCode.h"
#include "GaudiKernel/DataHandle.h"
 
#include "ExpressionEvaluation/IProxyLoader.h"
#include "ExpressionEvaluation/ExpressionParser.h"
 
// Forward declarations
namespace ExpressionParsing {
  class SGxAODProxyLoader;
  class MultipleProxyLoader;
  using AppendLoaderFunc = std::function<StatusCode(ExpressionParsing::MultipleProxyLoader &)>;
  inline StatusCode NoLoaderFunc(ExpressionParsing::MultipleProxyLoader &) { return StatusCode::SUCCESS;}

  template <unsigned short NUM_PARSER>
  class MultiParserHelper {
  public:
     static
     std::array< std::unique_ptr<ExpressionParsing::ExpressionParser>, NUM_PARSER >
     createParser(ExpressionParsing::IProxyLoader &proxy_loader,
                  const std::vector< std::string> &selection_string,
                  unsigned short num_parser);

     static
     std::vector<std::string> getVariables(const std::array<std::unique_ptr<ExpressionParsing::ExpressionParser>,NUM_PARSER> &parser);
  };

  class SingleParserHelper {
  public:
     static
     std::unique_ptr<ExpressionParsing::ExpressionParser>
     createParser(ExpressionParsing::IProxyLoader &proxy_loader,
                                     const std::string &selection_string,
                                     unsigned short num_parser);

     static
     std::vector<std::string> getVariables(const std::unique_ptr<ExpressionParsing::ExpressionParser> &parser);
 
  };

  template <unsigned short NUM_PARSER>
  using ParserHelper = typename std::conditional< NUM_PARSER == 1, class SingleParserHelper, class MultiParserHelper<NUM_PARSER> >::type;

  template <unsigned short NUM_PARSER>
  using SelectionArg  = typename std::conditional< NUM_PARSER == 1, std::string, std::vector< std::string > >::type;
}
 
 
template <class T_Base, unsigned short const NUM_PARSER>
class ExpressionParserUserBase
   : public T_Base,
     virtual public IDynamicDataConsumer
{
public:
   template <typename...Args>
   ExpressionParserUserBase(Args...args) : T_Base(args...) {}
   virtual ~ExpressionParserUserBase() = default;
 
 
   StatusCode finalizeParser();
 
   virtual bool updateDataNeeds(const std::vector<const DataObjID*> &input_data_in,
                                const std::vector<const DataObjID*> &output_data_in,
                                std::vector<Gaudi::DataHandle *> &new_input_handles,
                                std::vector<Gaudi::DataHandle *> &new_output_handles) override;
 
   virtual bool renounceInput( const DataObjID &output_data_id) override;
 
protected:
   StatusCode _initializeParser(const ExpressionParsing::SelectionArg<NUM_PARSER> &selection_string,
                                ExpressionParsing::AppendLoaderFunc pre_xaod_loader=ExpressionParsing::NoLoaderFunc,
                                ExpressionParsing::AppendLoaderFunc post_xaod_loader=ExpressionParsing::NoLoaderFunc);

   ExpressionParsing::SGxAODProxyLoader                *m_xAODProxyLoader = nullptr;
   std::unique_ptr<ExpressionParsing::IProxyLoader>     m_proxyLoaders;
   typename std::conditional< NUM_PARSER == 1,
                              std::unique_ptr<ExpressionParsing::ExpressionParser>,
                              std::array< std::unique_ptr<ExpressionParsing::ExpressionParser>, NUM_PARSER> >::type m_parser;
 
   std::vector<std::string>  m_renounce;
};
 
template <class T_Base, unsigned short const NUM_PARSER = 1>
class ExpressionParserUser :  public ExpressionParserUserBase<T_Base, NUM_PARSER>
{
public:
   template <typename...Args>
   ExpressionParserUser(Args&&...args)
    : ExpressionParserUserBase<T_Base,NUM_PARSER>(std::forward<Args>(args)...) {}
   StatusCode initializeParser(const ExpressionParsing::SelectionArg<NUM_PARSER> &selection_string);
 
};
#endif