ExpressionParsing Namespace Reference

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

Namespaces
namespace	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.
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

Functions
StatusCode	NoLoaderFunc (ExpressionParsing::MultipleProxyLoader &)
std::ostream &	operator<< (std::ostream &os, const StackElement &el)
	Declare an output operator for StackElement objects.
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.
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".
template<class T>
void	dumpDeclare (const T *key)
	Function for debugging which dumps information about newly declared data handles.
template<class T_Key>
void	initializeHandle (T_Key *key, std::vector< Gaudi::DataHandle * > &new_input_handles)
	Auxiliary function to initialize newly create data handles.
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 = std::function<StatusCode(ExpressionParsing::MultipleProxyLoader &)>

Definition at line 25 of file ExpressionParserUser.h.

ParserHelper

template<unsigned short NUM_PARSER>

using ExpressionParsing::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.

Definition at line 62 of file ExpressionParserUser.h.

SelectionArg

template<unsigned short NUM_PARSER>

using ExpressionParsing::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

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.

{ 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.