ScannerHelpers.h

Go to the documentation of this file.

#ifndef PhysicsTools_FWLite_ScannerHelpers_h
#define PhysicsTools_FWLite_ScannerHelpers_h

#include <string>
#include <Reflex/Type.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/src/ExpressionPtr.h"
#include "CommonTools/Utils/src/SelectorPtr.h"
#include "CommonTools/Utils/src/ExpressionBase.h"
#include "CommonTools/Utils/src/SelectorBase.h"
#endif

namespace helper {
    class Parser {
        public:
            Parser() {}
            static reco::parser::ExpressionPtr  makeExpression(const std::string &expr, const Reflex::Type &type) ;
            static reco::parser::SelectorPtr    makeSelector(const std::string &expr, const Reflex::Type &type) ;
            static Reflex::Type elementType(const Reflex::Type &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 Reflex::Object
            static bool   test(const reco::parser::SelectorPtr &sel, const Reflex::Type type, const void * obj);
            static double eval(const reco::parser::ExpressionPtr &sel, const Reflex::Type type, const void * obj);
    };

    class ScannerBase {
        public:
            ScannerBase() {}
            ScannerBase(const Reflex::Type &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:
            Reflex::Type objType_;
            std::vector<reco::parser::ExpressionPtr> exprs_;

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

            bool ignoreExceptions_;
    };
}

#endif