#include <xAODVariableProxyLoaders.h>

Inheritance diagram for ExpressionParsing::xAODElementProxyLoader:

Collaboration diagram for ExpressionParsing::xAODElementProxyLoader:

Public Types
using	VariableType = IAccessor::VariableType

Public Member Functions
	xAODElementProxyLoader ()=default
	xAODElementProxyLoader (const SG::AuxElement *auxElement)
void	setData (const SG::AuxElement *auxElement)
virtual IAccessor::VariableType	variableTypeFromString (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
virtual void	reset ()
virtual std::pair< IAccessor::VariableType, const IAccessor & >	getAccessorFromString (const EventContext &ctx, const std::string &varname) const override
virtual VariableType	variableType (const std::string &var_name) const override

Protected Types
using	accessorCache_t = CxxUtils::ConcurrentStrMap<BaseAccessorWrapper*, CxxUtils::SimpleUpdater>

Protected Member Functions
template<class TYPE, class AUX>
bool	try_type (const std::string &varname, const std::type_info ti, const AUX data) const
template<class AUX>
IAccessor::VariableType	try_all_known_types (const std::string &varname, const AUX *data, bool isVector) const

Protected Attributes
accessorCache_t m_accessorCache	ATLAS_THREAD_SAFE

Private Attributes
const SG::AuxElement *	m_auxElement {nullptr}

Detailed Description

Definition at line 169 of file xAODVariableProxyLoaders.h.

Member Typedef Documentation

◆ accessorCache_t

using ExpressionParsing::xAODProxyLoader::accessorCache_t = CxxUtils::ConcurrentStrMap<BaseAccessorWrapper*, CxxUtils::SimpleUpdater>

protectedinherited

Definition at line 164 of file xAODVariableProxyLoaders.h.

◆ VariableType

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

inherited

Definition at line 23 of file IProxyLoader.h.

Constructor & Destructor Documentation

◆ xAODElementProxyLoader() [1/2]

ExpressionParsing::xAODElementProxyLoader::xAODElementProxyLoader ( )

default

◆ xAODElementProxyLoader() [2/2]

ExpressionParsing::xAODElementProxyLoader::xAODElementProxyLoader ( const SG::AuxElement * auxElement )

Definition at line 249 of file xAODVariableProxyLoaders.cxx.

    : m_auxElement(auxElement)
  {
  }

Member Function Documentation

◆ getAccessorFromString()

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

inlineoverridevirtualinherited

Implements ExpressionParsing::IProxyLoader.

Definition at line 12 of file RelayProxyLoader.h.

                                                                                                               {
         return {variableTypeFromString(varname), *this};
      }

◆ loadDouble()

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

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 294 of file xAODVariableProxyLoaders.cxx.

  {
    return m_accessorCache.at(varname)->getDoubleValue(m_auxElement);
  }

◆ loadInt()

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

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 289 of file xAODVariableProxyLoaders.cxx.

  {
    return m_accessorCache.at(varname)->getIntValue(m_auxElement);
  }

◆ loadVec()

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

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 304 of file xAODVariableProxyLoaders.cxx.

  {
    throw std::runtime_error("xAODElementProxyLoader can't load vector types");
  }

◆ loadVecInt()

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

overridevirtual

Implements ExpressionParsing::IAccessor.

Definition at line 299 of file xAODVariableProxyLoaders.cxx.

  {
    throw std::runtime_error("xAODElementProxyLoader can't load vector types");
  }

◆ reset()

void ExpressionParsing::xAODProxyLoader::reset ( )

virtualinherited

Implements ExpressionParsing::IProxyLoader.

Definition at line 196 of file xAODVariableProxyLoaders.cxx.

  {
    for (auto x : m_accessorCache) delete x.second;
    // m_accessorCache.clear();  // not supported by ConcurrentStrMap
  }

◆ setData()

void ExpressionParsing::xAODElementProxyLoader::setData ( const SG::AuxElement * auxElement )

Definition at line 254 of file xAODVariableProxyLoaders.cxx.

  {
    m_auxElement = auxElement;
  }

◆ try_all_known_types()

template<class AUX>

IAccessor::VariableType ExpressionParsing::xAODProxyLoader::try_all_known_types	(	const std::string &	varname,
		const AUX *	data,
		bool	isVector ) const

protectedinherited

Definition at line 220 of file xAODVariableProxyLoaders.cxx.

  {
    const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
    const SG::auxid_t auxid = r.findAuxID(varname);
    if (auxid != SG::null_auxid) {
      const std::type_info *ti = r.getType(auxid);
      // Try integer types:
      if ( try_type<int>(varname, ti, data) ||
           try_type<bool>(varname, ti, data) ||
           try_type<unsigned int>(varname, ti, data) ||
           try_type<char>(varname, ti, data) ||
           try_type<uint8_t>(varname, ti, data) ||
           try_type<unsigned short>(varname, ti, data) ||
           try_type<short>(varname, ti, data) ) {
        return isVector ? IProxyLoader::VT_VECINT : IProxyLoader::VT_INT;
      }
      // Try floating point types:
      if ( try_type<float>(varname, ti, data) ||
           try_type<double>(varname, ti, data) ) {
        return isVector ? IProxyLoader::VT_VECDOUBLE : IProxyLoader::VT_DOUBLE;
      }
    }
    return VT_UNK;
  }

◆ try_type()

template<class TYPE, class AUX>

bool ExpressionParsing::xAODProxyLoader::try_type	(	const std::string &	varname,
		const std::type_info *	ti,
		const AUX *	data ) const

protectedinherited

Definition at line 203 of file xAODVariableProxyLoaders.cxx.

  {
    if (*ti == typeid(TYPE)) {
      auto accWrap = std::make_unique<AccessorWrapper<TYPE>>(varname);
      if (accWrap && accWrap->isValid(data)) {
        m_accessorCache.insert_or_assign(varname, accWrap.release());
        return true;
      } else if (accWrap) {
        const SG::AuxTypeRegistry& r = SG::AuxTypeRegistry::instance();
        const SG::auxid_t auxid = r.findAuxID(varname);
        throw std::runtime_error("Unsupported aux element type '"+r.getTypeName(auxid)+"' for '"+varname+"'");
      }
    }
    return false;
  }

◆ variableType()

virtual VariableType ExpressionParsing::RelayProxyLoader::variableType ( const std::string & var_name ) const

inlineoverridevirtualinherited

Implements ExpressionParsing::IAccessor.

Definition at line 15 of file RelayProxyLoader.h.

                                                                                                   {
         return IProxyLoader::VT_UNK;
      }

◆ variableTypeFromString()

IAccessor::VariableType ExpressionParsing::xAODElementProxyLoader::variableTypeFromString ( const std::string & varname ) const

overridevirtual

Implements ExpressionParsing::RelayProxyLoader.

Definition at line 259 of file xAODVariableProxyLoaders.cxx.

  {
    // Try TMethodWrapper
    auto container = m_auxElement->container();
    const std::type_info &containerTypeinfo = typeid(*container);
    TClass *containerClass = TClass::GetClass(containerTypeinfo);
    if (!containerClass) {
      containerClass = TClass::GetClass(SG::normalizedTypeinfoName(containerTypeinfo).c_str());
    }
    if (containerClass) {
      std::unique_ptr<TMethodWrapper> accWrap;
      if( !strcmp(containerClass->GetName(),"SG::AuxElementStandaloneData") ) { /* special case where the element type is the aux element */
        accWrap = std::make_unique<TMethodWrapper>( typeid(*m_auxElement) , varname );
      } else {
        TVirtualCollectionProxy* collProxy = containerClass->GetCollectionProxy();
        if(collProxy) {
          const std::type_info &elementTypeinfo = *(collProxy->GetValueClass()->GetTypeInfo());
          accWrap = std::make_unique<TMethodWrapper>(elementTypeinfo, varname);
        }
      }
      if (accWrap && accWrap->isValid(m_auxElement)) {
        const IAccessor::VariableType vtype = accWrap->variableType();
        m_accessorCache.insert_or_assign(varname, accWrap.release());
        return vtype;
      }
    }
 
    return try_all_known_types(varname, m_auxElement, false);
  }

Member Data Documentation

◆ ATLAS_THREAD_SAFE

accessorCache_t m_accessorCache ExpressionParsing::xAODProxyLoader::ATLAS_THREAD_SAFE

mutableprotectedinherited

Definition at line 165 of file xAODVariableProxyLoaders.h.

◆ m_auxElement

const SG::AuxElement* ExpressionParsing::xAODElementProxyLoader::m_auxElement {nullptr}

private

Definition at line 184 of file xAODVariableProxyLoaders.h.

184{nullptr};

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

Public Types

Public Member Functions

Protected Types

Protected Member Functions

Protected Attributes

Private Attributes

Detailed Description

Member Typedef Documentation

◆ accessorCache_t

◆ VariableType

Constructor & Destructor Documentation

◆ xAODElementProxyLoader() [1/2]

◆ xAODElementProxyLoader() [2/2]

Member Function Documentation

◆ getAccessorFromString()

◆ loadDouble()

◆ loadInt()

◆ loadVec()

◆ loadVecInt()

◆ reset()

◆ setData()

◆ try_all_known_types()

◆ try_type()

◆ variableType()

◆ variableTypeFromString()

Member Data Documentation

◆ ATLAS_THREAD_SAFE

◆ m_auxElement