/home/bes3soft/bes3soft/Boss/7.0.2/dist/7.0.2/Event/DecayChain/DecayChain-00-00-03-slc6tag/DecayChain/List/DCDecayList.h

Go to the documentation of this file.

#ifndef DCHAIN_DCDECAYLIST_H
#define DCHAIN_DCDECAYLIST_H
// -*- C++ -*-
//
// Package:     DChain
// Module:      DCDecayList
// 
// Description: container of subclasses of Decay, used for iteration
//
// Usage:
//    <usage>
//
// Author:      Simon Patton
// Created:     Fri Oct  4 11:04:47 EDT 1996
// $Id: DCDecayList.h,v 1.1.1.1 2009/03/03 06:06:56 maqm Exp $
//
// Revision history
//
// $Log: DCDecayList.h,v $
// Revision 1.1.1.1  2009/03/03 06:06:56  maqm
// first import of DecayChain
//
// Revision 1.16  2006/04/09 13:32:09  cdj
// added back missing operator+
//
// Revision 1.15  2006/02/03 18:29:33  cdj
// fixed bug in copy constructor and operator=
//
// Revision 1.14  2006/01/14 15:29:43  cdj
// fixed missing symbol problem
//
// Revision 1.13  2006/01/13 18:10:15  cdj
// improved backwards compatibility
//
// Revision 1.12  2006/01/11 20:28:24  cdj
// massive class renaming, addition of [] for selection and unit tests
//
// Revision 1.11  2004/02/19 21:30:26  cdj
// added operator+= to DecayList
//
// Revision 1.10  2003/10/23 18:43:39  cdj
// can now use DCDecayList with other Decay objects
//
// Revision 1.9  2003/05/15 19:56:08  cdj
// revamped memory handling so always use a ReferenceHolder to deal with the reference counting
//
// Revision 1.8  2002/06/19 20:36:03  cleo3
// now compiles under Solaris 8
//
// Revision 1.7  2001/05/24 19:46:20  urner
// first tag
//
// Revision 1.6  2001/04/12 13:43:58  urner
// explicitely instantiated operator+ to make Solaris happy
//
// Revision 1.5  2001/04/10 13:56:45  urner
// bug fixes
//
// Revision 1.4  2001/04/03 11:43:10  cdj
// made operator+ a friend
//
// Revision 1.3  2001/03/30 16:34:53  cdj
// added simplistic operator+
//
// Revision 1.2  2001/03/23 23:07:43  urner
// modification needed to add pi0 eta and Ks decay lists in CleoDChain
//
// Revision 1.1.1.1  2000/12/18 22:16:52  cdj
// imported DChain
//
// Revision 1.12  1998/08/27 04:56:07  sjp
// Added value_type typedef
//
// Revision 1.11  1998/08/20 19:58:58  sjp
// Modified to use DChainBoolean
//
// Revision 1.10  1998/08/19 20:38:03  sjp
// Fixed include path for defintions
//
// Revision 1.9  1998/05/01 20:20:01  sjp
// Removed unnecessary functions which were causing infinate loop
//
// Revision 1.8  1998/04/17 19:10:58  sjp
// Modified to use latest types
//
// Revision 1.7  1997/08/28 06:59:42  sjp
// Modified files to handle complete templating
//
// Revision 1.6  1997/08/15 21:32:05  sjp
// Updated to use <package>/<file>.h include structure.
// Updated to use bug flags specified in Experiement.h
//
// Revision 1.5  1997/01/31 20:16:58  sjp
// Modified to use the new `bug' include files
//
// Revision 1.4  1997/01/22 16:27:06  sjp
// Fixed error in pre-processor labels
//
// Revision 1.3  1997/01/21 20:34:07  sjp
// Changed CPP flags and include because of library reorganization
//
// Revision 1.2  1996/12/20 21:19:25  sjp
// Extended pathnames for Include files
//
// Revision 1.1  1996/11/04 19:36:12  sjp
// New file for new `List' module
//

