TPConverter.h

Go to the documentation of this file.

// dear emacs, this is -*- c++ -*-
 
/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef TPCONVERTER_H
#define TPCONVERTER_H 1

 
#include "AthenaKernel/ITPCnvBase.h"
#include "AthenaKernel/getThinningCache.h"
#include "AthenaKernel/ThinningDecisionBase.h"
#include "ITPConverter.h"
#include "TopLevelTPCnvBase.h"
 
#include "GaudiKernel/MsgStream.h"
 
#include <vector>
#include <stdexcept>
#include <cassert>
 

template< class TRANS >
class ITPConverterFor : public ITPConverter
{
public:
  typedef TRANS             TransBase_t;
  typedef TransBase_t            Trans_t;
  typedef ITPConverterFor< TRANS >  PolyCnvBase_t;
 
  ITPConverterFor() :
        m_pStorageTIDvalue(0), m_topConverter(0), m_topConverterRuntime(0),
        m_wasUsedForReading( false )
  {}
  
  virtual ~ITPConverterFor()  = default;

  template < class CNV >
  CNV *
  converterForType( CNV *cnv, const std::type_info& t_info, MsgStream& log ) const {
     ITPConverter *c = m_topConverterRuntime->converterForType( t_info );
     cnv = dynamic_cast< CNV* >( c );
     if( !cnv )
    this->converterNotFound( typeid(CNV), c, t_info.name(), log );
     return cnv;
  }

  template < class CNV >
  CNV *
  converterForRef( CNV *cnv, const TPObjRef& ref, MsgStream& log ) const {
     ITPConverter *c = m_topConverterRuntime->converterForRef( ref );
     cnv = dynamic_cast<CNV*>(c);
     if( !cnv )
        this->converterNotFound( ref.typeID(), c, typeid(CNV).name(), log );
     return cnv;
  }

  template < class CNV >
  TPObjRef
  baseToPersistent( CNV **cnv, const typename CNV::Trans_t* transObj, MsgStream& log)  const {
     if( !*cnv || (*cnv)->wasUsedForReading() ) {
        // don't trust the converter if it was used for reading, find again
    *cnv = converterForType( *cnv, typeid(typename CNV::Trans_t), log );
    if( !*cnv )  return TPObjRef();
        (*cnv)->clearReadingFlag();
     }
//     return (**cnv).toPersistent_impl(transObj, log); 
     return (**cnv).virt_toPersistent(transObj, log); 
  }
  
  template < class CNV >
  TPObjRef toPersistent( CNV **cnv, const typename CNV::TransBase_t* transObj, MsgStream& log) const {
     if( !transObj ) return TPObjRef();
     CNV *temp_cnv_p = 0;
     if( !cnv ) cnv = &temp_cnv_p;
     if( !*cnv || (*cnv)->wasUsedForReading() ) {
        // don't trust the converter if it was used for reading, find again
    *cnv = converterForType( *cnv, typeid(*transObj), log );
    if( !*cnv )  return TPObjRef();
        (*cnv)->clearReadingFlag();
     }
     return (**cnv).virt_toPersistent(transObj, log);
  }

  template < class CNV, class TRANS_T >
  void  fillTransFromPStore( CNV **cnv, const TPObjRef& ref, TRANS_T *trans, MsgStream &log ) const {
    if( ref.isNull() )  return;
    CNV *temp_cnv_p = 0;
    if( !cnv ) cnv = &temp_cnv_p;
    // see if we already have a converter and if it is the right one
    if( !*cnv || (*cnv)->typeID().value() != ref.typeID() ) {
       // we don't - find the right converter for ref.typeID()
       *cnv = converterForRef( *cnv, ref, log );
       if( !*cnv ) return;
       (*cnv)->setReadingFlag();
     }
    (**cnv).pstoreToTrans( ref.index(), trans, log );
  }

