ExpressionParsing::SGxAODProxyLoader Class Reference

Auxiliary class to access content of xAOD objects referred to by variables of an expressions handled by an instance of the ExpressionParser. More...

#include <SGxAODProxyLoader.h>

Inheritance diagram for ExpressionParsing::SGxAODProxyLoader:

Collaboration diagram for ExpressionParsing::SGxAODProxyLoader:

Classes
class	IParentHelper
	Interface of an auxiliary class to pass the parent, e.g. More...
class	ParentHelper
	Template of an auxiliary class to declare the new handles in the parent AthAlgTool, AthAlgorithm etc. More...
class	ReadHandleMapTmpl
	Particular map which is used to associate names to read handles of AuxElements or AuxVectorBase. More...

Public Types
typedef ServiceHandle< StoreGateSvc >	StoreGateSvc_t
enum	VariableType {   VT_UNK , VT_INT , VT_DOUBLE , VT_VECINT ,   VT_VECDOUBLE , VT_VECEMPTY }

Public Member Functions
	SGxAODProxyLoader (StoreGateSvc_t &evtStore, bool verbose=false)
virtual	~SGxAODProxyLoader ()
virtual void	reset ()
virtual IProxyLoader::VariableType	variableTypeFromString (const std::string &varname) const
virtual int	loadIntVariableFromString (const std::string &varname) const
virtual double	loadDoubleVariableFromString (const std::string &varname) const
virtual std::vector< int >	loadVecIntVariableFromString (const std::string &varname) const
virtual std::vector< double >	loadVecDoubleVariableFromString (const std::string &varname) const
bool	updateDataDependencies (SGxAODProxyLoader::IParentHelper &parent, const std::vector< std::string > &var_names, const std::vector< std::string > &renounce, 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)
	Create extra data dependencies arising eventually from the given variables.

Static Public Member Functions
template<class T>
static ParentHelper< T >	wrapParent (T *parent)
	auxiliary method to create the auxiliary class to declare new data handles with the calling AthAlgTool, AthAlgorithm etc.

Private Types
using	ReadHandleMap
using	ReadDecorHandleMap

Private Member Functions
void	splitVarnameIntoContainerAndMethod (const std::string &varname, std::string &containerName, std::string &methodName) const
IAccessor &	computeClassForVarname (const EventContext &ctx, std::unordered_map< std::string, CxxUtils::CachedUniquePtrT< IAccessor > >::const_iterator accessor_iter, const std::string &varname) const
	Auxiliary method to create an xAOD object content accessor for the given variable name.
std::pair< RootUtils::TSMethodCall, TVirtualCollectionProxy * >	getMethodCallAccessor (const std::string &method_name, const std::type_info &info) const
	Auxiliary method to create a TMethodCall and eventually also a collection proxy to call the given method of the specified container type.
IAccessor &	getAccessor (const EventContext &ctx, const std::string &varname) const
	Get an existing or create a new accessor for the given variable name.
template<class T_Aux>
std::unique_ptr< IAccessor >	createAccessor (const EventContext &ctx, const SG::ReadHandleKey< T_Aux > &key, const SG::ReadDecorHandleKey< T_Aux > *decor_key, SG::auxid_t method_id, const std::string &method_name) const
	Auxiliary method to create an accessor for the given method_name.

Private Attributes
StoreGateSvc_t	m_evtStore
ReadHandleMap	m_readKeys
ReadDecorHandleMap	m_decorKeys
std::unordered_map< std::string, CxxUtils::CachedUniquePtrT< IAccessor > >	m_accessor
	Association of variable names to accessors for corresponding xAOD object content.
std::unique_ptr< IAccessor >	m_emptyVectorAccessor
	Special accessor to handle empty vectors Accessor are constructed at time of first evaluation.
bool	m_verbose = false

Detailed Description

Auxiliary class to access content of xAOD objects referred to by variables of an expressions handled by an instance of the ExpressionParser.

Definition at line 46 of file SGxAODProxyLoader.h.

Member Typedef Documentation

ReadDecorHandleMap

using ExpressionParsing::SGxAODProxyLoader::ReadDecorHandleMap

private

Initial value:

 ReadHandleMapTmpl<SG::ReadDecorHandleKey<SG::AuxElement>,
                                                   SG::ReadDecorHandleKey<SG::AuxVectorBase> >

