Namespace holding all the expression evaluation code. More...

Namespaces
	ast

Classes
class	AccessorFactory
	Class which creates accessors for the specified xAOD object content (singleton). More...

class	AccessorHelper
	Auxiliary class to handle xAOD accessor based xAOD object content access. More...

class	AccessorKit
	Implementation of an accessor creator which provides accessors for xAOD accessor or decor handle access to content of AuxElement or AuxVectorBase. More...

class	AccessorWrapper

class	BaseAccessor
	Base class of xAOD object content accessors. More...

class	BaseAccessorWrapper

class	CollectionMethodHelper
	Auxiliary class to handle method calls of vector containers (AuxVectorBase) More...

class	DecorHelper
	Auxiliary class to handle decorator handle based xAOD object content access. More...

class	EmptyVectorAccessor
	Special accessor to handle empty containers until the correct accessor can be created. More...

struct	EncapsulatedDefault

struct	EncapsulatedDefault< IProxyLoader >

struct	EncapsulatedDefault< IUnitInterpreter >

class	EncapsulatingSingleton

class	ExpressionParser

class	GenAccessor
	Generic accessor to access xAOD object content. More...

class	Helper_and

class	Helper_eq

class	Helper_gt

class	Helper_gte

class	Helper_lt

class	Helper_lte

class	Helper_neq

class	Helper_or

class	IAccessor
	Interface of auxiliary classes to access xAOD object content. More...

class	IAccessorKit
	Interface of a class to create an xAOD object content accessor. More...

class	IProxyLoader

class	IUnitInterpreter

class	MethodAccessorFactory
	Class to create accessor which call methods of an AuxElement of an AuxVectorBase container (singleton). More...

class	MethodHelper
	Auxiliary class to handle method calls of "scalar" containers (AuxElement). More...

class	MultiParserHelper
	Helper class to handle an array expression parsers to be used in the generic code. More...

class	MultipleProxyLoader

class	NTUPUnitInterpreter

class	PlainAccessorFactory

class	PlainValueHelper

class	ProxyLoaderSingleton

class	ScalarHelper
	Auxiliary class to handle scalar like containers (AuxElement). More...

class	SGNTUPProxyLoader

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

class	SingleParserHelper
	Helper class to handle a single expression parser to be used in the generic code. More...

class	Singleton

class	SizeHelper

class	SizeHelper< SG::AuxElement >

class	SizeHelper< SG::AuxVectorBase >

class	SizeHelper< std::vector< T > >

class	StackElement
	Class describing a single element in a text expression. More...

class	StdVectorHelper
	Auxiliary class to handle method calls of "scalar" containers (AuxElement). More...

class	TestProxyLoader

class	TMethodCollectionWrapper

class	TMethodWrapper

class	TriggerDecisionProxyLoader

class	UnitInterpreterSingleton

class	VectorHelper
	Auxiliary class to handle vector like containers (AuxVectorBase). More...

class	xAODElementProxyLoader

class	xAODProxyLoader

class	xAODVectorProxyLoader

Typedefs
using	AppendLoaderFunc = std::function< StatusCode(ExpressionParsing::MultipleProxyLoader &)>

template<unsigned short NUM_PARSER>
using	ParserHelper = typename std::conditional< NUM_PARSER==1, class SingleParserHelper, class MultiParserHelper< NUM_PARSER > >::type
	type of a helper class to create n-parser for the given expression or list of expressions. More...

template<unsigned short NUM_PARSER>
using	SelectionArg = typename std::conditional< NUM_PARSER==1, std::string, std::vector< std::string > >::type
	type to be used for expression string(s) for a single or multiple expression parsers More...

Functions
StatusCode	NoLoaderFunc (ExpressionParsing::MultipleProxyLoader &)

std::ostream &	operator<< (std::ostream &os, const StackElement &el)
	Declare an output operator for StackElement objects. More...

template<class T_func >
void	bin_op (std::vector< StackElement > &stack, T_func a_func)

template<class T_CompHelper , class T >
std::vector< int >	compareVector (std::vector< T > &&a, std::vector< T > &&b, T_CompHelper helper)