  template < class CNV >
  typename CNV::Trans_t*
  createTransFromPStore( CNV **cnv, const TPObjRef& ref, MsgStream& log) const {
     if( ref.isNull() )  return 0;
     CNV *temp_cnv_p = 0;
     if( !cnv ) cnv = &temp_cnv_p;
     // see if we already have a converter and if it is the right one
     if( !*cnv || (*cnv)->typeID().value() != ref.typeID() ) {
        // we don't - find the right converter for ref.typeID()
    *cnv = converterForRef( *cnv, ref, log );
    if( !*cnv ) return 0;
        (*cnv)->setReadingFlag();
     }
     return (**cnv).virt_createTransFromPStore( ref.index(), log );
  }
 
  // hook to initialize private converters
  virtual void  initPrivateConverters(TopLevelTPCnvBase *) {}
  

  virtual TopLevelTPCnvBase*   topConverter() {
     return m_topConverter;
  }

  virtual const TopLevelTPCnvBase* topConverter() const {
     return m_topConverter;
  }

  virtual const std::type_info& transientTInfo() const { return typeid(TRANS); }

  const std::type_info& transBaseTInfo() const { return typeid(TRANS); }

  virtual const TPObjRef::typeID_t&   typeID() const { return m_pStorageTID; }

  unsigned      typeIDvalue() const { return m_pStorageTIDvalue; }
 
  
  virtual void  setRuntimeTopConverter( TopLevelTPCnvBase *topConverter ) {
     m_topConverterRuntime = topConverter;
     initPrivateConverters( topConverter );
  }
  
  virtual void  setTopConverter( TopLevelTPCnvBase *topConverter,
                 const TPObjRef::typeID_t &TPtypeID )
  {
     m_topConverter = m_topConverterRuntime = topConverter;
     m_pStorageTID = TPtypeID;
     m_pStorageTIDvalue = TPtypeID.value();
     initPrivateConverters( topConverter );
  }
 
 
  /* Internal accessor methods for the Read Flag
     Need to be public
  */
  void          setReadingFlag() { m_wasUsedForReading = true; }
  void          clearReadingFlag() { m_wasUsedForReading = false; }
  bool          wasUsedForReading() { return m_wasUsedForReading; }
 
  
//protected:
  // ------ methods operating on the persistent store of the top level object

  virtual TPObjRef virt_toPersistent( const TransBase_t* trans, MsgStream& log) = 0;

  virtual TPObjRef virt_toPersistentWithKey( const TransBase_t* trans,
                                             const std::string& key,
                                             MsgStream& log) = 0;

  virtual TRANS* virt_createTransFromPStore( unsigned index, MsgStream &log ) = 0;

  virtual TRANS* virt_createTransFromPStoreWithKey( unsigned index,
                                                    const std::string& key,
                                                    MsgStream &log ) = 0;

  virtual void  pstoreToTrans( unsigned index, TransBase_t* transObj, MsgStream& log) = 0; 
 
protected:
  TPObjRef::typeID_t    m_pStorageTID;

  unsigned              m_pStorageTIDvalue;

  TopLevelTPCnvBase    *m_topConverter;
  
  TopLevelTPCnvBase    *m_topConverterRuntime;