Definition at line 199 of file SGxAODProxyLoader.h.

ReadHandleMap

using ExpressionParsing::SGxAODProxyLoader::ReadHandleMap

private

Initial value:

 ReadHandleMapTmpl<SG::ReadHandleKey<SG::AuxElement>,
                                              SG::ReadHandleKey<SG::AuxVectorBase> >

Definition at line 197 of file SGxAODProxyLoader.h.

StoreGateSvc_t

typedef ServiceHandle<StoreGateSvc> ExpressionParsing::SGxAODProxyLoader::StoreGateSvc_t

Definition at line 49 of file SGxAODProxyLoader.h.

Member Enumeration Documentation

VariableType

enum ExpressionParsing::IProxyLoader::VariableType

inherited

Enumerator
VT_UNK
VT_INT
VT_DOUBLE
VT_VECINT
VT_VECDOUBLE
VT_VECEMPTY

Definition at line 21 of file IProxyLoader.h.

{ VT_UNK, VT_INT, VT_DOUBLE, VT_VECINT, VT_VECDOUBLE, VT_VECEMPTY };

Constructor & Destructor Documentation

SGxAODProxyLoader()

ExpressionParsing::SGxAODProxyLoader::SGxAODProxyLoader	(	StoreGateSvc_t &	evtStore,
		bool	verbose = false )

Definition at line 42 of file SGxAODProxyLoader.cxx.

: m_evtStore(evtStore), m_emptyVectorAccessor(std::make_unique<EmptyVectorAccessor>()),m_verbose(verbose) { }

~SGxAODProxyLoader()

ExpressionParsing::SGxAODProxyLoader::~SGxAODProxyLoader ( )

virtual

Definition at line 44 of file SGxAODProxyLoader.cxx.

  {
  }

Member Function Documentation

computeClassForVarname()

IAccessor & ExpressionParsing::SGxAODProxyLoader::computeClassForVarname ( const EventContext & ctx, std::unordered_map< std::string, CxxUtils::CachedUniquePtrT< IAccessor > >::const_iterator accessor_iter, const std::string & varname ) const

private

Auxiliary method to create an xAOD object content accessor for the given variable name.

Parameters

ctx	the current event context
accessor_iter	location where the newly created accessor will be stored.
varname	the variable name which defines the xAOD container and the content.

Definition at line 138 of file SGxAODProxyLoader.cxx.

  {
    const IProxyDict *proxy = Atlas::getExtendedEventContext( ctx ).proxy();
    (void) proxy;
    std::string container_name;
    std::string method_name;
    splitVarnameIntoContainerAndMethod(varname,container_name, method_name);
    ReadHandleMap::const_iterator key_iter = m_readKeys.find(container_name);
    if (key_iter == m_readKeys.end()) {
       std::stringstream msg;
       msg << "No read handle key for " << container_name;
       throw std::runtime_error(msg.str());
    }
    SG::auxid_t method_id = SG::null_auxid;
    ReadDecorHandleMap::const_iterator decor_key_iter = m_decorKeys.end();
    if  (ReadHandleMap::isVector(key_iter->second) || ReadHandleMap::isElement(key_iter->second)) {
       method_id = SG::AuxTypeRegistry::instance().findAuxID(method_name,"");
       if (method_id != SG::null_auxid) {
          decor_key_iter=m_decorKeys.find(varname);
       }
    }
    std::unique_ptr<IAccessor> accessor;
    if (ReadHandleMap::isVector(key_iter->second)) {
       if (m_verbose) { std::cout << "DEBUG SGxAODProxyLoader::computeClassForVarname is Vector: " << varname << std::endl; }
       accessor = createAccessor(ctx,
                                 ReadHandleMap::vectorKey(key_iter->second),
                                 (decor_key_iter != m_decorKeys.end() ? &ReadDecorHandleMap::vectorKey(decor_key_iter->second) : nullptr),
                                 method_id,
                                 method_name);
    }
    else if (ReadHandleMap::isElement(key_iter->second)) {
       if (m_verbose) { std::cout << "DEBUG SGxAODProxyLoader::computeClassForVarname is element: " << varname << std::endl; }
       accessor = createAccessor(ctx,
                                 ReadHandleMap::elementKey(key_iter->second),
                                 (decor_key_iter != m_decorKeys.end() ? &ReadDecorHandleMap::elementKey(decor_key_iter->second) : nullptr),
                                 method_id,
                                 method_name);
    }
    else {
       if (m_verbose) { std::cout << "DEBUG SGxAODProxyLoader::computeClassForVarname try to create plain type accessor for " << varname << std::endl; }
       accessor = PlainAccessorFactory::instance().createAccessor(key_iter->second);
    }
    if (!accessor) {
       return *m_emptyVectorAccessor;
    }
    IAccessor* accessorPlainPtr = accessor.get();//avoid Wpotentially-evaluated-expression from typeid
    if (m_verbose) {
      std::cout << "DEBUG SGxAODProxyLoader use accessor "
                << typeid(*accessorPlainPtr).name() << " for " << varname
                << std::endl;
    }
    accessor_iter->second.set(std::move(accessor));
    return *(accessor_iter->second);
  }

