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
using	VariableType = IAccessor::VariableType

Public Member Functions
	SGxAODProxyLoader (StoreGateSvc_t &evtStore, bool verbose=false)
virtual	~SGxAODProxyLoader ()
virtual void	reset () override
virtual VariableType	variableType (const std::string &var_name) const override
virtual std::pair< IProxyLoader::VariableType, const IAccessor & >	getAccessorFromString (const EventContext &ctx, const std::string &varname) const override
virtual int	loadInt (const EventContext &ctx, const std::string &varname) const override
virtual double	loadDouble (const EventContext &ctx, const std::string &varname) const override
virtual std::vector< int >	loadVecInt (const EventContext &ctx, const std::string &varname) const override
virtual std::vector< double >	loadVec (const EventContext &ctx, const std::string &varname) const override
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 47 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 203 of file SGxAODProxyLoader.h.

ReadHandleMap

using ExpressionParsing::SGxAODProxyLoader::ReadHandleMap

private

Initial value:

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

Definition at line 201 of file SGxAODProxyLoader.h.

StoreGateSvc_t

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

Definition at line 50 of file SGxAODProxyLoader.h.

VariableType

using ExpressionParsing::IProxyLoader::VariableType = IAccessor::VariableType

inherited

Definition at line 23 of file IProxyLoader.h.

Constructor & Destructor Documentation

SGxAODProxyLoader()

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

Definition at line 43 of file SGxAODProxyLoader.cxx.

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

~SGxAODProxyLoader()

ExpressionParsing::SGxAODProxyLoader::~SGxAODProxyLoader ( )

virtual

Definition at line 45 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 130 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 105 of file SGxAODProxyLoader.cxx.

   {
      SG::ReadHandle<T_Aux> handle(key, ctx);
      if (!handle.isValid()) {
         std::stringstream amsg;
         amsg << "Failed to get " << key.key();
         throw std::runtime_error(amsg.str());
      }
      if (getContainerSize(*handle)==0) {
         return std::unique_ptr<IAccessor>();
      }
      if (!isAvailable(*handle,method_id)) {
         auto [method_wrapper, proxy]
            = details::getMethodCallAccessor(method_name, typeid(*handle), m_verbose);
         return MethodAccessorFactory::instance().create( key, std::move(method_wrapper), proxy);
      }
      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 142 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);
      }

getAccessorFromString()

std::pair< IProxyLoader::VariableType, const IAccessor & > ExpressionParsing::SGxAODProxyLoader::getAccessorFromString ( const EventContext & ctx, const std::string & varname ) const

overridevirtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 200 of file SGxAODProxyLoader.cxx.

                                                                                                  {
     const IAccessor &accessor = getAccessor(ctx, varname);
     return {accessor.variableType(varname), accessor};
  }

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(?)

loadDouble()

double ExpressionParsing::SGxAODProxyLoader::loadDouble ( const EventContext & ctx, const std::string & varname ) const

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 228 of file SGxAODProxyLoader.cxx.

  {
    return dump(varname,getAccessor(ctx, varname).loadDouble(ctx,varname));
  }

loadInt()

int ExpressionParsing::SGxAODProxyLoader::loadInt ( const EventContext & ctx, const std::string & varname ) const

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 223 of file SGxAODProxyLoader.cxx.

  {
    return dump(varname,getAccessor(ctx, varname).loadInt(ctx,varname));
  }

loadVec()

std::vector< double > ExpressionParsing::SGxAODProxyLoader::loadVec ( const EventContext & ctx, const std::string & varname ) const

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 238 of file SGxAODProxyLoader.cxx.

  {
    return dump(varname,getAccessor(ctx, varname).loadVec(ctx,varname));
  }

loadVecInt()

std::vector< int > ExpressionParsing::SGxAODProxyLoader::loadVecInt ( const EventContext & ctx, const std::string & varname ) const

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 233 of file SGxAODProxyLoader.cxx.

  {
    return dump(varname,getAccessor(ctx, varname).loadVecInt(ctx,varname));
  }

reset()

void ExpressionParsing::SGxAODProxyLoader::reset ( )

overridevirtual

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 243 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();
  }

variableType()

IAccessor::VariableType ExpressionParsing::SGxAODProxyLoader::variableType ( const std::string & var_name ) const

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 187 of file SGxAODProxyLoader.cxx.

                                                                                      {
    // This method has to be implemented because it is part of the interface
    // but the SGxAODProxyLoader will return pointers to different IAccesor objects
    // depending on the situation and the method variableType will be called of those
    // objects. Thus, there is really no need to pass the event context through, because
    // this method is never called and the event context would not be used in all other cases.
    const EventContext& ctx = Gaudi::Hive::currentContext();
    std::pair< IProxyLoader::VariableType, const IAccessor &>
       ret = getAccessorFromString(ctx, varname);
     return ret.first;
  }

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 94 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 212 of file SGxAODProxyLoader.h.

m_decorKeys

ReadDecorHandleMap ExpressionParsing::SGxAODProxyLoader::m_decorKeys

private

Definition at line 206 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 220 of file SGxAODProxyLoader.h.

m_evtStore

StoreGateSvc_t ExpressionParsing::SGxAODProxyLoader::m_evtStore

private

Definition at line 169 of file SGxAODProxyLoader.h.

m_readKeys

ReadHandleMap ExpressionParsing::SGxAODProxyLoader::m_readKeys

private

Definition at line 205 of file SGxAODProxyLoader.h.

m_verbose

bool ExpressionParsing::SGxAODProxyLoader::m_verbose = false

private

Definition at line 221 of file SGxAODProxyLoader.h.

---

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

• SGxAODProxyLoader.h
• SGxAODProxyLoader.cxx