  bool                  m_wasUsedForReading;
};
 
 
 
 
// --------------------------------------------------------------

 
template< class TRANS_BASE, class TRANS, class PERS >
class TPAbstractPolyCnvBase
   : public ITPConverterFor< TRANS_BASE > 
{
public:
  typedef TRANS     Trans_t;
  typedef PERS      Pers_t;
  typedef PERS      PersBase_t;  // Obsolete, for backward compat
  
  TPAbstractPolyCnvBase() :
    m_pStorage(0),
    m_curRecLevel(0),
    m_recursive(false),
    m_ignoreRecursion(false)
  {}
  
  virtual ~TPAbstractPolyCnvBase() = default;
 
 
  // conversion methods - to be implemented in the concrete converter
  //                      -------------------------------------------
  
   virtual void persToTrans(const PERS* persObj, TRANS* transObj, MsgStream &log) = 0;
  
  virtual void transToPers(const TRANS* transObj, PERS* persObj, MsgStream &log) = 0;

   virtual void persToTransWithKey(const PERS* persObj, TRANS* transObj,
                                   const std::string& /*key*/,
                                   MsgStream &log)
  {
    return persToTrans (persObj, transObj, log);
  }
    
  
  virtual void transToPersWithKey(const TRANS* transObj, PERS* persObj,
                                  const std::string& /*key*/,
                                  MsgStream &log)
  {
    return transToPers (transObj, persObj, log);
  }

  virtual void persToTransUntyped(const void* pers,
                                  void* trans,
                                  MsgStream& log)
  {
    persToTrans (reinterpret_cast<const PERS*> (pers),
                 reinterpret_cast<TRANS*> (trans),
                 log);
  }

  virtual void transToPersUntyped(const void* trans,
                                  void* pers,
                                  MsgStream& log)
  {
    transToPers (reinterpret_cast<const TRANS*> (trans),
                 reinterpret_cast<PERS*> (pers),
                 log);
  }
  
  virtual void persToTransWithKeyUntyped(const void* pers,
                                         void* trans,
                                         const std::string& key,
                                         MsgStream& log)
  {
    persToTransWithKey (reinterpret_cast<const PERS*> (pers),
                        reinterpret_cast<TRANS*> (trans),
                        key,
                        log);
  }

  virtual void transToPersWithKeyUntyped(const void* trans,
                                         void* pers,
                                         const std::string& key,
                                         MsgStream& log)
  {
    transToPersWithKey (reinterpret_cast<const TRANS*> (trans),
                        reinterpret_cast<PERS*> (pers),
                        key,
                        log);
  }
  
  // Default implementations (usually no need to overwrite)
  // ------------------------------------------------------

  virtual PERS* createPersistent(const TRANS* transObj, MsgStream &log);

  virtual PERS* createPersistentWithKey(const TRANS* transObj,
                                        const std::string& key,
                                        MsgStream &log);

  TPObjRef toPersistentWithKey_impl( const TRANS *trans,
                                     const std::string& key,
                                     MsgStream &log );
 
  
  virtual const std::type_info& transientTInfo() const { return typeid(TRANS); }

  virtual const std::type_info& persistentTInfo() const { return typeid(PERS); }
 
//protected:
  // various virtual "redirector" methods

  virtual void  pstoreToTrans( unsigned index, TRANS_BASE *trans, MsgStream &log ) {
     assert (index < m_pStorage->size());
     TRANS* trans_der = dynamic_cast<TRANS*>(trans);
     if (!trans_der) std::abort();
     this->persToTrans( &(*m_pStorage)[index], trans_der, log );
  }

  virtual TPObjRef virt_toPersistent( const TRANS_BASE *trans, MsgStream &log )  {
     const TRANS* trans_der = dynamic_cast<const TRANS*>(trans);
     if (!trans_der) std::abort();
     return toPersistentWithKey_impl( trans_der, "", log);
  }

  virtual TPObjRef virt_toPersistentWithKey( const TRANS_BASE *trans,
                                             const std::string& key,
                                             MsgStream &log )
  {
     const TRANS* trans_der = dynamic_cast<const TRANS*>(trans);
     if (!trans_der) std::abort();
     return toPersistentWithKey_impl( trans_der, key, log);
  }

  virtual TRANS* virt_createTransFromPStore( unsigned, MsgStream& ) {     
     throw std::runtime_error(
    std::string("virt_createTransFromPStore() mothod not supported in TP converter for an abstract class: ")
    + typeid(*this).name() );
     return 0;
  }

  virtual TRANS* virt_createTransFromPStoreWithKey( unsigned, const std::string&, MsgStream& ) {     
     throw std::runtime_error(
    std::string("virt_createTransFromPStore() method not supported in TP converter for an abstract class: ")
    + typeid(*this).name() );
     return 0;
  }
 
public:
  void  setPStorage( std::vector< PERS > *storage ) {
     m_pStorage = storage;
     m_curRecLevel = 0;
  }

  void  setRecursive( bool flag=true ) {
     m_recursive = flag;
  }

  void  ignoreRecursion( bool flag=false ) {
     m_ignoreRecursion = flag;
  }

  virtual void  reservePStorage( size_t size ) {
     m_pStorage->reserve( size );
  }
 
protected:
  std::vector< PERS >   *m_pStorage;

  int           m_curRecLevel;

  bool          m_recursive;

  bool          m_ignoreRecursion;
};
 
 