// system include files
#include <assert.h>
#include <iostream>

// user include files
#include "DecayChain/List/DecayList.h"
#include "DecayChain/List/DCFillableNeutralList.h"
#include "DecayChain/Function/DCSelectionFunction.h"

template < class DecayClass , class CandidateClass >
class DCDecayList;

template < class DecayClass , class CandidateClass >
DCDecayList< DecayClass, CandidateClass > operator+(
   const DCDecayList< DecayClass, CandidateClass >& iList1,
   const DCDecayList< DecayClass, CandidateClass >& iList2 );
template < class DecayClass , class CandidateClass, class NeutralClass >
DCDecayList< DecayClass, CandidateClass > operator+(
   const DCDecayList< DecayClass, CandidateClass >& iList1,
   const DCFillableNeutralList< NeutralClass >& iList2 );
template < class DecayClass , class CandidateClass, class NeutralClass >
DCDecayList< DecayClass, CandidateClass > operator+(
   const DCFillableNeutralList< NeutralClass >& iList1 ,
   const DCDecayList< DecayClass, CandidateClass >& iList2);

template < class DecayClass , class CandidateClass >
class DCDecayList : public dchain::DecayList<DecayClass, CandidateClass>
{
   // friend classses and functions

   friend 
      DCDecayList< DecayClass, CandidateClass > operator+ <DecayClass, CandidateClass> (
            const DCDecayList< DecayClass, CandidateClass >& iList1,
            const DCDecayList< DecayClass, CandidateClass >& iList2 );

   public:
   // constants, enums and typedefs
   typedef DecayClass value_type ;

   // Constructors and destructor
   DCDecayList( bool ( * pFunction )( DecayClass& ) = 0 ) ;
   // need this function to stop default copy constructor
   DCDecayList( const DCDecayList< DecayClass , CandidateClass >& aOtherList ,
         bool ( * pFunction )( DecayClass& ) ) ;
   DCDecayList( DCSelectionFunction< DecayClass >& aFunctionalObject ) ;

   DCDecayList(const DCDecayList<DecayClass,CandidateClass>& iList) :
      dchain::DecayList<DecayClass,CandidateClass>(
            static_cast<dchain::DecayList<DecayClass,CandidateClass> >(iList)),
      m_function(0), m_functionalObject(0) {}

   DCDecayList(const dchain::DecayList<DecayClass,CandidateClass>& iList) :
      dchain::DecayList<DecayClass,CandidateClass>(iList),
      m_function(0), m_functionalObject(0) {}

   // assignment operator(s)
   // need this function to stop default assignment operator
   template< class TDecay>
      const DCDecayList< DecayClass , CandidateClass >& operator=( const DCDecayList< TDecay , CandidateClass >& aOtherList ) {
         this->erase();
         fill(aOtherList);
         return ( *this ) ;
      }


   template< class TDecay>
      const DCDecayList< DecayClass , CandidateClass >& operator=( const dchain::DecayList< TDecay , CandidateClass >& aOtherList ) {
         this->erase();
         fill(aOtherList);
         return ( *this ) ;
      }

   const DCDecayList< DecayClass , CandidateClass >& operator=( const dchain::CombinatoricList< CandidateClass >& aOtherList );

   const DCDecayList< DecayClass , CandidateClass >& operator=( const DCDecayList< DecayClass , CandidateClass >& aOtherList ){
      this->erase();
      fill(aOtherList);
      return ( *this ) ;
   }
   //
   template<class TList>
      void operator+=( const TList& aOtherList) {

         if( this->size() != 0 ) {
            //only check compatable conjugation if something already in
            // this list, otherwise could have problem with default value
            bool can_only_add_lists_with_same_conjugation =
               this->isSelfConjugate() == aOtherList.isSelfConjugate();
            assert(can_only_add_lists_with_same_conjugation);
         }
         fill(aOtherList);
      }

