ExpressionParsing::xAODElementProxyLoader Class Reference

#include <xAODVariableProxyLoaders.h>

Inheritance diagram for ExpressionParsing::xAODElementProxyLoader:

Collaboration diagram for ExpressionParsing::xAODElementProxyLoader:

Public Types
enum	VariableType {   VT_UNK , VT_INT , VT_DOUBLE , VT_VECINT ,   VT_VECDOUBLE , VT_VECEMPTY }

Public Member Functions
	xAODElementProxyLoader ()=default
	xAODElementProxyLoader (const SG::AuxElement *auxElement)
void	setData (const SG::AuxElement *auxElement)
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
virtual void	reset ()

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>
IProxyLoader::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.

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

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

loadDoubleVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 294 of file xAODVariableProxyLoaders.cxx.

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

loadIntVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 289 of file xAODVariableProxyLoaders.cxx.

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

loadVecDoubleVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 304 of file xAODVariableProxyLoaders.cxx.

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

loadVecIntVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

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>

IProxyLoader::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;
  }

variableTypeFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

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 IProxyLoader::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 183 of file xAODVariableProxyLoaders.h.

{nullptr};

---

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

• xAODVariableProxyLoaders.h
• xAODVariableProxyLoaders.cxx