template< class TRANS_BASE, class TRANS, class PERS >
class TPAbstractPolyCnvConstBase
   : public TPAbstractPolyCnvBase<TRANS_BASE, TRANS, PERS>
{
public:
  // To shorten using declarations in derived classes.
  using base_class = TPAbstractPolyCnvConstBase;
 

  virtual void persToTrans (const PERS* persObj,
                            TRANS* transObj,
                            MsgStream &log) const = 0;
 
  
  virtual void transToPers (const TRANS* transObj,
                            PERS* persObj,
                            MsgStream &log) const = 0;
 
 
  // These call through to the const implementations.
  virtual void persToTrans(const PERS* persObj,
                           TRANS* transObj,
                           MsgStream &log) override final
  {
    return const_cast<const TPAbstractPolyCnvConstBase*>(this)->persToTrans (persObj, transObj, log);
  }
 
  
  virtual void transToPers(const TRANS* transObj,
                           PERS* persObj,
                           MsgStream &log) override final
  {
    return const_cast<const TPAbstractPolyCnvConstBase*>(this)->transToPers (transObj, persObj, log);
  }
};
 
 
 
// --------------------------------------------------------------
 
 
// Base converter template for polymorphic types
 
// Converters for objects in the same inheritance tree must share the same
// base class type:  TRANS_BASE

 
template< class TRANS_BASE, class TRANS, class PERS >
class TPPolyCnvBase
   : public TPAbstractPolyCnvBase< TRANS_BASE, TRANS, PERS > 
{
public:
  TPPolyCnvBase() {}
  virtual ~TPPolyCnvBase() = default;
 
 
  // Default implementations (usually no need to overwrite)
  // ------------------------------------------------------

  virtual TRANS* createTransient(const PERS* persObj, MsgStream &log);

  virtual TRANS* createTransientWithKey(const PERS* persObj, const std::string& key, MsgStream &log);

  virtual TRANS* virt_createTransFromPStore( unsigned index, MsgStream &log )  {
     assert (index < this->m_pStorage->size());
     return createTransient( &(*this->m_pStorage)[index], log );
  }

  virtual TRANS* virt_createTransFromPStoreWithKey( unsigned index,
                                                    const std::string& key,
                                                    MsgStream &log )
  {
     assert (index < this->m_pStorage->size());
     return createTransientWithKey( &(*this->m_pStorage)[index], key, log );
  }
 
};
 
 

template< class TRANS, class PERS >
class TPConverterBase
   : public TPPolyCnvBase< TRANS, TRANS,  PERS >
{
public:
  TPConverterBase() {}
  virtual ~TPConverterBase() = default;
 
 
  // implement these methods without dynamic cast to TRANS

  virtual TPObjRef virt_toPersistent( const TRANS *trans, MsgStream &log ) {
    return this->toPersistentWithKey_impl( trans, "", log);
  }

  virtual TPObjRef virt_toPersistentWithKey( const TRANS *trans,
                                             const std::string& key,
                                             MsgStream &log )
  {
     return this->toPersistentWithKey_impl( trans, key, log);
  }

  virtual void  pstoreToTrans( unsigned index, TRANS *trans, MsgStream &log ) {
     assert (index < this->m_pStorage->size());
     this->persToTrans( &(*this->m_pStorage)[index], trans, log );
  }
 
};
 

template< class TRANS, class PERS >
class TPConverterConstBase
   : public TPConverterBase< TRANS,  PERS >
{
public:
  // To shorten using declarations in derived classes.
  using base_class = TPConverterConstBase;
 

  virtual void persToTrans (const PERS* persObj,
                            TRANS* transObj,
                            MsgStream &log) const = 0;
 
  
  virtual void transToPers (const TRANS* transObj,
                            PERS* persObj,
                            MsgStream &log) const = 0;
 
 
  // These call through to the const implementations.
  virtual void persToTrans(const PERS* persObj,
                           TRANS* transObj,
                           MsgStream &log) override final
  {
    return const_cast<const TPConverterConstBase*>(this)->persToTrans (persObj, transObj, log);
  }
 
  
  virtual void transToPers(const TRANS* transObj,
                           PERS* persObj,
                           MsgStream &log) override final
  {
    return const_cast<const TPConverterConstBase*>(this)->transToPers (transObj, persObj, log);
  }
 
 
  virtual TRANS* createTransientConst (const PERS* persObj, MsgStream& log) const;
  virtual PERS* createPersistentConst(const TRANS* transObj, MsgStream &log) const;
};
 

