Classes
struct	Abort

struct	abs_f

struct	acos_f

struct	AndCombiner

class	AnyMethodArgument2VoidPtr

class	AnyMethodArgumentFixup

class	AnyObjSelector

struct	asin_f

struct	atan2_f

struct	atan_f

struct	BinaryCutSetter

struct	BinarySelector

class	BinarySelectorSetter

struct	chi2prob_f

struct	Comparison

struct	ComparisonBase

struct	ComparisonSetter

struct	cos_f

struct	cosh_f

struct	CutBinaryOperator

struct	CutBinaryOperatorSetter

struct	CutSetter

struct	deltaPhi_f

struct	deltaR_f

class	Exception

struct	exp_f

struct	ExpressionBase

struct	ExpressionBinaryOperator

struct	ExpressionBinaryOperatorSetter

struct	ExpressionCondition

struct	ExpressionConditionSetter

struct	ExpressionFunctionSetter

class	ExpressionLazyVar

struct	ExpressionNumber

struct	ExpressionNumberSetter

struct	ExpressionQuaterOperator

class	ExpressionSelectorSetter

struct	ExpressionSetter

struct	ExpressionUnaryOperator

struct	ExpressionUnaryOperatorSetter

class	ExpressionVar
	Evaluate an object's method or datamember (or chain of them) to get a number. More...

struct	ExpressionVarSetter

struct	FunctionSetter

struct	FunctionSetterCommit

struct	Grammar

struct	hypot_f

struct	IntSetter

struct	LazyInvoker
	Keeps different SingleInvokers for each dynamic type of the objects passed to invoke() More...

struct	log10_f

struct	log_f

struct	LogicalBinaryOperator

struct	LogicalUnaryOperator

struct	matches_another_integral_type

struct	max_f

struct	MethodArgumentSetter

class	MethodInvoker

class	MethodSetter

struct	min_f

struct	NotCombiner

struct	OrCombiner

struct	pow_f

struct	power_of

class	SelectorBase

struct	sin_f

struct	SingleInvoker

struct	sinh_f

struct	sqrt_f

struct	tan_f

struct	tanh_f

struct	test_bit_f

struct	TrinarySelector

class	TrinarySelectorSetter

struct	UnaryCutSetter

Typedefs
typedef std::conditional < matches_another_integral_type < unsigned long >::value, std::variant< int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, double, float, std::string > , std::variant< int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, unsigned long, double, float, std::string > >::type	AnyMethodArgument

typedef boost::spirit::classic::parser_error < reco::parser::SyntaxErrors >	BaseException

typedef std::vector < std::shared_ptr < ComparisonBase > >	ComparisonStack

typedef std::shared_ptr < ExpressionBase >	ExpressionPtr

typedef std::vector < reco::parser::ExpressionPtr >	ExpressionPtrs

typedef std::vector < std::shared_ptr < ExpressionBase > >	ExpressionStack

typedef std::vector< Function >	FunctionStack

typedef std::vector< int >	IntStack

typedef std::vector< LazyInvoker >	LazyMethodStack

typedef std::vector < AnyMethodArgument >	MethodArgumentStack

typedef std::vector < MethodInvoker >	MethodStack

typedef std::shared_ptr < SelectorBase >	SelectorPtr

typedef std::vector < reco::parser::SelectorPtr >	SelectorPtrs

typedef std::vector< SelectorPtr >	SelectorStack

typedef std::vector < edm::TypeWithDict >	TypeStack

Enumerations
enum	ErrorCodes { kNoError = 0, kNameDoesNotExist, kIsNotPublic, kIsStatic, kIsNotConst, kIsFunctionAddedByROOT, kIsConstructor, kIsDestructor, kIsOperator, kWrongNumberOfArguments, kWrongArgumentType, kOverloaded }

enum	Function { kAbs, kAcos, kAsin, kAtan, kAtan2, kChi2Prob, kCos, kCosh, kExp, kHypot, kLog, kLog10, kMax, kMin, kPow, kSin, kSinh, kSqrt, kTan, kTanh, kDeltaR, kDeltaPhi, kTestBit }

enum	SyntaxErrors { kSyntaxError, kMissingClosingParenthesis, kSpecialError }

Functions
const char *	baseExceptionWhat (const BaseException &e)
	returns the appropriate 'what' message for the exception More...

bool	cutParser (const edm::TypeWithDict &t, const std::string &cut, SelectorPtr &sel, bool lazy)

template<typename T >
bool	cutParser (const std::string &cut, SelectorPtr &sel, bool lazy=false)

bool	expressionParser (const edm::TypeWithDict &t, const std::string &value, ExpressionPtr &expr, bool lazy)

template<typename T >
bool	expressionParser (const std::string &value, ExpressionPtr &expr, bool lazy=false)

template<class T >
Exception &	operator<< (Exception &e, const T &iT)

template<class T >
Exception &	operator<< (const Exception &e, const T &iT)

Exception &	operator<< (Exception &e, std::ostream &(*f)(std::ostream &))

Exception &	operator<< (const Exception &e, std::ostream &(*f)(std::ostream &))

