ScannerHelpers.h

Go to the documentation of this file.

#ifndef PhysicsTools_FWLite_ScannerHelpers_h
#define PhysicsTools_FWLite_ScannerHelpers_h

#include <string>
#include <FWCore/Reflection/interface/TypeWithDict.h>
#include <TH1.h>
#include <TH2.h>
#include <TProfile.h>
#include <TGraph.h>

// AFAIK These includes are needed to build the dictionary
// but must be kept hidden if CINT sees this class
#if !defined(__CINT__) && !defined(__MAKECINT__)
#include "CommonTools/Utils/interface/ExpressionPtr.h"
#include "CommonTools/Utils/interface/SelectorPtr.h"
#include "CommonTools/Utils/interface/ExpressionBase.h"
#include "CommonTools/Utils/interface/SelectorBase.h"
#endif

namespace helper {
  class Parser {
  public:
    Parser() {}
    static reco::parser::ExpressionPtr makeExpression(const std::string &expr, const edm::TypeWithDict &type);
    static reco::parser::SelectorPtr makeSelector(const std::string &expr, const edm::TypeWithDict &type);
    static edm::TypeWithDict elementType(const edm::TypeWithDict &wrapperType);

    //--- we define also dictionaries for these two trivial functions that should be callable even by CINT
    //    because otherwise sometimes CINT crashes even on the creation and destruction of edm::ObjectWithDict
    static bool test(const reco::parser::SelectorPtr &sel, const edm::TypeWithDict type, const void *obj);
    static double eval(const reco::parser::ExpressionPtr &sel, const edm::TypeWithDict type, const void *obj);
  };

  class ScannerBase {
  public:
    ScannerBase() {}
    ScannerBase(const edm::TypeWithDict &objType) : objType_(objType), cuts_(1), ignoreExceptions_(false) {}

    bool addExpression(const char *expr);
    void clearExpressions() { exprs_.clear(); }
    size_t numberOfExpressions() const { return exprs_.size(); }

    bool setCut(const char *cut);
    void clearCut();
    bool addExtraCut(const char *cut);
    void clearExtraCuts();
    size_t numberOfExtraCuts() const { return cuts_.size() - 1; }

    bool test(const void *obj, size_t icut = 0) const;

    double eval(const void *obj, size_t iexpr = 0) const;

    void print(const void *obj) const;

    void fill1D(const void *obj, TH1 *hist) const;

    void fill2D(const void *obj, TH2 *hist2d) const;

    void fillGraph(const void *obj, TGraph *graph) const;

    void fillProf(const void *obj, TProfile *prof) const;

    void setIgnoreExceptions(bool ignoreThem) { ignoreExceptions_ = ignoreThem; }

  private:
    edm::TypeWithDict objType_;
    std::vector<reco::parser::ExpressionPtr> exprs_;

    std::vector<reco::parser::SelectorPtr> cuts_;

    bool ignoreExceptions_;
  };
}  // namespace helper

#endif