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/Candidate/interface/iterator_imp_specific.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 ) { }
    virtual ~CompositeRefCandidateT();
    virtual CompositeRefCandidateT<D> * clone() const;
    virtual const_iterator begin() const;
    virtual const_iterator end() const;
    virtual iterator begin();
    virtual iterator end();
    virtual size_t numberOfDaughters() const;
    virtual size_t numberOfMothers() const;
    virtual const Candidate * daughter(size_type) const;
    using ::reco::LeafCandidate::daughter; // avoid hiding the base
    virtual const Candidate * mother(size_type = 0) const;
    virtual Candidate * daughter(size_type);
    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 ); }


  private:
    typedef candidate::const_iterator_imp_specific<daughters> const_iterator_imp_specific;
    typedef candidate::iterator_imp_specific_dummy<daughters> iterator_imp_specific;
    daughters dau;
    daughters mom;
    virtual bool overlap( const Candidate & ) const;
  };

  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>
  Candidate::const_iterator CompositeRefCandidateT<D>::begin() const { 
    return const_iterator( new const_iterator_imp_specific( dau.begin() ) ); 
  }
  
  template<typename D>
  Candidate::const_iterator CompositeRefCandidateT<D>::end() const { 
    return const_iterator( new const_iterator_imp_specific( dau.end() ) ); 
  }    
  
  template<typename D>
  Candidate::iterator CompositeRefCandidateT<D>::begin() { 
    return iterator( new iterator_imp_specific ); 
  }
  
  template<typename D>
  Candidate::iterator CompositeRefCandidateT<D>::end() { 
    return iterator( new iterator_imp_specific ); 
  }    
  
  template<typename D>
  const Candidate * CompositeRefCandidateT<D>::daughter( size_type i ) const { 
    return ( i < numberOfDaughters() ) ? & * dau[ i ] : 0;
  }
  
  template<typename D>
  const Candidate * CompositeRefCandidateT<D>::mother( size_type i ) const { 
    return ( i < numberOfMothers() ) ? & * mom[ i ] : 0;
  }
  
  template<typename D>
  Candidate * CompositeRefCandidateT<D>::daughter( size_type i ) { 
    return 0;
  }
  
  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";
  }
}

#endif