Exception &	operator<< (Exception &e, std::ios_base &(*f)(std::ios_base &))

Exception &	operator<< (const Exception &e, std::ios_base &(*f)(std::ios_base &))

Typedef Documentation

typedef std::conditional< matches_another_integral_type<unsigned long>::value, std::variant<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, double, float, std::string>, std::variant<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, unsigned long, double, float, std::string> >::type reco::parser::AnyMethodArgument

Definition at line 45 of file AnyMethodArgument.h.

typedef boost::spirit::classic::parser_error<reco::parser::SyntaxErrors> reco::parser::BaseException

Definition at line 33 of file Exception.h.

typedef std::vector<std::shared_ptr<ComparisonBase> > reco::parser::ComparisonStack

Definition at line 19 of file ComparisonStack.h.

typedef std::shared_ptr< ExpressionBase > reco::parser::ExpressionPtr

Definition at line 25 of file ExpressionBase.h.

typedef std::vector<reco::parser::ExpressionPtr> reco::parser::ExpressionPtrs

Definition at line 13 of file classes.h.

typedef std::vector<std::shared_ptr<ExpressionBase> > reco::parser::ExpressionStack

Definition at line 19 of file ExpressionStack.h.

typedef std::vector<Function> reco::parser::FunctionStack

Definition at line 17 of file FunctionStack.h.

typedef std::vector<int> reco::parser::IntStack

Definition at line 16 of file IntStack.h.

typedef std::vector<LazyInvoker> reco::parser::LazyMethodStack

Definition at line 18 of file MethodStack.h.

typedef std::vector<AnyMethodArgument> reco::parser::MethodArgumentStack

Definition at line 17 of file MethodArgumentStack.h.

typedef std::vector<MethodInvoker> reco::parser::MethodStack

Definition at line 17 of file MethodStack.h.

typedef std::shared_ptr<SelectorBase> reco::parser::SelectorPtr

Definition at line 18 of file SelectorPtr.h.

typedef std::vector<reco::parser::SelectorPtr> reco::parser::SelectorPtrs

Definition at line 14 of file classes.h.

typedef std::vector<SelectorPtr> reco::parser::SelectorStack

Definition at line 18 of file SelectorStack.h.

typedef std::vector<edm::TypeWithDict> reco::parser::TypeStack

Definition at line 17 of file TypeStack.h.

Enumeration Type Documentation

enum reco::parser::ErrorCodes

ErrorCodes.h CommonTools/Utils/interface/ErrorCodes.h

Description: enum containing the various ways data/function member lookups can fail

Usage: <usage>

Enumerator
kNoError
kNameDoesNotExist
kIsNotPublic
kIsStatic
kIsNotConst
kIsFunctionAddedByROOT
kIsConstructor
kIsDestructor
kIsOperator
kWrongNumberOfArguments
kWrongArgumentType
kOverloaded

Definition at line 30 of file ErrorCodes.h.

                     {
       kNoError = 0,
       kNameDoesNotExist,
       kIsNotPublic,
       kIsStatic,
       kIsNotConst,
       kIsFunctionAddedByROOT,
       kIsConstructor,
       kIsDestructor,
       kIsOperator,
       kWrongNumberOfArguments,
       kWrongArgumentType,
       kOverloaded
     };

enum reco::parser::Function

Enumerator
kAbs
kAcos
kAsin
kAtan
kAtan2
kChi2Prob
kCos
kCosh
kExp
kHypot
kLog
kLog10
kMax
kMin
kPow
kSin
kSinh
kSqrt
kTan
kTanh
kDeltaR
kDeltaPhi
kTestBit

Definition at line 18 of file Function.h.

                   {
       kAbs,
       kAcos,
       kAsin,
       kAtan,
       kAtan2,
       kChi2Prob,
       kCos,
       kCosh,
       kExp,
       kHypot,
       kLog,
       kLog10,
       kMax,
       kMin,
       kPow,
       kSin,
       kSinh,
       kSqrt,
       kTan,
       kTanh,
       kDeltaR,
       kDeltaPhi,
       kTestBit
     };

enum reco::parser::SyntaxErrors

Enumerator
kSyntaxError
kMissingClosingParenthesis
kSpecialError

Definition at line 31 of file Exception.h.

31 { kSyntaxError, kMissingClosingParenthesis, kSpecialError };

reco::parser::kSpecialError

Definition: Exception.h:31

reco::parser::kMissingClosingParenthesis

Definition: Exception.h:31

reco::parser::kSyntaxError

Definition: Exception.h:31

Function Documentation

const char* reco::parser::baseExceptionWhat ( const BaseException & e )

inline

returns the appropriate 'what' message for the exception

Definition at line 36 of file Exception.h.

References kMissingClosingParenthesis, kSpecialError, and kSyntaxError.

Referenced by cutParser(), expressionParser(), helper::Parser::makeExpression(), helper::Parser::makeSelector(), FWModelExpressionSelector::select(), FWModelFilter::setExpression(), and FWExpressionEvaluator::setExpression().

                                                                  {
       switch (e.descriptor) {
         case kMissingClosingParenthesis:
           return "Missing close parenthesis.";
         case kSyntaxError:
           return "Syntax error.";
         case kSpecialError:
         default:
           break;
       }
       return e.what();
     }

