TPIntVectorCnv_p1.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAPOOLCNVSVC_T_ATHENAPOOLTPVECTORCNV_H
#define ATHENAPOOLCNVSVC_T_ATHENAPOOLTPVECTORCNV_H
 
#include "AthenaPoolUtilities/TPIntegerVector.h"
#include "TPConverter.h"
 
 
template< class TRANS_BASE, class TRANS >
class TPAbstractPolyCnvBase < TRANS_BASE, TRANS, TPIntegerVector_p1 > : public ITPConverterFor< TRANS_BASE > 
{
public:
  typedef TRANS     Trans_t;
  typedef TPIntegerVector_p1  PERS;
  
  TPAbstractPolyCnvBase() :m_pStorage(0), m_curRecLevel(0){}
  
  virtual ~TPAbstractPolyCnvBase() {}
 
 
  // 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 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);
  }
  
  // Default implementations (usually no need to overwrite)
  // ------------------------------------------------------

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

  TPObjRef toPersistent_impl( const TRANS *trans, MsgStream &log );
 
  
  virtual const std::type_info& transientTInfo() const { return typeid(TRANS); }
 
//protected:
  // various virtual "redirector" methods

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

  virtual TPObjRef virt_toPersistent( const TRANS_BASE *trans, MsgStream &log )  {
     return toPersistent_impl( dynamic_cast<const TRANS*>(trans), 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;
  }
 
public:
  void  setPStorage( TPIntegerVectorStorage_p1 *storage ) {
     m_pStorage = storage;
     m_curRecLevel = 0;
  }

  virtual void  reservePStorage( size_t size ) {
     m_pStorage->reserve( size );
  }
  
protected:
  TPIntegerVectorStorage_p1    *m_pStorage;

  int           m_curRecLevel;

  bool          m_recursive;
};
 
 
 
// --------------------------------------------------------------
 
// 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 TPPolyCnvBase<  TRANS_BASE, TRANS, TPIntegerVector_p1 >  : public TPAbstractPolyCnvBase< TRANS_BASE, TRANS, TPIntegerVector_p1 > 
{
public:
  TPPolyCnvBase() {}
  virtual ~TPPolyCnvBase() {}
 
  typedef TPIntegerVector_p1 PERS;
 
  // Default implementations (usually no need to overwrite)
  // ------------------------------------------------------

  virtual TRANS* createTransient(const PERS* persObj, MsgStream &log) {
     std::unique_ptr<TRANS> trans(new TRANS());
     persToTrans(persObj, trans.get(), log);
     return(trans.release());
  }
  
  virtual TRANS* virt_createTransFromPStore( unsigned index, MsgStream &log )  {
     assert (index < this->m_pStorage->size());
     PERS pers = (*this->m_pStorage)[index];
     return createTransient( &pers, log );
  }
};
 
 

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

  virtual TPObjRef virt_toPersistent( const TRANS *trans, MsgStream &log ) {
     return toPersistent_impl( trans, log );
  }

  virtual void  pstoreToTrans( unsigned index, TRANS *trans, MsgStream &log ) {
     assert (index < this->m_pStorage->size());
     PERS pers = (*this->m_pStorage)[index];
     persToTrans( &pers, trans, log );
  }
 
};
 
 
 
 
template< class TRANS_BASE, class TRANS >
TPObjRef
TPAbstractPolyCnvBase<TRANS_BASE, TRANS, TPIntegerVector_p1>::
toPersistent_impl( const TRANS *trans, MsgStream &log ){
   // make sure there is a storage object
//   if( !this->topConverter()->hasTLPersObject() ) {
//      this->topConverter()->createTLPersObject();
//   }
   // make a new space in the storage vector
   m_pStorage->grow();
 
   if( m_curRecLevel > 0 ) {
      throw std::runtime_error(
     std::string("T/P converter: ") + typeid(*this).name()
     + " recursive usage not supported! " );
   }
   m_curRecLevel++;
   PERS pers = m_pStorage->back();
   transToPers( trans, &pers, log);
   m_curRecLevel--;
   
   return TPObjRef( this->m_pStorageTID, m_pStorage->size()-1 );
}
 
 
#endif