---

AssocTypeRecoverer.h

Go to the documentation of this file.

#ifndef ATLFAST_ASSOCTYPERECOVERER_H
#define ATLFAST_ASSOCTYPERECOVERER_H

#ifndef ATLFAST_IASSOCIATIONMANAGER_H
#include "AtlfastEvent/IAssociationManager.h"
#endif

#ifndef ATLFAST_COLLECTIONDEFS_H
#include "AtlfastEvent/CollectionDefs.h"
#endif


#ifndef STD_VECTOR_H
#include <vector>
#define STD_VECTOR_H
#endif

#ifndef STOREGATE_DATAPTR_H
#include "DataModel/DataPtr.h"
#define STOREGATE_DATAPTR_H
#endif

#include<typeinfo>

namespace Atlfast{

  template<class T> 
  class AssocTypeRecoverer {
    
  public:
    
    AssocTypeRecoverer(const T&);
    AssocTypeRecoverer(const T*);
    AssocTypeRecoverer(const DataVector<T>& t);

    ~AssocTypeRecoverer(){delete m_am;}
    
    ITwoCptCellCollection*           cells();
    ClusterCollection*               clusters();
    JetCollection*                   jets();
    ReconstructedParticleCollection* reconstructedParticles();
    SimpleKinematicCollection*       simpleKinematics();
    TrackCollection*                 tracks();
    IKinematicCollection*            allAsIKinematics();
    std::vector<IKinematic*>*        vectorOfIKinematics();
  private:
    IAssociationManager*  m_am;
  };
  template<class T> class NoConst{
    public:
    T* operator()(const T* t){return const_cast<T*>(t);}
  };
  class Associator{
  public:
    Associator(IAssociationManager* iam):m_iam(iam){}
    template<class T>
      void operator()(T* t){
      IAssociationManager* ia = t;
      std::vector<const IAssociationManager*>::iterator iter = ia->begin();
      for(; iter!=ia->end(); ++iter) {
        m_iam->associate(*iter);
      }
    }
    template<class T>
      void operator()(DataPtr<T> t){
      T* tPtr = t; 
      IAssociationManager* ia = tPtr;
      std::vector<const IAssociationManager*>::iterator iter = ia->begin();
      for(; iter!=ia->end(); ++iter) {
        m_iam->associate(*iter);
      }
    }
  private:
    IAssociationManager* m_iam;
  };
 
  template<class T>
    inline
    AssocTypeRecoverer<T>::AssocTypeRecoverer(const DataVector<T>& t){
    m_am = new SimpleKinematic;
    std::for_each(t.begin(), t.end(), Associator(m_am) );     
  }
  template<class T>
    inline
    AssocTypeRecoverer<T>::AssocTypeRecoverer(const T& t){
    m_am = new SimpleKinematic;
    std::for_each(t.begin(), t.end(), Associator(m_am) );     
  }
  template<class T>
    inline
    AssocTypeRecoverer<T>::AssocTypeRecoverer(const T* t){
    m_am = new SimpleKinematic;
    std::for_each(t->begin(), t->end(), Associator(m_am) );     
  }
  template<class T>
    inline
    ITwoCptCellCollection* AssocTypeRecoverer<T>::cells(){ 
    SimpleKinematic y;
    TwoCptCell x;
    std::vector<const TwoCptCell*> temp = m_am->associations(x);
    ITwoCptCellCollection* collection = new ITwoCptCellCollection;
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<TwoCptCell>()
                   );
    
    return collection;
  }
  template<class T>
    inline
    ClusterCollection* AssocTypeRecoverer<T>::clusters(){
    Cluster x;
    std::vector<const Cluster*> temp = m_am->associations(x);

    ClusterCollection* collection = new ClusterCollection;
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<Cluster>()
                   );

    return collection;
  }
  template<class T>
    inline
    JetCollection* AssocTypeRecoverer<T>::jets(){
    Jet x;
    std::vector<const Jet*> temp = m_am->associations(x);

    JetCollection* collection = new JetCollection;
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<Jet>()
                   );

    return collection;
  }
  template<class T>
    inline
    ReconstructedParticleCollection*
    AssocTypeRecoverer<T>::reconstructedParticles(){
    ReconstructedParticle x;
    std::vector<const ReconstructedParticle*> temp = m_am->associations(x);

    ReconstructedParticleCollection* collection = 
      new ReconstructedParticleCollection;
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<ReconstructedParticle>()
                   );

    return collection;
  }
  template<class T>
    inline
    SimpleKinematicCollection* AssocTypeRecoverer<T>::simpleKinematics(){  
    SimpleKinematic x;
    std::vector<const SimpleKinematic*> temp = m_am->associations(x);

    SimpleKinematicCollection* collection = new SimpleKinematicCollection;
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<SimpleKinematic>()
                   );

    return collection;
  }
  template<class T>
    inline
    TrackCollection* AssocTypeRecoverer<T>::tracks(){  
    Track x;
    std::vector<const Track*> temp = m_am->associations(x);

    TrackCollection* collection = new TrackCollection;
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<Track>()
                   );

    return collection;
  }
  template<class T>
    inline
    IKinematicCollection* AssocTypeRecoverer<T>::allAsIKinematics(){  
    std::vector<const IKinematic*> temp = m_am->ikinematics();

    IKinematicCollection* collection = new IKinematicCollection;
    
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<IKinematic>()
                   );

    return collection;
  }
  template<class T>
    inline
    std::vector<IKinematic*>* AssocTypeRecoverer<T>::vectorOfIKinematics(){  
    std::vector<const IKinematic*> temp = m_am->ikinematics();

    std::vector<IKinematic*>* collection = new std::vector<IKinematic*>;
    
    std::transform(
                   temp.begin(), temp.end(), std::back_inserter(*collection),
                   NoConst<IKinematic>()
                   );

    return collection;
  }
}//namespace

#endif

---