createAccessor()

template<class T_Aux>

std::unique_ptr< IAccessor > ExpressionParsing::SGxAODProxyLoader::createAccessor ( const EventContext & ctx, const SG::ReadHandleKey< T_Aux > & key, const SG::ReadDecorHandleKey< T_Aux > * decor_key, SG::auxid_t method_id, const std::string & method_name ) const

private

Auxiliary method to create an accessor for the given method_name.

Parameters

ctx	the current event context.
key	a valid read handle key to retrieve the corresponding container.
decor_key	a valid read handle key or nullptr to create a decoration handle for the given method
method_id	the xAOD ID of the given method
the	name of the method.

Returns

returns an accessor for the xAOD content.

Definition at line 114 of file SGxAODProxyLoader.cxx.

   {
      SG::ReadHandle<T_Aux> handle(key, ctx);
      if (!handle.isValid()) {
         std::stringstream msg;
         msg << "Failed to get " << key.key();
            throw std::runtime_error(msg.str());
      }
      if (getContainerSize(*handle)==0) {
         return std::unique_ptr<IAccessor>();
      }
      if (!isAvailable(*handle,method_id)) {
         std::pair<RootUtils::TSMethodCall,TVirtualCollectionProxy *> method = getMethodCallAccessor(method_name, typeid(*handle));
         return MethodAccessorFactory::instance().create( key, std::move(method.first), method.second);
      }
      else {
         return ExpressionParsing::AccessorFactory::instance().create( key, method_id , decor_key );
      }
   }

getAccessor()

IAccessor & ExpressionParsing::SGxAODProxyLoader::getAccessor ( const EventContext & ctx, const std::string & varname ) const

inlineprivate

Get an existing or create a new accessor for the given variable name.

Parameters

ctx	the current event context
varname	the name of the variable for which an accessor will be returned. The event context is needed if a new accessor has to be created to gather information about the type which the variable refers to.

Definition at line 138 of file SGxAODProxyLoader.h.

                                                                                      {
         std::unordered_map<std::string, CxxUtils::CachedUniquePtrT<IAccessor> >::const_iterator
            accessor_iter = m_accessor.find(varname);
         if (accessor_iter == m_accessor.end()) {
            std::stringstream msg;
            msg << "No accessor stub was created for  " << varname << " i.e. variable is unknown.";
            throw std::runtime_error(msg.str());
         }
         if (accessor_iter->second) return *(accessor_iter->second);
         return computeClassForVarname(ctx,accessor_iter, varname);
      }

getMethodCallAccessor()

std::pair< RootUtils::TSMethodCall, TVirtualCollectionProxy * > ExpressionParsing::SGxAODProxyLoader::getMethodCallAccessor ( const std::string & method_name, const std::type_info & info ) const

private

Auxiliary method to create a TMethodCall and eventually also a collection proxy to call the given method of the specified container type.

Parameters

method_name	the name of the method to be called.
info	the type_info of the container whose method is to be called.

Returns

a TMethodCall object and optionally collection proxy which is owned by ROOT(?)

