TPIntVectorCnv_p2.h

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef T_ATHENAPOOLTPINTVECTORCNV_H
#define T_ATHENAPOOLTPINTVECTORCNV_H

 
#include "TPConverter.h"
#include "AthenaPoolUtilities/TPIntegerVector_p2.h"
 
#include <stdexcept>
 
 
template< class TRANS_BASE, class TRANS >
class TPAbstractPolyCnvBase< TRANS_BASE, TRANS, TPIntegerVector_p2 >
   : public ITPConverterFor< TRANS_BASE > 
{
public:
  typedef TRANS         Trans_t;
  typedef TPIntegerVector_p2  Pers_t;
  
  TPAbstractPolyCnvBase() :  m_pStorage(0)
  {}
  
  virtual ~TPAbstractPolyCnvBase() {}
 
 
  // conversion methods - to be implemented in the concrete converter
  //                      -------------------------------------------
  
   virtual void persToTrans(const Pers_t* persObj, TRANS* transObj, MsgStream &log) = 0;
  
  virtual void transToPers(const TRANS* transObj, Pers_t* persObj, MsgStream &log) = 0;

  virtual void persToTransUntyped(const void* pers,
                                  void* trans,
                                  MsgStream& log)
  {
    persToTrans (reinterpret_cast<const Pers_t*> (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_t*> (pers),
                 log);
  }
  
  // Default implementations (usually no need to overwrite)
  // ------------------------------------------------------

  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_t 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_p2 *storage ) {
     m_pStorage = storage;
  }

  virtual void  reservePStorage( size_t size ) {
     m_pStorage->reserve( size );
  }
  
protected:
  TPIntegerVectorStorage_p2    *m_pStorage;
};
 
 
 
// --------------------------------------------------------------
 
// 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_p2 >
   : public TPAbstractPolyCnvBase< TRANS_BASE, TRANS, TPIntegerVector_p2 > 
{
public:
  TPPolyCnvBase() {}
  virtual ~TPPolyCnvBase() {}
 
  typedef TPIntegerVector_p2 Pers_t;
 
  // Default implementations (usually no need to overwrite)
  // ------------------------------------------------------

  virtual TRANS* createTransient(const Pers_t* 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_t pers = (*this->m_pStorage)[index];
     return createTransient( &pers, log );
  }
};
 
 

template< class TRANS >
class TPCnvBase< TRANS,  TPIntegerVector_p2 >
   : public TPPolyCnvBase< TRANS, TRANS, TPIntegerVector_p2 >
{
public:
  TPCnvBase() {}
  virtual ~TPCnvBase() {}
 
  typedef TPIntegerVector_p2 Pers_t;
 
  // 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_t pers = (*this->m_pStorage)[index];
     persToTrans( &pers, trans, log );
  }
 
};
 
 
 
template< class TRANS_BASE, class TRANS >
TPObjRef
TPAbstractPolyCnvBase<TRANS_BASE, TRANS, TPIntegerVector_p2>::
toPersistent_impl( const TRANS *trans, MsgStream &log )
{
   // make sure there is a storage object
   if( !this->topConverter()->hasTLPersObject() ) {
      this->topConverter()->createTLPersObject();
   }
 
   unsigned pos =  m_pStorage->size();
   // make a new space in the storage vector
   m_pStorage->grow();
 
   Pers_t pers = m_pStorage->back();
   transToPers( trans, &pers, log);
   
   return TPObjRef( this->m_pStorageTID, pos );
}
 
 
 
 
 
 
 
// --------------------------------------------------------------

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

  virtual void persToTrans(const TPIntegerVector_p2 * persVect, TRANS* transVect, MsgStream &log) {
     TPIntegerVector_p2::const_iterator piter = persVect->begin();
     size_t pers_size = persVect->next(piter);
     transVect->clear();
     transVect->reserve( pers_size );
     // convert vector entries one by one
     while( pers_size-- ) {
    transVect->push_back( createTransFromPStore( &m_elementCnv, persVect->next_TPObjRef(piter), log ) );
     }
  }

  virtual void transToPers(const TRANS* transVect, TPIntegerVector_p2* persVect, MsgStream &log) {
     persVect->reserve( 1 + transVect->size()*2 );
     persVect->push_back( transVect->size() );
     // convert vector entries one by one
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  
      ++it ) {
       persVect->push_TPObjRef( toPersistent( &m_elementCnv, *it, log ) );
     }       
  }
 
protected:
  CONV  *m_elementCnv;  
};
 
 
 
// --------------------------------------------------------------
template<class TRANS, class CONV>
class TPPolyVectorCnv<TRANS, TPIntegerVector_p2, CONV >
   : public TPPtrVectorCnv<TRANS, TPIntegerVector_p2, CONV> {
public:
  virtual void transToPers(const TRANS* transVect, TPIntegerVector_p2* persVect, MsgStream &log)
  {
     persVect->reserve( 1 + transVect->size()*2 );
     persVect->push_back( transVect->size() );
     // convert vector entries one by one
     for( typename TRANS::const_iterator 
        it   = transVect->begin(),
        iEnd = transVect->end();
      it != iEnd;  
      ++it ) {
       persVect->push_TPObjRef( 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 TPCnvBase<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;
};
 
*/
 
#endif