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	CombinerSetter
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
struct	ExpressionLazyVar
struct	ExpressionNumber
struct	ExpressionNumberSetter
struct	ExpressionQuaterOperator
class	ExpressionSelectorSetter
struct	ExpressionSetter
struct	ExpressionUnaryOperator
struct	ExpressionUnaryOperatorSetter
struct	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
struct	MethodInvoker
struct	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 boost::mpl::if_ < matches_another_integral_type < unsigned long > , boost::variant< int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, double, float, std::string >, boost::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 < boost::shared_ptr < ComparisonBase > >	ComparisonStack
typedef boost::shared_ptr < ExpressionBase >	ExpressionPtr
typedef std::vector < reco::parser::ExpressionPtr >	ExpressionPtrs
typedef std::vector < boost::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 boost::shared_ptr < SelectorBase >	SelectorPtr
typedef std::vector < reco::parser::SelectorPtr >	SelectorPtrs
typedef std::vector< SelectorPtr >	SelectorStack
typedef std::vector< Reflex::Type >	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 Reflex::Type &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 Reflex::Type &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 boost::mpl::if_<matches_another_integral_type<unsigned long>, boost::variant<int8_t, uint8_t, int16_t, uint16_t, int32_t, uint32_t, int64_t, uint64_t, double,float, std::string>, boost::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 50 of file AnyMethodArgument.h.

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

Definition at line 37 of file Exception.h.

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

Definition at line 18 of file ComparisonStack.h.

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

Definition at line 24 of file ExpressionBase.h.

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

Definition at line 12 of file classes.h.

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

Definition at line 18 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 boost::shared_ptr<SelectorBase> reco::parser::SelectorPtr

Definition at line 17 of file SelectorPtr.h.

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

Definition at line 13 of file classes.h.

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

Definition at line 18 of file SelectorStack.h.

typedef std::vector<Reflex::Type> 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.

                        {
         kSyntaxError,
         kMissingClosingParenthesis,
         kSpecialError
      };

Function Documentation

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

inline

returns the appropriate 'what' message for the exception

Definition at line 40 of file Exception.h.

References kMissingClosingParenthesis, kSpecialError, and kSyntaxError.

Referenced by cutParser(), expressionParser(), helper::Parser::makeExpression(), helper::Parser::makeSelector(), FWModelExpressionSelector::select(), FWExpressionEvaluator::setExpression(), and FWModelFilter::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 Reflex::Type &	t,
		const std::string &	cut,
		SelectorPtr &	sel,
		bool	lazy = false
	)

Definition at line 7 of file cutParser.cc.

References baseExceptionWhat(), trackerHits::c, edm::errors::Configuration, alignCSCRings::e, edm::hlt::Exception, and triggerExpression::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";
        }
        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(Reflex::Type::ByTypeInfo(typeid(T)), cut, sel, lazy);
    }

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

Definition at line 7 of file expressionParser.cc.

References baseExceptionWhat(), edm::errors::Configuration, alignCSCRings::e, edm::hlt::Exception, and triggerExpression::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(Reflex::Type::ByTypeInfo(typeid(T)), value, expr, lazy);
  }

template<class T >

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

inline

Definition at line 86 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 91 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 94 of file Exception.h.

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

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

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

inline

Definition at line 99 of file Exception.h.

References alignCSCRings::e, and 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 104 of file Exception.h.

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

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

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

inline

Definition at line 108 of file Exception.h.

References alignCSCRings::e, and f.

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