Definition at line 62 of file SGxAODProxyLoader.cxx.

                                                                                                        {
     if (m_verbose) {
        std::cout << "DEBUG SGxAODProxyLoader search for " << method_name << " in type " << info.name() << std::endl;
     }
     TClass *containerClass = TClass::GetClass(info);
     if (!containerClass) {
        if (m_verbose) {
           std::cout << "DEBUG SGxAODProxyLoader search for " << method_name << " in normalisze type " << SG::normalizedTypeinfoName(info) << std::endl;
        }
        containerClass = TClass::GetClass(SG::normalizedTypeinfoName(info).c_str());
        if (!containerClass) {
           std::stringstream msg;
           msg << "No dictionary for " << info.name() << std::endl;
           throw std::runtime_error(msg.str());
        }
     }
     TClass *elementClass=nullptr;
     TVirtualCollectionProxy *collection_proxy=nullptr;
     if( strcmp(containerClass->GetName(),"SG::AuxElementStandaloneData")==0 ) {
        elementClass=containerClass;
     }
     else {
        collection_proxy = containerClass->GetCollectionProxy();
        elementClass = (collection_proxy ? collection_proxy->GetValueClass()  : nullptr);
        if (!elementClass) {
           std::stringstream msg;
           msg << "No collection proxy or element class for " << info.name() << std::endl;
           throw std::runtime_error(msg.str());
        }
     }
     RootUtils::TSMethodCall method_call;
     method_call.setProto (elementClass, method_name, "",
                           ROOT::kConversionMatch);
     if (!method_call.call() || !method_call.call()->IsValid()) {
        std::stringstream msg;
        msg << "No valid method " << method_name << " for " << info.name() << std::endl;
        throw std::runtime_error(msg.str());
     }
     if (m_verbose && method_call.call()->GetMethod()) {
        // @TODO check signature "() const
        std::cout << "DEBUG SGxAODProxyLoader got method " << " . " << method_name << " : "
                  << method_call.call()->GetMethod()->GetReturnTypeNormalizedName ()
                  << " proto=" << method_call.call()->GetProto()
                  << " signature=" << method_call.call()->GetMethod()->GetSignature ()
                  << " proto=" << method_call.call()->GetMethod()->GetPrototype()
                  << std::endl;
     }
     return std::make_pair( method_call, collection_proxy);
  }

loadDoubleVariableFromString()

double ExpressionParsing::SGxAODProxyLoader::loadDoubleVariableFromString ( const std::string & varname ) const

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 224 of file SGxAODProxyLoader.cxx.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    return dump(varname,getAccessor(ctx, varname).loadDouble(ctx));
  }

loadIntVariableFromString()

int ExpressionParsing::SGxAODProxyLoader::loadIntVariableFromString ( const std::string & varname ) const

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 218 of file SGxAODProxyLoader.cxx.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    return dump(varname,getAccessor(ctx, varname).loadInt(ctx));
  }

loadVecDoubleVariableFromString()

std::vector< double > ExpressionParsing::SGxAODProxyLoader::loadVecDoubleVariableFromString ( const std::string & varname ) const

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 236 of file SGxAODProxyLoader.cxx.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    return dump(varname,getAccessor(ctx, varname).loadVec(ctx));
  }

loadVecIntVariableFromString()

std::vector< int > ExpressionParsing::SGxAODProxyLoader::loadVecIntVariableFromString ( const std::string & varname ) const

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 230 of file SGxAODProxyLoader.cxx.

  {
    const EventContext& ctx = Gaudi::Hive::currentContext();
    return dump(varname,getAccessor(ctx, varname).loadVecInt(ctx));
  }

reset()

void ExpressionParsing::SGxAODProxyLoader::reset ( )

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 48 of file SGxAODProxyLoader.cxx.

                                 {
     m_decorKeys.clear();
     m_readKeys.clear();
     m_accessor.clear();
  }

splitVarnameIntoContainerAndMethod()

void ExpressionParsing::SGxAODProxyLoader::splitVarnameIntoContainerAndMethod ( const std::string & varname, std::string & containerName, std::string & methodName ) const

private

Definition at line 54 of file SGxAODProxyLoader.cxx.

  {
    size_t dotPosition = varname.find('.');
    containerName = varname.substr(0, dotPosition);
    methodName = varname.substr(dotPosition + 1);
  }

updateDataDependencies()

bool ExpressionParsing::SGxAODProxyLoader::updateDataDependencies	(	SGxAODProxyLoader::IParentHelper &	parent,
		const std::vector< std::string > &	var_names,
		const std::vector< std::string > &	renounce,
		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 )