template< class TRANS, class PERS >
class TPConverterWithKeyBase
   : public TPConverterConstBase< TRANS,  PERS >
{
public:
  using TPConverterConstBase< TRANS,  PERS >::transToPers;
  using TPConverterConstBase< TRANS,  PERS >::persToTrans;
 
  // To shorten using declarations in derived classes.
  using base_class = TPConverterWithKeyBase;
 

  virtual void persToTransWithKey (const PERS* persObj,
                                   TRANS* transObj,
                                   const std::string& key,
                                   MsgStream &log) const = 0;
 
  
  virtual void transToPersWithKey (const TRANS* transObj,
                                   PERS* persObj,
                                   const std::string& key,
                                   MsgStream &log) const = 0;
 
 
  // These call through to the const implementations.
  virtual void persToTransWithKey (const PERS* persObj,
                                   TRANS* transObj,
                                   const std::string& key,
                                   MsgStream &log) override final
  {
    return const_cast<const TPConverterWithKeyBase*>(this)->persToTransWithKey (persObj, transObj, key, log);
  }
 
 
  virtual void transToPersWithKey (const TRANS* transObj,
                                   PERS* persObj,
                                   const std::string& key,
                                   MsgStream &log) override final
  {
    return const_cast<const TPConverterWithKeyBase*>(this)->transToPersWithKey (transObj, persObj, key, log);
  }
 
 
  // It's an error if the non-key versions get called.
  virtual void persToTrans(const PERS* /*persObj*/,
                           TRANS* /*transObj*/,
                           MsgStream& /*log*/) const override final
  {
    throw std::runtime_error ("persToTrans called where persToTransWithKey required.");
  }
 
  
  virtual void transToPers(const TRANS* /*transObj*/,
                           PERS* /*persObj*/,
                           MsgStream& /*log*/) const override final
  {
    throw std::runtime_error ("transToPers called where transToPersWithKey required.");
  }
};
 
 
// --------------------------------------------------------------

template<class TRANS, class PERS, class CONV>
class TPPtrVectorCnv : public TPConverterBase<TRANS, PERS> {
public:
  TPPtrVectorCnv() : m_elementCnv(0)  {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) {
     transVect->clear();
     transVect->reserve( persVect->size() );
     // convert vector entries one by one
     for( typename PERS::const_iterator 
        it   = persVect->begin(),
        iEnd = persVect->end();
      it != iEnd;  ++it ) {
    transVect->push_back( this->createTransFromPStore( &m_elementCnv, *it, log ) );
     }        
  }
  

  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) {
     persVect->clear();
     persVect->reserve( transVect->size() );
     // convert vector entries one by one
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  
      ++it ) {
       persVect->push_back( this->toPersistent( &m_elementCnv, *it, log ) );
     }       
  }
 
protected:
  CONV  *m_elementCnv;  
};
 
 
 
// --------------------------------------------------------------

template<class TRANS, class PERS, class CONV>
class TPPtrVectorCnvConst : public TPConverterConstBase<TRANS, PERS> {
public:
  using TPConverterConstBase<TRANS, PERS>::transToPers;
  using TPConverterConstBase<TRANS, PERS>::persToTrans;
 
 
  TPPtrVectorCnvConst() {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) const override {
     transVect->clear();
     transVect->reserve( persVect->size() );
     // convert vector entries one by one
     CONV* cnv = nullptr;
     for( typename PERS::const_iterator 
        it   = persVect->begin(),
        iEnd = persVect->end();
      it != iEnd;  ++it ) {
       transVect->push_back( this->createTransFromPStore( &cnv,
                                                           *it, log ) );
     }        
  }
  

  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) const override
  {
     persVect->clear();
     persVect->reserve( transVect->size() );
     // convert vector entries one by one
     CONV* cnv = nullptr;
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  ++it ) {
        persVect->push_back( this->toPersistent( &cnv, *it, log ) );
     }       
  }
};
 
 
 
