reco::parser Namespace Reference

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

AnyMethodArgument

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.

BaseException

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

Definition at line 33 of file Exception.h.

ComparisonStack

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

Definition at line 19 of file ComparisonStack.h.

ExpressionPtr

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

Definition at line 25 of file ExpressionBase.h.

ExpressionPtrs

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

Definition at line 13 of file classes.h.

ExpressionStack

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

Definition at line 19 of file ExpressionStack.h.

FunctionStack

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

Definition at line 17 of file FunctionStack.h.

IntStack

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

Definition at line 16 of file IntStack.h.

LazyMethodStack

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

Definition at line 18 of file MethodStack.h.

MethodArgumentStack

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

Definition at line 17 of file MethodArgumentStack.h.

MethodStack

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

Definition at line 17 of file MethodStack.h.

SelectorPtr

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

Definition at line 18 of file SelectorPtr.h.

SelectorPtrs

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

Definition at line 14 of file classes.h.

SelectorStack

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

Definition at line 18 of file SelectorStack.h.

TypeStack

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

Definition at line 17 of file TypeStack.h.

Enumeration Type Documentation

ErrorCodes

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

Function

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

SyntaxErrors

enum reco::parser::SyntaxErrors

Enumerator
kSyntaxError
kMissingClosingParenthesis
kSpecialError

Definition at line 31 of file Exception.h.

{ kSyntaxError, kMissingClosingParenthesis, kSpecialError };

Function Documentation

baseExceptionWhat()

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 MillePedeFileConverter_cfg::e, 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();
    }

cutParser() [1/2]

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(), HltBtagPostValidation_cff::c, edm::errors::Configuration, DMR_cfg::cut, MillePedeFileConverter_cfg::e, Exception, parse(), EgammaValidation_Wenu_cff::sel, and submitPVValidationJobs::t.

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

cutParser() [2/2]

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 DMR_cfg::cut, cutParser(), and EgammaValidation_Wenu_cff::sel.

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

expressionParser() [1/2]

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, MillePedeFileConverter_cfg::e, Exception, parse(), and submitPVValidationJobs::t.

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

expressionParser() [2/2]

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);
    }

operator<<() [1/6]

template<class T >

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

inline

Definition at line 82 of file Exception.h.

References MillePedeFileConverter_cfg::e.

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

operator<<() [2/6]

template<class T >

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

inline

Definition at line 87 of file Exception.h.

References MillePedeFileConverter_cfg::e.

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

operator<<() [3/6]

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

inline

Definition at line 90 of file Exception.h.

References MillePedeFileConverter_cfg::e, and f.

                                                                              {
      f(e.ost_);
      return e;
    }

operator<<() [4/6]

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

inline

Definition at line 94 of file Exception.h.

References MillePedeFileConverter_cfg::e, and f.

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

operator<<() [5/6]

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

inline

Definition at line 98 of file Exception.h.

References MillePedeFileConverter_cfg::e, and f.

                                                                                {
      f(e.ost_);
      return e;
    }

operator<<() [6/6]

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

inline

Definition at line 102 of file Exception.h.

References MillePedeFileConverter_cfg::e, and f.

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