bool reco::parser::cutParser	(	const edm::TypeWithDict &	t,
		const std::string &	cut,
		SelectorPtr &	sel,
		bool	lazy = `false`
	)

Definition at line 7 of file cutParser.cc.

References baseExceptionWhat(), c, edm::errors::Configuration, GOODCOLL_filter_cfg::cut, alignCSCRings::e, Exception, and dumpparser::parse().

Referenced by cutParser().

                                                                                                               {
   bool justBlanks = true;
   for (std::string::const_iterator c = cut.begin(); c != cut.end(); ++c) {
     if (*c != ' ') {
       justBlanks = false;
       break;
     }
   }
   if (justBlanks) {
     sel = SelectorPtr(new AnyObjSelector);
     return true;
   } else {
     using namespace boost::spirit::classic;
     Grammar grammar(sel, t, lazy);
     bool returnValue = false;
     const char* startingFrom = cut.c_str();
     try {
       returnValue = parse(startingFrom, grammar.use_parser<0>() >> end_p, space_p).full;
     } catch (BaseException& e) {
       throw edm::Exception(edm::errors::Configuration)
           << "Cut parser error:" << baseExceptionWhat(e) << " (char " << e.where - startingFrom << ")\n"
           << "Cut string was " << cut;
     }
     return returnValue;
   }
 }

template<typename T >

bool reco::parser::cutParser	(	const std::string &	cut,
		SelectorPtr &	sel,
		bool	lazy = `false`
	)

inline

Definition at line 13 of file cutParser.h.

References cutParser().

                                                                                      {
       return reco::parser::cutParser(edm::TypeWithDict(typeid(T)), cut, sel, lazy);
     }

bool reco::parser::expressionParser	(	const edm::TypeWithDict &	t,
		const std::string &	value,
		ExpressionPtr &	expr,
		bool	lazy
	)

Definition at line 7 of file expressionParser.cc.

References baseExceptionWhat(), edm::errors::Configuration, alignCSCRings::e, Exception, and dumpparser::parse().

Referenced by expressionParser().

                                                {
   using namespace boost::spirit::classic;
   Grammar grammar(expr, t, lazy);
   bool returnValue = false;
   const char* startingFrom = value.c_str();
   try {
     returnValue = parse(startingFrom, grammar.use_parser<1>() >> end_p, space_p).full;
   } catch (BaseException& e) {
     throw edm::Exception(edm::errors::Configuration)
         << "Expression parser error:" << baseExceptionWhat(e) << " (char " << e.where - startingFrom << ")\n";
   }
   return returnValue;
 }

template<typename T >

bool reco::parser::expressionParser	(	const std::string &	value,
		ExpressionPtr &	expr,
		bool	lazy = `false`
	)

Definition at line 13 of file expressionParser.h.

References expressionParser().

                                                                                           {
       return reco::parser::expressionParser(edm::TypeWithDict(typeid(T)), value, expr, lazy);
     }

template<class T >

Exception& reco::parser::operator<<	(	Exception &	e,
		const T &	iT
	)

inline

Definition at line 82 of file Exception.h.

References alignCSCRings::e, and reco::parser::Exception::ost_.

                                                             {
       e.ost_ << iT;
       return e;
     }

template<class T >

Exception& reco::parser::operator<<	(	const Exception &	e,
		const T &	iT
	)

inline

Definition at line 87 of file Exception.h.

References alignCSCRings::e.

                                                                   {
       return operator<<(const_cast<Exception&>(e), iT);
     }

Exception& reco::parser::operator<<	(	Exception &	e,
		std::ostream &(*)(std::ostream &)	f
	)

inline

Definition at line 90 of file Exception.h.

References alignCSCRings::e, validate-o2o-wbm::f, and reco::parser::Exception::ost_.

Exception& reco::parser::operator<<	(	const Exception &	e,
		std::ostream &(*)(std::ostream &)	f
	)

inline

Definition at line 94 of file Exception.h.

References alignCSCRings::e, and validate-o2o-wbm::f.

                                                                                     {
       f(const_cast<Exception&>(e).ost_);
       return const_cast<Exception&>(e);
     }

Exception& reco::parser::operator<<	(	Exception &	e,
		std::ios_base &(*)(std::ios_base &)	f
	)

inline

Definition at line 98 of file Exception.h.

References alignCSCRings::e, validate-o2o-wbm::f, and reco::parser::Exception::ost_.

Exception& reco::parser::operator<<	(	const Exception &	e,
		std::ios_base &(*)(std::ios_base &)	f
	)

inline

Definition at line 102 of file Exception.h.

References alignCSCRings::e, and validate-o2o-wbm::f.

                                                                                       {
       f(const_cast<Exception&>(e).ost_);
       return const_cast<Exception&>(e);
     }

Classes

Typedefs

Enumerations

Functions

Typedef Documentation

Enumeration Type Documentation

Function Documentation