CMS 3D CMS Logo

Classes | Typedefs | Enumerations | Functions

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< FunctionFunctionStack
typedef std::vector< int > IntStack
typedef std::vector< LazyInvokerLazyMethodStack
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< SelectorPtrSelectorStack
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
template<typename T >
bool cutParser (const std::string &cut, SelectorPtr &sel, bool lazy=false)
bool cutParser (const Reflex::Type &t, const std::string &cut, SelectorPtr &sel, bool lazy)
template<typename T >
bool expressionParser (const std::string &value, ExpressionPtr &expr, bool lazy=false)
bool expressionParser (const Reflex::Type &t, const std::string &value, ExpressionPtr &expr, bool lazy)
Exceptionoperator<< (const Exception &e, std::ostream &(*f)(std::ostream &))
Exceptionoperator<< (Exception &e, std::ostream &(*f)(std::ostream &))
Exceptionoperator<< (const Exception &e, std::ios_base &(*f)(std::ios_base &))
template<class T >
Exceptionoperator<< (Exception &e, const T &iT)
template<class T >
Exceptionoperator<< (const Exception &e, const T &iT)
Exceptionoperator<< (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.

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.

Definition at line 18 of file MethodStack.h.

Definition at line 17 of file MethodArgumentStack.h.

Definition at line 17 of file MethodStack.h.

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

Definition at line 17 of file SelectorPtr.h.

Definition at line 13 of file classes.h.

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

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.

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.

Enumerator:
kSyntaxError 
kMissingClosingParenthesis 
kSpecialError 

Definition at line 31 of file Exception.h.


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