Create extra data dependencies arising eventually from the given variables.

Parameters

parent	auxiliary class to declare new data handles with the calling parent
var_names	the variables for which data dependencies might be created.
renounce	a list of output data keys, which should be renounced from the new_input_handles list.
input_data_in	read data object IDs declared by all algorithms and tools
output_data_in	write data object IDs declared by all algorithms and tools
new_input_handles	will be filled with read data handles newly created by this loader
new_output_handles	will be filled with write data handles newly created by this loader (unused).

Returns

true if new handles have been declared.

Definition at line 242 of file SGxAODProxyLoader.cxx.

  {
     (void) new_output_handles;
     std::size_t initial_size=m_decorKeys.size()+m_readKeys.size();
     for (const std::string &var_name : var_names) {
        if (   m_decorKeys.find(var_name)!= m_decorKeys.end()) continue;
        std::string container_name;
        std::string method_name;
        splitVarnameIntoContainerAndMethod(var_name,container_name, method_name);
        if (m_verbose) {
           std::cout << "DEBUG SGxAODProxyLoader::updateDataDependencies var " << var_name << " -> "  << container_name << " . " << method_name
                     << " i:" << input_data_in.size() << " o:" << output_data_in.size()
                     << std::endl;
        }
        const DataObjID *container_data_id=nullptr;
        const DataObjID *method_data_id=nullptr;
        bool verbose = m_verbose;
 
        // Decide whether a variable just needs a container read handle key or a read decor handle key.
        // Search in data handles for data handles and decor handles:
        //   decor handle : "container_name.decoration_name"
        //   data handle  : "container_name"
        // if a decor handle is found assume that it is a decoration, otherwise assume that it is either a default aux item
        // or refers to  a method call
        auto set_ids = [&method_data_id,&container_data_id,&var_name,&container_name,verbose](const DataObjID *obj_data_id) -> bool {
                              std::string_view handle_key(obj_data_id->key());
                              std::string::size_type pos=obj_data_id->key().find('+');
                              pos =  (pos==std::string::npos  ?  0 : pos+1);
                              handle_key=handle_key.substr(pos,handle_key.size()-pos);
                              if (verbose && (handle_key == container_name || handle_key == var_name)) {
                                 const SG::BaseInfoBase* base_info = SG::BaseInfoBase::find (obj_data_id->clid());
                                 std::cout << "DEBUG SGxAODProxyLoader::updateDataDependencies " << handle_key << " matches " << var_name <<  " ? "
                                           << (handle_key == var_name ? " method " : "")
                                           << (handle_key == container_name ? " container " : "")
                                           << "-> " << (base_info ? base_info->typeinfo().name() : "")
                                           << std::endl;
                              }
                              if (handle_key == var_name) {
                                 method_data_id = obj_data_id;
                                 if (container_data_id) return true;
                              }
                              else if (handle_key == container_name ) {
                                 container_data_id = obj_data_id;
                                 if (method_data_id) return true;
                              }
                              return false;
                           };
        // start with output handles which are expected to contain the decorator handles
        for( std::vector<const DataObjID *>::const_iterator elm_iter = output_data_in.begin(); elm_iter != output_data_in.end() && !set_ids(*elm_iter); ++elm_iter) {}
        if (!method_data_id) {
           for( std::vector<const DataObjID *>::const_iterator elm_iter = input_data_in.begin(); elm_iter != input_data_in.end() && !set_ids(*elm_iter); ++elm_iter) {}
        }
        if (method_data_id) {
           if (!container_data_id) {
              container_data_id=method_data_id;
           }
        }
        // ---DEBUG
        if (m_verbose && method_data_id && method_data_id != container_data_id) {
           std::cout << "DEBUG SGxAODProxyLoader method_clid "    << method_data_id->clid() << std::endl;
        }
        if (m_verbose && container_data_id) {
           std::cout << "DEBUG SGxAODProxyLoader container_clid " << container_data_id->clid() << std::endl;
        }
        // ___DEBUG
 
        if (container_data_id) {
           m_accessor.insert( std::make_pair(var_name, CxxUtils::CachedUniquePtrT<IAccessor>()));
           bool have_container_read_key = m_readKeys.find(container_name) != m_readKeys.end();
           if (have_container_read_key && !method_data_id) continue;
 
           auto clid = container_data_id->clid();
           (void) clid;
           const SG::BaseInfoBase* base_info = (container_data_id ? SG::BaseInfoBase::find (container_data_id->clid()) : nullptr);
           if (!base_info) {
              std::stringstream msg;
              msg << "Missing type information about container " << container_name << ".";
              if (container_data_id) {
                 msg << " It seems that inheritance information is missing for " << container_data_id->className() << "."
                     << " Only container which inherit from SG::AuxVectorBase or data inheriting from  SG::AuxElement "
                     << " are supported by the SGxAODProxyLoader loader.";
              }
              else {
                  msg << " This problem may occur if the container is read from the input"
                      << " file and not accessed anywhere in the job via read handles. ";
              }
              throw std::runtime_error(msg.str());
           }
           // ---DEBUG
           if (m_verbose && base_info) {
              std::cout << "DEBUG SGxAODProxyLoader " << container_name << " -> " << base_info->typeinfo().name() << std::endl;
              for ( CLID clid :  base_info->get_bases ()) {
                 const SG::BaseInfoBase* a_base_info = SG::BaseInfoBase::find (clid);
                 std::cout << "DEBUG SGxAODProxyLoader " << container_name << " base: " << a_base_info->typeinfo().name() << std::endl;
              }
           }
           // ___DEBUG
 
 
           std::any read_key;
           std::any decor_key;
           if (base_info->is_base(ClassID_traits<SG::AuxVectorBase>::ID())) {
              if (!have_container_read_key) {
                 read_key = std::make_any<SG::ReadHandleKey<SG::AuxVectorBase> >(container_name);
              }
              if (method_data_id) {
                 decor_key = std::make_any<SG::ReadDecorHandleKey<SG::AuxVectorBase> >(var_name);
              }
           }
           else if (base_info->is_base(ClassID_traits<SG::AuxElement>::ID())) {
              if (!have_container_read_key) {
                 read_key = std::make_any<SG::ReadHandleKey<SG::AuxElement> >(container_name);
              }
              if (method_data_id) {
                 decor_key = std::make_any<SG::ReadDecorHandleKey<SG::AuxElement> >(var_name);
              }
           }
           else {
              if (method_data_id && method_data_id != container_data_id && method_data_id->clid() != container_data_id->clid()) {
                 std::stringstream msg;
                 msg << "Did not expect a \"method\" handle for the plain type " << var_name;
                 throw std::logic_error(msg.str());
              }
              bool registered_key =  PlainAccessorFactory::instance().registerReadKey(m_readKeys, base_info->typeinfo(), parent, var_name, new_input_handles, m_verbose);
              if (registered_key) {
                 popRenounced(renounce, new_input_handles);
                 continue;
              }
           }
 
           if (!have_container_read_key) {
              if (!read_key.has_value()) {
                 std::stringstream msg;
                 msg << "Container  " << container_name << " is of unsupported type " << base_info->typeinfo().name()
                     << " expected a type derived from SG::AuxVectorBase or SG::AuxElement";
                 throw std::runtime_error(msg.str());
              }
              std::pair<ReadHandleMap::iterator, bool> ret = m_readKeys.insert(std::make_pair(container_name, std::move(read_key)));
              if (ret.second) {
                 if (   (ReadHandleMap::isVector(ret.first->second)  && parent.declare(ReadHandleMap::vectorKey(ret.first->second)).isFailure())
                     || (ReadHandleMap::isElement(ret.first->second) && parent.declare(ReadHandleMap::elementKey(ret.first->second)).isFailure())) {
                    std::stringstream msg;
                    msg << "Failed to add read handle key for " << container_name;
                    throw std::runtime_error(msg.str());
                 }
                 if (m_verbose) {
                    if (ReadHandleMap::isVector(ret.first->second)) dumpDeclare(&ReadHandleMap::vectorKey(ret.first->second) );
                    else                                            dumpDeclare(&ReadHandleMap::elementKey(ret.first->second));
                 }
                 if (ReadHandleMap::isVector(ret.first->second)) initializeHandle(&ReadHandleMap::vectorKey(ret.first->second), new_input_handles);
                 else                                            initializeHandle(&ReadHandleMap::elementKey(ret.first->second),new_input_handles);
                 popRenounced(renounce, new_input_handles);
 
              }
           }
           if (method_data_id) {
              if (!decor_key.has_value()) {
                 std::stringstream msg;
                 msg << "Container  " << container_name << " is of unsupported type " << base_info->typeinfo().name()
                     << " expected a type derived from SG::AuxVectorBase or SG::AuxElement";
                 throw std::runtime_error(msg.str());
              }
              std::pair<ReadDecorHandleMap::iterator, bool> ret = m_decorKeys.insert(std::make_pair(var_name,std::move(decor_key)));
              if (ret.second) {
                 if (   (ReadDecorHandleMap::isVector(ret.first->second)  && parent.declare(ReadDecorHandleMap::vectorKey(ret.first->second)).isFailure())
                     || (!ReadDecorHandleMap::isVector(ret.first->second) && parent.declare(ReadDecorHandleMap::elementKey(ret.first->second)).isFailure())) {
                    std::stringstream msg;
                    msg << "Failed to add read decor handle key for " << var_name;
                    throw std::runtime_error(msg.str());
                 }
                 if (m_verbose) {
                    if (ReadDecorHandleMap::isVector(ret.first->second)) dumpDeclare(&ReadDecorHandleMap::vectorKey(ret.first->second) );
                    else                                                 dumpDeclare(&ReadDecorHandleMap::elementKey(ret.first->second));
                 }
                 if (ReadDecorHandleMap::isVector(ret.first->second)) initializeHandle(&ReadDecorHandleMap::vectorKey(ret.first->second),new_input_handles );
                 else                                                 initializeHandle(&ReadDecorHandleMap::elementKey(ret.first->second),new_input_handles);
                 popRenounced(renounce, new_input_handles);
              }
           }
        }
     }
     return initial_size != m_decorKeys.size()+m_readKeys.size();
  }

