ExpressionParsing::xAODVectorProxyLoader Class Reference

#include <xAODVariableProxyLoaders.h>

Inheritance diagram for ExpressionParsing::xAODVectorProxyLoader:

Collaboration diagram for ExpressionParsing::xAODVectorProxyLoader:

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

Public Member Functions
	xAODVectorProxyLoader ()=default
	xAODVectorProxyLoader (const SG::AuxVectorData *auxVectorData)
void	setData (const SG::AuxVectorData *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::AuxVectorData *	m_auxVectorData {nullptr}

Detailed Description

Definition at line 187 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

xAODVectorProxyLoader() [1/2]

ExpressionParsing::xAODVectorProxyLoader::xAODVectorProxyLoader ( )

default

xAODVectorProxyLoader() [2/2]

ExpressionParsing::xAODVectorProxyLoader::xAODVectorProxyLoader

(

const SG::AuxVectorData *

auxVectorData

)

Definition at line 312 of file xAODVariableProxyLoaders.cxx.

    : m_auxVectorData(auxVectorData)
  {
  }

Member Function Documentation

loadDoubleVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 351 of file xAODVariableProxyLoaders.cxx.

  {
    throw std::runtime_error("xAODVectorProxyLoader can't load scalar types");
  }

loadIntVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 346 of file xAODVariableProxyLoaders.cxx.

  {
    throw std::runtime_error("xAODVectorProxyLoader can't load scalar types");
  }

loadVecDoubleVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 361 of file xAODVariableProxyLoaders.cxx.

  {/*
     // Check whether we have an accessor already:
     std::map< std::string, BaseAccessorWrapper* >::const_iterator itr;
     if( ( itr = m_accessorCache.find( varname ) ) == m_accessorCache.end() ) {
        // For an empty container let's not bother too much:
        if( m_auxVectorData->size_v() == 0 ) {
           return std::vector< double >();
        }
        // If it's not empty, then let the variableTypeFromString function
        // figure out the variable type, and create the accessor:
        if( variableTypeFromString( varname ) == VT_UNK ) {
           throw std::runtime_error( "Couldn't find variable type for " +
                                     varname );
        }
        // Update the iterator:
        itr = m_accessorCache.find( varname );
     }
     // Now do the "regular thing". Note that even if the type turns out
     // to be an integer type, the accessor wrapper does the conversion
     // reasonably anyway, behind the scenes.
     return itr->second->getVecDoubleValue(m_auxVectorData);*/
    return m_accessorCache.at(varname)->getVecDoubleValue(m_auxVectorData);
  }

loadVecIntVariableFromString()

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

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 356 of file xAODVariableProxyLoaders.cxx.

  {
    return m_accessorCache.at(varname)->getVecIntValue(m_auxVectorData);
  }

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::xAODVectorProxyLoader::setData

(

const SG::AuxVectorData *

auxElement

)

Definition at line 317 of file xAODVariableProxyLoaders.cxx.

  {
    m_auxVectorData = auxVectorData;
  }

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::xAODVectorProxyLoader::variableTypeFromString ( const std::string & varname ) const

virtual

Implements ExpressionParsing::IProxyLoader.

Definition at line 322 of file xAODVariableProxyLoaders.cxx.

  {
    auto accWrap = std::make_unique<TMethodCollectionWrapper>(typeid(*m_auxVectorData), varname);
    if (accWrap && accWrap->isValid(m_auxVectorData)) {
      const IProxyLoader::VariableType vtype = accWrap->variableType();
      m_accessorCache.insert_or_assign(varname, accWrap.release());
      return vtype;
    }
 
    IProxyLoader::VariableType vtype = try_all_known_types(varname, m_auxVectorData, true);
 
    // Before giving up completely, check the size of the vector. If it's
    // 0, it may be that it's empty on *all* events of the current input
    // file. Meaning that dynamic variables will be missing from each event.
    if( vtype==VT_UNK && m_auxVectorData->size_v() == 0 ) {
       // Let's claim a vector<double> type, that seems to be the safest bet.
       // Even if the variable should actually be vector<int>, this is a
       // simple conversion at least.
       vtype = VT_VECDOUBLE;
    }
 
    return vtype;
  }

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_auxVectorData

const SG::AuxVectorData* ExpressionParsing::xAODVectorProxyLoader::m_auxVectorData {nullptr}

private

Definition at line 201 of file xAODVariableProxyLoaders.h.

{nullptr};

---

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

• xAODVariableProxyLoaders.h
• xAODVariableProxyLoaders.cxx