EventHypothesis.h

Go to the documentation of this file.

#ifndef DataFormats_EventHypothesis_interface_EventHypothesis_h
#define DataFormats_EventHypothesis_interface_EventHypothesis_h

#include "DataFormats/Candidate/interface/CandidateFwd.h"
#include "DataFormats/Candidate/interface/Candidate.h"
#include <boost/regex.hpp>
#include <boost/shared_ptr.hpp>

namespace pat {
   // forward declaration
   namespace eventhypothesis { template<typename T> struct Looper; }
   // real declarations
   namespace eventhypothesis { 
        // typedef for the Ref
        typedef reco::CandidatePtr CandRefType; // Ptr one day in the future
        // filter
        struct ParticleFilter {
            virtual ~ParticleFilter() {}
            bool operator()(const std::pair<std::string, CandRefType> &p) const { return operator()(p.second, p.first); }
            virtual bool operator()(const CandRefType &cand, const std::string &role) const = 0;
        };
        // smart pointer to the filter
        typedef boost::shared_ptr<const ParticleFilter> ParticleFilterPtr;
   }
   // the class
   class EventHypothesis {
        public:
            typedef eventhypothesis::CandRefType              CandRefType;
            typedef std::pair<std::string, CandRefType>       value_type;
            typedef std::vector<value_type>                   vector_type;
            typedef vector_type::const_iterator               const_iterator;
            typedef vector_type::const_reverse_iterator       const_reverse_iterator;
            typedef eventhypothesis::Looper<reco::Candidate>  CandLooper;

            void add(const CandRefType &ref, const std::string &role) ;

            const_iterator begin() const { return particles_.begin(); }
            const_iterator end()   const { return particles_.end();   }
            const_reverse_iterator rbegin() const { return particles_.rbegin(); }
            const_reverse_iterator rend()   const { return particles_.rend();   }

            class ByRole {
                public:
                    ByRole(const std::string &role) : role_(role) {}
                    bool operator()(const value_type &p) const { return p.first == role_; }
                private:
                    const std::string &role_;
            };

            typedef eventhypothesis::ParticleFilter ParticleFilter;
            typedef eventhypothesis::ParticleFilterPtr ParticleFilterPtr;
    
            const CandRefType & get(const std::string &role, int index=0) const ;
            const CandRefType & get(const ParticleFilter &filter, int index=0) const ;
            template<typename T> const T * getAs(const std::string &role, int index=0) const ;
            template<typename T> const T * getAs(const ParticleFilter &filter, int index=0) const ;
            const CandRefType & operator[](const std::string &role) const { return get(role,0); }
            const CandRefType & operator[](const ParticleFilter &filter) const { return get(filter,0); }

            std::vector<CandRefType> all(const std::string &roleRegexp) const;
            std::vector<CandRefType> all(const ParticleFilter &filter) const;

            size_t count() const { return particles_.size(); }
            size_t count(const std::string &roleRegexp) const;
            size_t count(const ParticleFilter &role) const;
            
            CandLooper loop() const ;
            CandLooper loop(const std::string &roleRegexp) const;
            CandLooper loop(const ParticleFilter &filter) const;
            CandLooper loop(const ParticleFilter *filter) const;
            CandLooper loop(const ParticleFilterPtr &filter) const;



            template<typename T> eventhypothesis::Looper<T> loopAs(const std::string &roleRegexp) const ;
            template<typename T> eventhypothesis::Looper<T> loopAs(const ParticleFilter &filter) const;
            template<typename T> eventhypothesis::Looper<T> loopAs(const ParticleFilter *filter) const;
            template<typename T> eventhypothesis::Looper<T> loopAs(const ParticleFilterPtr &filter) const;
        private:
            template<typename Iterator, typename Predicate>
            Iterator realGet(const Iterator &realBegin, const Iterator &realEnd, const Predicate &p, size_t idx) const ;

            std::vector<value_type> particles_;

   } ;

   namespace eventhypothesis {
        struct AcceptAllFilter : public ParticleFilter {
            static const AcceptAllFilter & get() { static AcceptAllFilter dummyFilter; return dummyFilter; }
            virtual bool operator()(const CandRefType &cand, const std::string &role) const { return true; }
        };
        class RoleRegexpFilter : public ParticleFilter {
            public:
                explicit RoleRegexpFilter(const std::string &roleRegexp) : re_(roleRegexp) {}
                virtual bool operator()(const CandRefType &cand, const std::string &role) const {
                    return boost::regex_match(role, re_);
                }
            private:
                boost::regex re_;
        };
   }
 
   template<typename Iterator, typename Predicate>
   Iterator EventHypothesis::realGet(const Iterator &realBegin, const Iterator &realEnd, const Predicate &pred, size_t idx) const  
   {
        Iterator it = realBegin;
        while (it != realEnd) {
            if (pred(*it)) {
                if (idx == 0) return it;
                idx--;
            }
            ++it;
        }
        return it;
   }
    
   template<typename T> 
   const T * 
   EventHypothesis::getAs(const std::string &role, int index) const 
   {
       CandRefType ref = get(role, index);
       const T* ret = dynamic_cast<const T*>(ref.get());
       if ((ret == 0) && (ref.get() != 0)) throw cms::Exception("Type Checking") <<
                "You can't convert a " << typeid(*ref).name() << " to a " << typeid(T).name() << "\n" <<
                "note: you can use c++filt command to convert the above in human readable types.\n";
       return ret;
   }
   template<typename T> 
   const T * 
   EventHypothesis::getAs(const ParticleFilter &filter, int index) const 
   {
       CandRefType ref = get(filter, index);
       const T* ret = dynamic_cast<const T*>(ref.get());
       if ((ret == 0) && (ref.get() != 0)) throw cms::Exception("Type Checking") <<
                "You can't convert a " << typeid(*ref).name() << " to a " << typeid(T).name() << "\n" <<
                "note: you can use c++filt command to convert the above in human readable types.\n";
       return ret;
   }
   template<typename T>
   eventhypothesis::Looper<T>
   EventHypothesis::loopAs(const std::string &roleRegexp) const 
   {
       return loopAs<T>(new pat::eventhypothesis::RoleRegexpFilter(roleRegexp));
   }

   template<typename T>
   eventhypothesis::Looper<T>
   EventHypothesis::loopAs(const ParticleFilter &role) const
   {
       return pat::eventhypothesis::Looper<T>(*this, role);
   }

   template<typename T>
   eventhypothesis::Looper<T>
   EventHypothesis::loopAs(const ParticleFilter *role) const
   {
       return pat::eventhypothesis::Looper<T>(*this, role);
   }

   template<typename T>
   eventhypothesis::Looper<T>
   EventHypothesis::loopAs(const ParticleFilterPtr &role) const
   {
       return pat::eventhypothesis::Looper<T>(*this, role);
   }
}

#endif