variableTypeFromString()

IProxyLoader::VariableType ExpressionParsing::SGxAODProxyLoader::variableTypeFromString ( const std::string & varname ) const

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 195 of file SGxAODProxyLoader.cxx.

                                                                                                   {
     const EventContext& ctx = Gaudi::Hive::currentContext();
     return getAccessor(ctx, varname).variableType();
  }

wrapParent()

template<class T>

ParentHelper< T > ExpressionParsing::SGxAODProxyLoader::wrapParent ( T * parent )

inlinestatic

auxiliary method to create the auxiliary class to declare new data handles with the calling AthAlgTool, AthAlgorithm etc.

Definition at line 90 of file SGxAODProxyLoader.h.

                                                   {
         return ParentHelper<T>(parent);
      }

Member Data Documentation

m_accessor

std::unordered_map<std::string, CxxUtils::CachedUniquePtrT<IAccessor> > ExpressionParsing::SGxAODProxyLoader::m_accessor

private

Association of variable names to accessors for corresponding xAOD object content.

The map structure is constructed before the event loop. The content of its leaves is completed during the event loop.

Definition at line 208 of file SGxAODProxyLoader.h.

m_decorKeys

ReadDecorHandleMap ExpressionParsing::SGxAODProxyLoader::m_decorKeys

private

Definition at line 202 of file SGxAODProxyLoader.h.

m_emptyVectorAccessor

std::unique_ptr<IAccessor> ExpressionParsing::SGxAODProxyLoader::m_emptyVectorAccessor

private

Special accessor to handle empty vectors Accessor are constructed at time of first evaluation.

This fails for empty containers because empty container do not necessarily provide enough type information to create the correct accessor. This is mitigated by this special accessor which is used until the final accessor can be created.

Definition at line 216 of file SGxAODProxyLoader.h.

m_evtStore

StoreGateSvc_t ExpressionParsing::SGxAODProxyLoader::m_evtStore

private

Definition at line 165 of file SGxAODProxyLoader.h.

m_readKeys

ReadHandleMap ExpressionParsing::SGxAODProxyLoader::m_readKeys

private

Definition at line 201 of file SGxAODProxyLoader.h.

m_verbose

bool ExpressionParsing::SGxAODProxyLoader::m_verbose = false

private

Definition at line 217 of file SGxAODProxyLoader.h.

---

The documentation for this class was generated from the following files:

• SGxAODProxyLoader.h
• SGxAODProxyLoader.cxx