// --------------------------------------------------------------

template<class TRANS, class PERS, class CONV>
class TPThinnedPtrVectorCnv : public TPConverterWithKeyBase<TRANS, PERS> {
public:
  using TPConverterWithKeyBase<TRANS, PERS>::transToPersWithKey;
  using TPConverterWithKeyBase<TRANS, PERS>::persToTransWithKey;
 
 
  TPThinnedPtrVectorCnv() {}

  virtual void persToTransWithKey (const PERS* persVect,
                                   TRANS* transVect,
                                   const std::string& /*key*/,
                                   MsgStream &log) const override
  {
     transVect->clear();
     transVect->reserve( persVect->size() );
     // convert vector entries one by one
     CONV* cnv = nullptr;
     for( typename PERS::const_iterator 
        it   = persVect->begin(),
        iEnd = persVect->end();
      it != iEnd;  ++it ) {
       transVect->push_back( this->createTransFromPStore( &cnv,
                                                           *it, log ) );
     }        
  }
  

  virtual void transToPersWithKey (const TRANS* transVect,
                                   PERS* persVect,
                                   const std::string& key,
                                   MsgStream &log) const override
  {
     const SG::ThinningDecisionBase* dec = SG::getThinningDecision (key);
     persVect->clear();
     persVect->reserve( transVect->size() );
     // convert vector entries one by one
     CONV* cnv = nullptr;
     size_t ipos = 0;
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  ++it, ++ipos )
     {
       if (!dec || !dec->thinned (ipos)) {
         persVect->push_back( this->toPersistent( &cnv, *it, log ) );
       }
     }       
  }
};
 
 
 
// --------------------------------------------------------------
template<class TRANS, class PERS, class CONV>
class TPPolyVectorCnv : public TPPtrVectorCnv<TRANS, PERS, CONV> {
public:
  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) {
     persVect->clear();
     persVect->reserve( transVect->size() );
     // convert vector entries one by one
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  ++it ) {
    persVect->push_back( this->toPersistent( (CONV**)0, *it, log ) );
     }       
  }
};
 

template<class TRANS, class PERS, class CONV>
class TPPolyVectorCnvConst : public TPPtrVectorCnvConst<TRANS, PERS, CONV> {
public:
  using TPPtrVectorCnvConst<TRANS, PERS, CONV>::transToPers;
  using TPPtrVectorCnvConst<TRANS, PERS, CONV>::persToTrans;
 

  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) const {
     persVect->clear();
     persVect->reserve( transVect->size() );
     // convert vector entries one by one
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  ++it ) {
    persVect->push_back( this->toPersistent( (CONV**)0, *it, log ) );
     }       
  }
};
 
 
/*
  Converter between
  transient vector<T> (by value) and persistent vector<TPObjRef>  
*/
 
template<class TRANS, class PERS, class CONV>
class TPValVectorCnv : public TPConverterBase<TRANS, PERS> {
public:
  TPValVectorCnv()  : m_elementCnv(0) {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) {
     transVect->clear();
     transVect->reserve( persVect->size() );
     // convert vector entries one by one
     typename TRANS::iterator ti = transVect->begin();
     typename PERS::const_iterator pi = persVect->begin(), iEnd = persVect->end();
     for( ; pi != iEnd;  ++pi, ++ti ) {
        fillTransFromPStore( &m_elementCnv, *pi, &*ti, log );
     }
  }
  
  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) {
     persVect->clear();
     persVect->reserve( transVect->size() );
     // convert vector entries one by one
     for( typename TRANS::const_iterator
             it = transVect->begin(), iEnd = transVect->end();
      it != iEnd; ++it ) {
        persVect->push_back( toPersistent( &m_elementCnv, &*it, log ) );
     }
  }
  
protected:
  CONV  *m_elementCnv;
};
 
 
 