template<class T_CompHelper , class T >
std::vector< int >	compareVectorAlt (const std::vector< T > &&a, std::vector< T > &&b, T_CompHelper helper)

template<class T_CompHelper >
std::vector< int >	compareVector (std::vector< int > &&a, const std::vector< int > &&b, T_CompHelper helper)

template<class T_CompHelper >
std::vector< int >	compareVectorAlt (const std::vector< int > &&a, std::vector< int > &&b, T_CompHelper helper)

template<class T >
void	dumpAuxId (const T &cont, SG::auxid_t method_id)
	Method for debugging to dump information for the given aux member. More...

template<class T >
void	dumpAux (const T &cont, SG::auxid_t method_id)
	Method for debugging to dump information of all aux member of the given container and the specific aux "member". More...

template<class T >
void	dumpDeclare (const T *key)
	Function for debugging which dumps information about newly declared data handles. More...

template<class T_Key >
void	initializeHandle (T_Key key, std::vector< Gaudi::DataHandle > &new_input_handles)
	Auxiliary function to initialize newly create data handles. More...

template<class T_Aux >
bool	isAvailable (const T_Aux &cont, SG::auxid_t auxid)

template<>
bool	isAvailable< SG::AuxVectorBase > (const SG::AuxVectorBase &cont, SG::auxid_t auxid)

template<>
bool	isAvailable< SG::AuxElement > (const SG::AuxElement &cont, SG::auxid_t auxid)

template<class T >
std::size_t	getContainerSize (const T &cont)

template<class T >
const SG::AuxVectorData *	getVectorData (const T &cont)

template<>
const SG::AuxVectorData *	getVectorData< SG::AuxElement > (const SG::AuxElement &cont)

Variables
template<class T_Derived >
CxxUtils::CachedUniquePtrT< T_Derived > Singleton< T_Derived >::s_instance	ATLAS_THREAD_SAFE

Detailed Description

Namespace holding all the expression evaluation code.

For convenience reasons all the code of the package is put into this namespace.

Author: Thomas Gillam (thoma.nosp@m.s.gi.nosp@m.llam@.nosp@m.cern.nosp@m..ch)

$Revision$ $Date$

Typedef Documentation

◆ AppendLoaderFunc

using ExpressionParsing::AppendLoaderFunc = typedef std::function<StatusCode(ExpressionParsing::MultipleProxyLoader &)>

Definition at line 25 of file ExpressionParserUser.h.

◆ ParserHelper

template<unsigned short NUM_PARSER>

using ExpressionParsing::ParserHelper = typedef typename std::conditional< NUM_PARSER == 1, class SingleParserHelper, class MultiParserHelper<NUM_PARSER> >::type

type of a helper class to create n-parser for the given expression or list of expressions.

Definition at line 62 of file ExpressionParserUser.h.

◆ SelectionArg

template<unsigned short NUM_PARSER>

using ExpressionParsing::SelectionArg = typedef typename std::conditional< NUM_PARSER == 1, std::string, std::vector< std::string > >::type

type to be used for expression string(s) for a single or multiple expression parsers

Definition at line 66 of file ExpressionParserUser.h.

Function Documentation

◆ bin_op()

template<class T_func >

void ExpressionParsing::bin_op	(	std::vector< StackElement > &	stack,
		T_func	a_func
	)

Definition at line 26 of file ParsingInternals.cxx.

                                                                {
       assert( stack.size() >= 2);
       std::vector<ExpressionParsing::StackElement>::iterator last_elm = stack.end()-1;
       std::vector<ExpressionParsing::StackElement>::iterator second_last_elm = stack.end()-2;
       a_func(*second_last_elm, *last_elm);
       stack.pop_back();
    }

◆ compareVector() [1/2]

template<class T_CompHelper >

std::vector<int> ExpressionParsing::compareVector	(	std::vector< int > &&	a,
		const std::vector< int > &&	b,
		T_CompHelper	helper
	)

Definition at line 446 of file StackElement.cxx.

    {
       assert( a.size() == b.size() );
       for (std::size_t idx=0; idx < a.size(); ++idx) {
          a[idx] = helper.compare(a[idx],b[idx]);
       }
       return std::vector<int>(std::move(a));
    }

