#include <EventHypothesisLooper.h>

Classes
struct	null_deleter
Public Member Functions
const reco::Candidate &	cand () const
	C++ reference to pointed particle.
const T *	get () const
	Accessor as if it was a smart pointer to const T *.
size_t	globalIndex ()
	Index of this item in the full EventHypothesis.
size_t	index () const
	Index of this item among those in the loop.
bool	isTypeOk () const
	test if the type is correct
	Looper (const EventHypothesis &eh, const ParticleFilter *filter)
	Looper (const EventHypothesis &eh, const ParticleFilter &filter)
	Looper (const EventHypothesis &eh, const ParticleFilterPtr &filter)
	operator bool () const
template<typename T2 >
bool	operator!= (const Looper< T2 > &other) const
const T &	operator* () const
	Accessor as if it was a const_iterator on a list of T.
Looper &	operator++ ()
	iteration
Looper &	operator-- ()
	iteration
const T *	operator-> () const
	Accessor as if it was a const_iterator on a list of T.
template<typename T2 >
bool	operator< (const Looper< T2 > &other) const
template<typename T2 >
bool	operator<= (const Looper< T2 > &other) const
template<typename T2 >
bool	operator== (const Looper< T2 > &other) const
	returns true if loopers point to the same record
template<typename T2 >
bool	operator> (const Looper< T2 > &other) const
template<typename T2 >
bool	operator>= (const Looper< T2 > &other) const
const CandRefType &	ref () const
	EDM Ref to pointed particle.
Looper &	reset (int item=0)
const std::string &	role () const
	Role of pointed item.
size_t	size () const
	Number of particles in the loop.
Looper &	skip (int delta)
	skip (might be slow)
	~Looper ()
Private Types
typedef EventHypothesis::const_iterator	const_iterator
Private Member Functions
bool	assertOk () const
void	first ()
void	realSize () const
Private Attributes
const EventHypothesis &	eh_
const ParticleFilterPtr	filter_
const_iterator	iter_
int	num_
DynCastCandPtr< T >	ptr_
int	total_

Detailed Description

template<typename T>
class pat::eventhypothesis::Looper< T >

Definition at line 43 of file EventHypothesisLooper.h.

Member Typedef Documentation

template<typename T>

typedef EventHypothesis::const_iterator pat::eventhypothesis::Looper< T >::const_iterator [private]

Definition at line 105 of file EventHypothesisLooper.h.

Constructor & Destructor Documentation

template<typename T >

pat::eventhypothesis::Looper< T >::Looper	(	const EventHypothesis &	eh,
		const ParticleFilter &	filter
	)

Looper from EventHypothesis and an external, not owned, ParticleFilter. That is: MyFilter flt; Looper(eh, flt);

Definition at line 121 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::first().

                                                                                 :
            eh_(eh), filter_(ParticleFilterPtr(&filter, typename Looper<T>::null_deleter())), total_(-1)
        {
            first();
        }

template<typename T >

pat::eventhypothesis::Looper< T >::Looper	(	const EventHypothesis &	eh,
		const ParticleFilter *	filter
	)

Looper from EventHypothesis and an internal, owned, ParticleFilter That is: Looper(eh, new MyFilter());

Definition at line 128 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::first().

                                                                                 :
            eh_(eh), filter_(filter), total_(-1)
        {
            first();
        }

template<typename T >

pat::eventhypothesis::Looper< T >::Looper	(	const EventHypothesis &	eh,
		const ParticleFilterPtr &	filter
	)

Looper from EventHypothesis and a shared ParticleFilter That is: Looper(eh, ParticleFilterPtr(new MyFilter()));

Definition at line 135 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::first().

                                                                                    :
            eh_(eh), filter_(filter), total_(-1)
        {
            first();
        }

template<typename T>

pat::eventhypothesis::Looper< T >::~Looper ( ) [inline]

Definition at line 55 of file EventHypothesisLooper.h.

{}

Member Function Documentation

template<typename T >

bool pat::eventhypothesis::Looper< T >::assertOk ( ) const [private]

Definition at line 143 of file EventHypothesisLooper.h.

                                       {
            assert(iter_ <= eh_.end());
            assert((iter_+1) >= eh_.begin());
            assert((iter_ < eh_.begin()) || (iter_ == eh_.end()) || ((*filter_)(*iter_)));
            return true;
        }

template<typename T>

const reco::Candidate& pat::eventhypothesis::Looper< T >::cand ( ) const [inline]

C++ reference to pointed particle.

Definition at line 72 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return *iter_->second; }

template<typename T >

void pat::eventhypothesis::Looper< T >::first ( ) [private]

Definition at line 206 of file EventHypothesisLooper.h.

References ptr_.

Referenced by pat::eventhypothesis::Looper< T >::Looper().

                              {
            num_ = 0; 
            iter_ = eh_.begin(); 
            ptr_.clearCache();
            for (; iter_ != eh_.end(); ++iter_) {
                if ((*filter_)(*iter_)) break;
            }
            assert(assertOk());
        }

template<typename T>

const T* pat::eventhypothesis::Looper< T >::get ( void ) const [inline]

