AssocTypeConverter.h

Go to the documentation of this file.

#ifndef ATLFAST_ASSOCTYPECONVERTER_H
#define ATLFAST_ASSOCTYPECONVERTER_H

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

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


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

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

#include<typeinfo>
#include "AtlfastAlgs/AssocTypeRecoverer.h"
namespace Atlfast{

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

    ~AssocTypeConverter(){delete m_am;}
    
    
    ITwoCptCellCollection*           cells();                   
    ClusterCollection*               clusters();                
    JetCollection*                   jets();                    
    ReconstructedParticleCollection* reconstructedParticles();  
    SimpleKinematicCollection*       simpleKinematics();        
    TrackCollection*                 tracks();                  
    IKinematicCollection*            allAsIKinematics();        
    std::vector<IKinematic*>*        vectorOfIKinematics();     

  private:
    IAOO*  m_am; 
  };

  template<class T> class NewNoConst{
  public:
    T* operator()(const T* t){return new T(*t);}
    //    T* operator()(const T* t){return const_cast<T*>(t);}
  };



  class Associator2{
  public:
    Associator2(IAOO* iam):m_iam(iam){}
    template<class T>
      void operator()(T* t){
      T* tPtr = t; 
      IAOO* ia = tPtr;
      m_iam->associate(ia);
    }
    template<class T>
      void operator()(DataPtr<T> t){
      T* tPtr = t; 
      IAOO* ia = tPtr;
        m_iam->associate(ia);
    }
  private:
    IAOO* m_iam;  
  };
  template<class T>
    inline
    AssocTypeConverter<T>::AssocTypeConverter(const DataVector<T>& t){
    m_am = new SimpleKinematic;
    std::for_each(t.begin(), t.end(), Associator2(m_am) );     
  }
  template<class T>
    inline
    AssocTypeConverter<T>::AssocTypeConverter(const T& t){
    m_am = new SimpleKinematic;
    std::for_each(t.begin(), t.end(), Associator2(m_am) );     
  }
  template<class T>
    inline
    AssocTypeConverter<T>::AssocTypeConverter(const T* t){
    m_am = new SimpleKinematic;
    std::for_each(t->begin(), t->end(), Associator2(m_am) );     
  }
  template<class T>
    inline
    ITwoCptCellCollection* AssocTypeConverter<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),
                   NewNoConst<TwoCptCell>()
                   );
    
    return collection;
  }
  template<class T>
    inline
    ClusterCollection* AssocTypeConverter<T>::clusters(){
    std::vector<const Cluster*> temp = m_am->associations(x);

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

    return collection;
  }
  template<class T>
    inline
    JetCollection* AssocTypeConverter<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),
                   NewNoConst<Jet>()
                   );

    return collection;
  }
  template<class T>
    inline
    ReconstructedParticleCollection*
    AssocTypeConverter<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),
                   NewNoConst<ReconstructedParticle>()
                   );

    return collection;
  }
  template<class T>
    inline
    SimpleKinematicCollection* AssocTypeConverter<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),
                   NewNoConst<SimpleKinematic>()
                   );

    return collection;
  }
  template<class T>
    inline
    TrackCollection* AssocTypeConverter<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),
                   NewNoConst<Track>()
                   );

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

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

    return collection;
  }
  template<class T>
    inline
    std::vector<IKinematic*>* AssocTypeConverter<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),
                   NewNoConst<IKinematic>()
                   );

    return collection;
  }
}//namespace

#endif

---