◆ compareVector() [2/2]

template<class T_CompHelper , class T >

std::vector<int> ExpressionParsing::compareVector	(	std::vector< T > &&	a,
		std::vector< T > &&	b,
		T_CompHelper	helper
	)

Definition at line 429 of file StackElement.cxx.

    {
       std::vector<int> ret;
       ret.resize(a.size());
       assert( a.size() == b.size() );
       for (std::size_t idx=0; idx < a.size(); ++idx) {
          ret[idx] = helper.compare(a[idx],b[idx]);
       }
       return ret;
    }

◆ compareVectorAlt() [1/2]

template<class T_CompHelper >

std::vector<int> ExpressionParsing::compareVectorAlt	(	const std::vector< int > &&	a,
		std::vector< int > &&	b,
		T_CompHelper	helper
	)

Definition at line 456 of file StackElement.cxx.

    {
       assert( a.size() == b.size() );
       for (std::size_t idx=0; idx < a.size(); ++idx) {
          b[idx] = helper.compare(a[idx],b[idx]);
       }
       return std::vector<int>(std::move(b));
    }

◆ compareVectorAlt() [2/2]

template<class T_CompHelper , class T >

std::vector<int> ExpressionParsing::compareVectorAlt	(	const std::vector< T > &&	a,
		std::vector< T > &&	b,
		T_CompHelper	helper
	)

Definition at line 440 of file StackElement.cxx.

    {
       return compareVectorAlt(a,b,helper);
    }

◆ dumpAux()

template<class T >

void ExpressionParsing::dumpAux	(	const T &	cont,
		SG::auxid_t	method_id
	)

Method for debugging to dump information of all aux member of the given container and the specific aux "member".

Definition at line 55 of file DebugUtils.h.

                                                     {
       dumpAuxId(cont, method_id);
       for ( auto id : cont.getAuxIDs()) {
          dumpAuxId(cont,id);
       }
    }

◆ dumpAuxId()

template<class T >

void ExpressionParsing::dumpAuxId	(	const T &	cont,
		SG::auxid_t	method_id
	)

Method for debugging to dump information for the given aux member.

Definition at line 14 of file DebugUtils.h.

                                                        {
          std::string name;
          std::string class_name;
          std::string type_name;
          std::string vec_name;
          bool is_avaail=false;
          try {
             is_avaail=isAvailable (cont, method_id);
          }
          catch (...) {
          }
          try {
             name = SG::AuxTypeRegistry::instance().getName(method_id);
          }
          catch (...) {
          }
          try {
             class_name = SG::AuxTypeRegistry::instance().getClassName(method_id);
          }
          catch (...) {
          }
          try {
             type_name  = SG::AuxTypeRegistry::instance().getTypeName(method_id);
          }
          catch (...) {
          }
          try {
             vec_name   = SG::AuxTypeRegistry::instance().getVecTypeName(method_id);
          }
          catch (...) {
          }
          std::cout << "DEBUG SGxAODProxyLoader aux " << method_id << " : " << name << " -> "
                    << " class=" << class_name
                    << " type="  << type_name
                    << " type="  << vec_name
                    << " avail=" << is_avaail
                    << std::endl;
    }

◆ dumpDeclare()

template<class T >

void ExpressionParsing::dumpDeclare ( const T * key )

Function for debugging which dumps information about newly declared data handles.

Definition at line 65 of file DebugUtils.h.

                                   {
       if (key) {
          std::string type_name;
          const SG::BaseInfoBase* base_info = SG::BaseInfoBase::find (key->clid());
          if (base_info) {
             type_name =base_info->typeinfo().name();
          }
          std::cout << "DEBUG SGxAODProxyLoader declare " << key->key() << " -> " << type_name << std::endl;
       }
    }

◆ getContainerSize()

template<class T >

std::size_t ExpressionParsing::getContainerSize ( const T & cont )

Definition at line 73 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                              {
       return SizeHelper<T>::getSize(cont);
    }

◆ getVectorData()

template<class T >

const SG::AuxVectorData* ExpressionParsing::getVectorData ( const T & cont )