// --------------------------------------------------------------
/*
  Converter between
  transient AthenaHistVector of T* and persistent vector<T>
*/
 
template<class TRANS, class PERS, class CONV>
class T_AthenaHitsVectorCnv : public TPConverterBase<TRANS, PERS> {
public:
    T_AthenaHitsVectorCnv() {}

  virtual void persToTrans(const PERS* persCont, TRANS* transCont, MsgStream &log);
  virtual void transToPers(const TRANS* transCont, PERS* persCont, MsgStream &log);
};
 
 
// --------------------------------------------------------------
/*
  Converter between
  transient AtlasHitsVector of T* and persistent vector<T>
*/
 
template<class TRANS, class PERS, class CONV>
class T_AtlasHitsVectorCnv : public TPConverterBase<TRANS, PERS> {
public:
    T_AtlasHitsVectorCnv() {}

  virtual void persToTrans(const PERS* persCont, TRANS* transCont, MsgStream &log);
  virtual void transToPers(const TRANS* transCont, PERS* persCont, MsgStream &log);
};
 
 
// -------------------------------
//  OLD STYLE vector TP converters
//  TP conversion in-place, not involving top-level objects or TPRefs
// -------------------------------------------------------------------
/*
  Converter between
  transient vector of T* (like DataVector<T>)
  and persistent vector<T>
*/
 
template<class TRANS, class PERS, class CONV>
class TPCnvVector : public TPConverterBase<TRANS, PERS> {
public:
  TPCnvVector() {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log);
  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log);

  CONV  m_elementCnv;
};
 
 
template<class TRANS, class PERS, class CONV>
class TPCnvVectorConst : public TPConverterConstBase<TRANS, PERS> {
public:
  TPCnvVectorConst() {}
 
  using TPConverterConstBase<TRANS, PERS>::transToPers;
  using TPConverterConstBase<TRANS, PERS>::persToTrans;

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) const override;
  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) const override;
};
 
 
/*
  Converter between
  transient vector of T and persistent vector<T>
*/
 
template<class TRANS, class PERS, class CONV>
class TPCnvStdVector : public TPConverterBase<TRANS, PERS> {
public:
  TPCnvStdVector() {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) ;
  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) ;
};
 

template<class TRANS, class PERS, class CONV>
class TPCnvStdVectorConst : public TPConverterConstBase<TRANS, PERS>
{
public:
  using TPConverterConstBase<TRANS, PERS>::transToPers;
  using TPConverterConstBase<TRANS, PERS>::persToTrans;
 

  virtual void persToTrans(const PERS* persVect,
                           TRANS* transVect,
                           MsgStream &log) const override;

  virtual void transToPers(const TRANS* transVect,
                           PERS* persVect,
                           MsgStream &log) const override;
};
 
 
//---------------------------------------------------------------------------------
/*
  Converter between
  transient IdentifiableContainer<T> and persistent std::vector<T>
  Used by Muon RDO containers 
  This version assumes RDO collection returns an identifier as a unsigned int.
*/
 
template<class TRANS, class PERS, class CONV>
class TPCnvIDCont : public TPConverterBase<TRANS, PERS> {
public:
  TPCnvIDCont() {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) ;

  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) ;
 
  typedef typename TRANS::IDENTIFIABLE COLLECTION_t;

  CONV  m_elementCnv;
};
 
//---------------------------------------------------------------------------------
/*
  Converter between
  transient IdentifiableContainer<T> and persistent std::vector<T>
  Used by Muon RDO containers
  This version assumes RDO collection returns an identifier as an Identifier
*/
 
template<class TRANS, class PERS, class CONV>
class TPCnvIDContFromIdentifier : public TPConverterBase<TRANS, PERS> {
public:
  TPCnvIDContFromIdentifier() {}

  virtual void persToTrans(const PERS* persVect, TRANS* transVect, MsgStream &log) ;

  virtual void transToPers(const TRANS* transVect, PERS* persVect, MsgStream &log) ;
 
  typedef typename TRANS::IDENTIFIABLE COLLECTION_t;

  CONV  m_elementCnv;
};
 
 
 
#include "TPConverter.icc"
#endif