Accessor as if it was a smart pointer to const T *.

Definition at line 62 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_, and pat::eventhypothesis::Looper< T >::ptr_.

{ return ptr_.get(iter_->second.get()); }

template<typename T>

size_t pat::eventhypothesis::Looper< T >::globalIndex ( ) [inline]

Index of this item in the full EventHypothesis.

Definition at line 75 of file EventHypothesisLooper.h.

References pat::EventHypothesis::begin(), pat::eventhypothesis::Looper< T >::eh_, and pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ - eh_.begin(); }

template<typename T>

size_t pat::eventhypothesis::Looper< T >::index ( ) const [inline]

Index of this item among those in the loop.

Definition at line 77 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::num_.

{ return num_; }

template<typename T>

bool pat::eventhypothesis::Looper< T >::isTypeOk ( ) const [inline]

test if the type is correct

Definition at line 65 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_, and pat::eventhypothesis::Looper< T >::ptr_.

{ return ptr_.typeOk(iter_->second.get()); }

template<typename T >

pat::eventhypothesis::Looper< T >::operator bool ( ) const

Returns true if you have not run out of the boundaries. It does NOT check if typeOk()

Definition at line 217 of file EventHypothesisLooper.h.

                                       {
            return  (iter_ < eh_.end()) && (iter_ >= eh_.begin());
        }

template<typename T>

template<typename T2 >

bool pat::eventhypothesis::Looper< T >::operator!= ( const Looper< T2 > & other ) const [inline]

Definition at line 97 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ != other.iter_; }

template<typename T>

const T& pat::eventhypothesis::Looper< T >::operator* ( void ) const [inline]

Accessor as if it was a const_iterator on a list of T.

Definition at line 58 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_, and pat::eventhypothesis::Looper< T >::ptr_.

{ return ptr_.get(iter_->second.get()); }

template<typename T >

Looper< T > & pat::eventhypothesis::Looper< T >::operator++ ( void )

iteration

Definition at line 151 of file EventHypothesisLooper.h.

References ptr_.

                                          { 
            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 > & pat::eventhypothesis::Looper< T >::operator-- ( )

iteration

Definition at line 167 of file EventHypothesisLooper.h.

References ptr_.

                                          { 
            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>

const T* pat::eventhypothesis::Looper< T >::operator-> ( ) const [inline]

Accessor as if it was a const_iterator on a list of T.

Definition at line 60 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_, and pat::eventhypothesis::Looper< T >::ptr_.

{ return ptr_.get(iter_->second.get()); }

template<typename T>

template<typename T2 >

bool pat::eventhypothesis::Looper< T >::operator< ( const Looper< T2 > & other ) const [inline]

Definition at line 100 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ < other.iter_; }

template<typename T>

template<typename T2 >

bool pat::eventhypothesis::Looper< T >::operator<= ( const Looper< T2 > & other ) const [inline]

Definition at line 98 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ <= other.iter_; }

template<typename T>

template<typename T2 >

bool pat::eventhypothesis::Looper< T >::operator== ( const Looper< T2 > & other ) const [inline]

returns true if loopers point to the same record

Definition at line 96 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ == other.iter_; }

template<typename T>

template<typename T2 >

bool pat::eventhypothesis::Looper< T >::operator> ( const Looper< T2 > & other ) const [inline]

Definition at line 101 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ > other.iter_; }

template<typename T>

template<typename T2 >

bool pat::eventhypothesis::Looper< T >::operator>= ( const Looper< T2 > & other ) const [inline]

Definition at line 99 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return iter_ >= other.iter_; }

template<typename T >

void pat::eventhypothesis::Looper< T >::realSize ( ) const [private]

Definition at line 222 of file EventHypothesisLooper.h.

Referenced by pat::eventhypothesis::Looper< T >::size().

                                       {
            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_;
            }
        }

template<typename T>

const CandRefType& pat::eventhypothesis::Looper< T >::ref ( ) const [inline]

EDM Ref to pointed particle.

Definition at line 70 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return  iter_->second; }

template<typename T >

Looper< T > & pat::eventhypothesis::Looper< T >::reset ( int item = 0 )

Reset to the start or to any other specific item; negatives count from the end. might be slow, especially with negative items

Definition at line 192 of file EventHypothesisLooper.h.

References first.

                                             {
            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>

const std::string& pat::eventhypothesis::Looper< T >::role ( ) const [inline]

Role of pointed item.

Definition at line 68 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::iter_.

{ return  iter_->first; }

template<typename T>

size_t pat::eventhypothesis::Looper< T >::size ( void ) const [inline]

Number of particles in the loop.

Definition at line 79 of file EventHypothesisLooper.h.

References pat::eventhypothesis::Looper< T >::realSize(), and pat::eventhypothesis::Looper< T >::total_.

{ if (total_ < 0) realSize(); return total_; }

template<typename T >

Looper< T > & pat::eventhypothesis::Looper< T >::skip ( int delta )

skip (might be slow)

Definition at line 184 of file EventHypothesisLooper.h.

                                             {
            assert(assertOk());
            std::advance(this, delta);
            assert(assertOk());
            return *this;
        }