   // member functions
   using dchain::DecayList<DecayClass,CandidateClass>::attempt_insert;
   void attempt_insert(DecayClass* pPossible,
         const dchain::conjugation::Label aLabel) {

      if(0!= m_function) {
         this->attempt_insert(pPossible, aLabel, m_function);
      } else if(0!= m_functionalObject) {
         this->attempt_insert(pPossible, aLabel, *m_functionalObject);
      } else {
         dchain::SelectAll<DecayClass> selectAll;
         this->attempt_insert(pPossible, aLabel,selectAll );
      }
   }
   protected:
   // Constructors and destructor

   public:
   DCDecayList(
         dchain::LabeledParticleList< DecayClass , CandidateClass >& aLabeledDecayList ,
         dchain::conjugation::Label aLabel ) ;

   private:
   // Constructors and destructor

   // private member functions
   using dchain::DecayList<DecayClass,CandidateClass>::fill;
   template<class TDecayList>
      void fill( const TDecayList& aList ) {
         //std::cout << "@DCDecayList::fill()" << std::endl;
         if(0!= m_function) {
            this->fill(aList, m_function);
         } else if(0!= m_functionalObject) {
            this->fill(aList, *m_functionalObject);
         } else {
            dchain::SelectAll<DecayClass> selectAll;
            this->fill(aList,selectAll );
         }
      }  

   private:

   // private const member functions

   // data members
   bool ( * m_function )( DecayClass& ) ;
   DCSelectionFunction< DecayClass >* m_functionalObject ;


   // static data members

} ;

// inline function definitions

#include <assert.h>

template < class DecayClass , class CandidateClass >
inline
DCDecayList< DecayClass, CandidateClass > operator+(
   const DCDecayList< DecayClass, CandidateClass >& iList1,
   const DCDecayList< DecayClass, CandidateClass >& iList2 )
{
   bool can_only_add_lists_with_same_conjugation =
      iList1.isSelfConjugate()== iList2.isSelfConjugate();
   assert(can_only_add_lists_with_same_conjugation);

   DCDecayList< DecayClass, CandidateClass> returnValue( iList1 );
   if( &iList1 != &iList2 ) {
      returnValue.fill( iList2 );
   }
   return returnValue;
}

template < class DecayClass , class CandidateClass, class NeutralClass >
inline
DCDecayList< DecayClass, CandidateClass > operator+(
   const DCDecayList< DecayClass, CandidateClass >& iList1,
   const DCFillableNeutralList< NeutralClass >& iList2 )
{
   bool can_only_add_lists_with_same_conjugation =
      iList1.isSelfConjugate()== iList2.isSelfConjugate();
   assert(can_only_add_lists_with_same_conjugation);

   
   DCDecayList< DecayClass, CandidateClass> returnValue( iList1 );
   typename dchain::LabeledParticleList< NeutralClass , CandidateClass >::const_iterator finished( iList2.particle_end() ) ;
   for( typename dchain::LabeledParticleList< NeutralClass , CandidateClass >::const_iterator entry(iList2.particle_begin()) ;
        entry != finished ;
        ++entry ){
     NeutralClass* localCopy = new NeutralClass( (*entry).particle() ) ;
     returnValue.attempt_insert( localCopy, (*entry).label() ) ;
   }
   return returnValue;
}


template < class DecayClass , class CandidateClass, class NeutralClass >
inline
DCDecayList< DecayClass, CandidateClass > operator+(
   const DCFillableNeutralList< NeutralClass >& iList1 ,
   const DCDecayList< DecayClass, CandidateClass >& iList2)
{
     DCDecayList< DecayClass, CandidateClass> returnValue;
     returnValue = iList2 + iList1;
     return returnValue;
}

   
// function definitions
#include "DecayChain/List/Template/DCDecayList.cc"

#endif /* DCHAIN_DCDECAYLIST_H */

---