CompositeRefCandidateT.h

Go to the documentation of this file.

#ifndef Candidate_CompositeRefCandidateT_h
#define Candidate_CompositeRefCandidateT_h
 
#include "DataFormats/Candidate/interface/LeafCandidate.h"
#include "DataFormats/Common/interface/CMS_CLASS_VERSION.h"
 
namespace reco {
 
  template <typename D>
  class CompositeRefCandidateT : public LeafCandidate {
  public:
    typedef D daughters;
    typedef D mothers;
    CompositeRefCandidateT() : LeafCandidate() {}
    CompositeRefCandidateT(Charge q,
                           const LorentzVector& p4,
                           const Point& vtx = Point(0, 0, 0),
                           int pdgId = 0,
                           int status = 0,
                           bool integerCharge = true)
        : LeafCandidate(q, p4, vtx, pdgId, status, integerCharge) {}
    CompositeRefCandidateT(Charge q,
                           const PolarLorentzVector& p4,
                           const Point& vtx = Point(0, 0, 0),
                           int pdgId = 0,
                           int status = 0,
                           bool integerCharge = true)
        : LeafCandidate(q, p4, vtx, pdgId, status, integerCharge) {}
    explicit CompositeRefCandidateT(const LeafCandidate& c) : LeafCandidate(c) {}
    ~CompositeRefCandidateT() override;
    CompositeRefCandidateT<D>* clone() const override;
    size_t numberOfDaughters() const override;
    size_t numberOfMothers() const override;
    const Candidate* daughter(size_type) const override;
    using ::reco::LeafCandidate::daughter;  // avoid hiding the base
    const Candidate* mother(size_type = 0) const override;
    Candidate* daughter(size_type) override;
    void addDaughter(const typename daughters::value_type&);
    void addMother(const typename mothers::value_type&);
    void clearDaughters() { dau.clear(); }
    void clearMothers() { mom.clear(); }
    typename daughters::value_type daughterRef(size_type i) const { return dau[i]; }
    const daughters& daughterRefVector() const { return dau; }
    typename daughters::value_type motherRef(size_type i = 0) const { return mom[i]; }
    const mothers& motherRefVector() const { return mom; }
    void resetDaughters(const edm::ProductID& id) { dau = daughters(id); }
    void resetMothers(const edm::ProductID& id) { mom = mothers(id); }
 
    CMS_CLASS_VERSION(13)
 
  private:
    daughters dau;
    daughters mom;
    bool overlap(const Candidate&) const override;
  };
 
  template <typename D>
  inline void CompositeRefCandidateT<D>::addDaughter(const typename daughters::value_type& cand) {
    dau.push_back(cand);
  }
 
  template <typename D>
  inline void CompositeRefCandidateT<D>::addMother(const typename daughters::value_type& cand) {
    mom.push_back(cand);
  }
 
  template <typename D>
  CompositeRefCandidateT<D>::~CompositeRefCandidateT() {}
 
  template <typename D>
  CompositeRefCandidateT<D>* CompositeRefCandidateT<D>::clone() const {
    return new CompositeRefCandidateT(*this);
  }
 
  template <typename D>
  const Candidate* CompositeRefCandidateT<D>::daughter(size_type i) const {
    return (i < numberOfDaughters()) ? &*dau[i] : nullptr;
  }
 
  template <typename D>
  const Candidate* CompositeRefCandidateT<D>::mother(size_type i) const {
    return (i < numberOfMothers()) ? &*mom[i] : nullptr;
  }
 
  template <typename D>
  Candidate* CompositeRefCandidateT<D>::daughter(size_type i) {
    return nullptr;
  }
 
  template <typename D>
  size_t CompositeRefCandidateT<D>::numberOfDaughters() const {
    return dau.size();
  }
 
  template <typename D>
  size_t CompositeRefCandidateT<D>::numberOfMothers() const {
    return mom.size();
  }
 
  template <typename D>
  bool CompositeRefCandidateT<D>::overlap(const Candidate& c2) const {
    throw cms::Exception("Error") << "can't check overlap internally for CompositeRefCanddate";
  }
}  // namespace reco
 
#endif