EventHypothesisLooper.h

Go to the documentation of this file.

#ifndef DataFormats_EventHypothesis_interface_EventHypothesisLooper_h
#define DataFormats_EventHypothesis_interface_EventHypothesisLooper_h
 
#include "DataFormats/Candidate/interface/Candidate.h"
#include "DataFormats/PatCandidates/interface/EventHypothesis.h"
#include <algorithm>
 
namespace pat {
  namespace eventhypothesis {
    template <typename T>
    class DynCastCandPtr {
    public:
      const T *get(const reco::Candidate *ptr);
      void clearCache() { isPtrCached_ = false; }
      bool typeOk(const reco::Candidate *ptr) {
        doPtr(ptr);
        return cachePtr_ != 0;
      }
 
    private:
      void doPtr(const reco::Candidate *ptr);
      bool isPtrCached_;
      const T *cachePtr_;
    };
    template <typename T>
    void DynCastCandPtr<T>::doPtr(const reco::Candidate *ptr) {
      if (!isPtrCached_) {
        cachePtr_ = dynamic_cast<const T *>(ptr);
        isPtrCached_ = true;
      }
    }
    template <typename T>
    const T *DynCastCandPtr<T>::get(const reco::Candidate *ptr) {
      doPtr(ptr);
      if ((ptr != nullptr) && (cachePtr_ == nullptr))
        throw cms::Exception("Type Checking")
            << "You can't convert a " << typeid(*ptr).name() << " to a " << typeid(T).name() << "\n"
            << "note: you can use c++filt command to convert the above in human readable types.\n";
      return cachePtr_;
    }
 
    template <>
    struct DynCastCandPtr<reco::Candidate> {
      const reco::Candidate *get(const reco::Candidate *ptr) { return ptr; }
      void clearCache() {}
      bool typeOk(const reco::Candidate *ptr) { return true; }
    };
 
    template <typename T>
    class Looper {
    public:
      Looper(const EventHypothesis &eh, const ParticleFilter &filter);
 
      Looper(const EventHypothesis &eh, const ParticleFilter *filter);
      Looper(const EventHypothesis &eh, const ParticleFilterPtr &filter);
      ~Looper() {}
 
      const T &operator*() const { return ptr_.get(iter_->second.get()); }
      const T *operator->() const { return ptr_.get(iter_->second.get()); }
      const T *get() const { return ptr_.get(iter_->second.get()); }
 
      bool isTypeOk() const { return ptr_.typeOk(iter_->second.get()); }
 
      const std::string &role() const { return iter_->first; }
      const CandRefType &ref() const { return iter_->second; }
      const reco::Candidate &cand() const { return *iter_->second; }
 
      size_t globalIndex() { return iter_ - eh_.begin(); }
      size_t index() const { return num_; }
      size_t size() const {
        if (total_ < 0)
          realSize();
        return total_;
      }
 
      Looper &operator++();
      Looper &operator--();
      Looper &skip(int delta);
      Looper &reset(int item = 0);
 
      operator bool() const;
 
      template <typename T2>
      bool operator==(const Looper<T2> &other) const {
        return iter_ == other.iter_;
      }
      template <typename T2>
      bool operator!=(const Looper<T2> &other) const {
        return iter_ != other.iter_;
      }
      template <typename T2>
      bool operator<=(const Looper<T2> &other) const {
        return iter_ <= other.iter_;
      }
      template <typename T2>
      bool operator>=(const Looper<T2> &other) const {
        return iter_ >= other.iter_;
      }
      template <typename T2>
      bool operator<(const Looper<T2> &other) const {
        return iter_ < other.iter_;
      }
      template <typename T2>
      bool operator>(const Looper<T2> &other) const {
        return iter_ > other.iter_;
      }
 
    private:
      struct null_deleter {
        void operator()(void const *) const {}
      };
      typedef typename EventHypothesis::const_iterator const_iterator;
 
      void first();
      void realSize() const;
      bool assertOk() const;
 
      const EventHypothesis &eh_;
      const ParticleFilterPtr filter_;
      const_iterator iter_;
      int num_;
      mutable int total_;  // mutable as it is not computed unless needed
      mutable DynCastCandPtr<T> ptr_;
    };
    typedef Looper<reco::Candidate> CandLooper;
 
    template <typename T>
    Looper<T>::Looper(const EventHypothesis &eh, const ParticleFilter &filter)
        : eh_(eh), filter_(ParticleFilterPtr(&filter, typename Looper<T>::null_deleter())), total_(-1) {
      first();
    }
 
    template <typename T>
    Looper<T>::Looper(const EventHypothesis &eh, const ParticleFilter *filter) : eh_(eh), filter_(filter), total_(-1) {
      first();
    }
 
    template <typename T>
    Looper<T>::Looper(const EventHypothesis &eh, const ParticleFilterPtr &filter)
        : eh_(eh), filter_(filter), total_(-1) {
      first();
    }
 
    template <typename T>
    bool Looper<T>::assertOk() const {
      assert(iter_ <= eh_.end());
      assert((iter_ + 1) >= eh_.begin());
      assert((iter_ < eh_.begin()) || (iter_ == eh_.end()) || ((*filter_)(*iter_)));
      return true;
    }
 
    template <typename T>
    Looper<T> &Looper<T>::operator++() {
      ptr_.clearCache();
      assert(assertOk());
      if (iter_ == eh_.end())
        return *this;
      do {
        ++iter_;
        if (iter_ == eh_.end())
          break;
        if ((*filter_)(*iter_)) {
          assert(assertOk());
          ++num_;
          return *this;
        }
      } while (true);
      assert(assertOk());
      return *this;
    }
    template <typename T>
    Looper<T> &Looper<T>::operator--() {
      ptr_.clearCache();
      assert(assertOk());
      if (num_ < 0)
        return *this;
      do {
        --iter_;
        if (iter_ < eh_.begin()) {
          num_ = -1;
          break;
        }
        if ((*filter_)(*iter_)) {
          assert(assertOk());
          --num_;
          return *this;
        }
      } while (true);
      assert(assertOk());
      return *this;
    }
 
    template <typename T>
    Looper<T> &Looper<T>::skip(int delta) {
      assert(assertOk());
      std::advance(this, delta);
      assert(assertOk());
      return *this;
    }
 
    template <typename T>
    Looper<T> &Looper<T>::reset(int item) {
      assert(assertOk());
      if (item >= 0) {
        first();
        std::advance(this, item);
      } else {
        num_ = item + 1;
        iter_ = eh_.end();
        std::advance(this, item);
      }
      assert(assertOk());
      return *this;
    }
 
    template <typename T>
    void Looper<T>::first() {
      num_ = 0;
      iter_ = eh_.begin();
      ptr_.clearCache();
      for (; iter_ != eh_.end(); ++iter_) {
        if ((*filter_)(*iter_))
          break;
      }
      assert(assertOk());
    }
 
    template <typename T>
    Looper<T>::operator bool() const {
      return (iter_ < eh_.end()) && (iter_ >= eh_.begin());
    }
 
    template <typename T>
    void Looper<T>::realSize() const {
      EventHypothesis::const_iterator it = iter_;
      if (it < eh_.begin()) {
        it = eh_.begin();
        total_ = 0;
      } else {
        total_ = num_;
      }
      for (; it != eh_.end(); ++it) {
        if ((*filter_)(*it))
          ++total_;
      }
    }
  }  // namespace eventhypothesis
}  // namespace pat
 
#endif