Definition at line 78 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                                        {
       return &cont;
    }

◆ getVectorData< SG::AuxElement >()

template<>

const SG::AuxVectorData* ExpressionParsing::getVectorData< SG::AuxElement > ( const SG::AuxElement & cont )

Definition at line 83 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                                                                 {
       return cont.container();
    }

◆ initializeHandle()

template<class T_Key >

void ExpressionParsing::initializeHandle	(	T_Key *	key,
		std::vector< Gaudi::DataHandle * > &	new_input_handles
	)

Auxiliary function to initialize newly create data handles.

Definition at line 17 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                                                                       {
       if (key) {
          if (key->initialize().isFailure()) {
             std::stringstream msg;
             msg << "Failed to initialize read handle " << key->key();
             throw std::runtime_error( msg.str());
          }
          key->init();
          new_input_handles.push_back( key);
       }
    }

◆ isAvailable()

template<class T_Aux >

bool ExpressionParsing::isAvailable	(	const T_Aux &	cont,
		SG::auxid_t	auxid
	)

◆ isAvailable< SG::AuxElement >()

template<>

bool ExpressionParsing::isAvailable< SG::AuxElement >	(	const SG::AuxElement &	cont,
		SG::auxid_t	auxid
	)

Definition at line 40 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                                                              {
       return cont.container() && cont.container()->isAvailable(auxid);
    }

◆ isAvailable< SG::AuxVectorBase >()

template<>

bool ExpressionParsing::isAvailable< SG::AuxVectorBase >	(	const SG::AuxVectorBase &	cont,
		SG::auxid_t	auxid
	)

Definition at line 35 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

                                                                                    {
       return cont.isAvailable(auxid);
    }

◆ NoLoaderFunc()

StatusCode ExpressionParsing::NoLoaderFunc ( ExpressionParsing::MultipleProxyLoader & )

inline

Definition at line 26 of file ExpressionParserUser.h.

26 { return StatusCode::SUCCESS;}

◆ operator<<()

std::ostream & ExpressionParsing::operator<<	(	std::ostream &	os,
		const StackElement &	el
	)

Declare an output operator for StackElement objects.

Declare the print operator as a friend of the class.

Definition at line 775 of file StackElement.cxx.

                                                       {
  
       switch( el.m_type ) {
  
       case StackElement::SE_INT:
          os << "(int)" << el.m_intVal;
          break;
  
       case StackElement::SE_DOUBLE:
          os << "(double)" << el.m_doubleVal;
          break;
  
       case StackElement::SE_VECINT:
          os << "(vec<int>)" << el.m_vecIntVal;
          break;
  
       case StackElement::SE_VECDOUBLE:
          os << "(vec<double>)" << el.m_vecDoubleVal;
          break;
  
       case StackElement::SE_UNK:
          os << "SE_UNK";
          break;
  
       default:
          break;
       }
  
       return os;
    }

Variable Documentation

◆ ATLAS_THREAD_SAFE

template<class T_Derived >

CxxUtils::CachedUniquePtrT<T_Derived> Singleton<T_Derived>::s_instance ExpressionParsing::ATLAS_THREAD_SAFE

Definition at line 100 of file PhysicsAnalysis/CommonTools/ExpressionEvaluation/src/Utils.h.

Namespaces

Classes

Typedefs

Functions

Variables

Detailed Description

Typedef Documentation

◆ AppendLoaderFunc

◆ ParserHelper

◆ SelectionArg

Function Documentation

◆ bin_op()

◆ compareVector() [1/2]

◆ compareVector() [2/2]

◆ compareVectorAlt() [1/2]

◆ compareVectorAlt() [2/2]

◆ dumpAux()

◆ dumpAuxId()

◆ dumpDeclare()

◆ getContainerSize()

◆ getVectorData()

◆ getVectorData< SG::AuxElement >()

◆ initializeHandle()

◆ isAvailable()

◆ isAvailable< SG::AuxElement >()

◆ isAvailable< SG::AuxVectorBase >()

◆ NoLoaderFunc()

◆ operator<<()

Variable Documentation

◆ ATLAS_THREAD_SAFE