TopLevelTPConverter.h

Go to the documentation of this file.

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

 
#include "TopLevelTPCnvBaseP.h"
#include "TPConverter.h"
#include "CxxUtils/checker_macros.h"
 

 
template< class MAIN_CNV, class TL_PERS >
class TopLevelTPConverter
   : public TopLevelTPCnvBaseP< TL_PERS >
   , public ITPCnvBase
{
public:
  typedef typename MAIN_CNV::Trans_t    TRANS;
  typedef TL_PERS                       PERS;
 
  // ----  Methods to be implement in the derived converter:
 
  // this declaration is repeated here for clarity 
  virtual void  setPStorage( TL_PERS* persObj) override = 0;

  TopLevelTPConverter() {}
 
 
  // ----- default implementations

  TRANS*  createTransient( MsgStream &log ) {
     // 0 is the index of the main and only one top level object
     TRANS *transObj = m_mainConverter.virt_createTransFromPStore( 0, log );
     this->deleteTLPersObject();
     return transObj;
  }
  

  TRANS*  createTransientWithKey( const std::string& key,
                                  MsgStream &log )
  {
     // 0 is the index of the main and only one top level object
    TRANS *transObj = m_mainConverter.virt_createTransFromPStoreWithKey( 0, key, log );
     this->deleteTLPersObject();
     return transObj;
  }
  

  virtual TRANS*  createTransient(const TL_PERS* persObj, MsgStream &log) {
     // FIXME: TPConverter uses the same non-const member m_pStorage
     // for both reading and writing, but we want it to be const
     // in the former case.
     TL_PERS* pers_nc ATLAS_THREAD_SAFE = const_cast<TL_PERS*>(persObj);
     setPStorage( pers_nc ); 
     return createTransient( log );
  }

  virtual TL_PERS*  createPersistent(const TRANS* transObj, MsgStream &log)
  {
     // create a new persistent object (empty)
     this->createTLPersObject();
     // do transToPers conversion, fill in the persistent object
     m_mainConverter.virt_toPersistent(transObj, log);
     // take the persistent object away from the TL converter 
     TL_PERS    *ret = this->getTLPersObject();
     // important to clear so createTransient() will not try to delete it (and crash)
     this->clearTLPersObject();
     return ret;
  }

  virtual TL_PERS*  createPersistentWithKey(const TRANS* transObj,
                                            const std::string& key,
                                            MsgStream &log)
  {
     // create a new persistent object (empty)
     this->createTLPersObject();
     // do transToPers conversion, fill in the persistent object
     m_mainConverter.virt_toPersistentWithKey(transObj, key, log);
     // take the persistent object away from the TL converter 
     TL_PERS    *ret = this->getTLPersObject();
     // important to clear so createTransient() will not try to delete it (and crash)
     this->clearTLPersObject();
     return ret;
  }

  void  addMainTPConverter() {  this->addTPConverter( &m_mainConverter ); }

  // moved to a template to accomodate TPIntegerVectorStorage_pN classes
  // without whole class specialization
  template< typename STORAGE >
  void  setMainCnvPStorage( STORAGE* storage ) {
     m_mainConverter.setPStorage( storage );
  }

  virtual unsigned short    getConverterID() override { return 0; }
 
 
  //- --------------------------------------------------------------------------
  // implementation of ITPCnvBase interface

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

  virtual const std::type_info& persistentTInfo() const override { return typeid(PERS); }
 

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

  virtual void transToPersUntyped(const void* trans, void* pers, MsgStream& log) override {
     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) override
  {
     persToTrans( reinterpret_cast<const PERS*>(pers), reinterpret_cast<TRANS*>(trans), log );
  }

  virtual void transToPersWithKeyUntyped(const void* trans,
                                         void* pers,
                                         const std::string& /*key*/,
                                         MsgStream& log) override
  {
     transToPers( reinterpret_cast<const TRANS*>(trans),  reinterpret_cast<PERS*>(pers), log );
  }
 
  // ----------------------  methods used by T_TPCnv<> converters
  virtual void persToTrans (const PERS* pers, TRANS* trans, MsgStream& msg) {
    // FIXME: TPConverter uses the same non-const member m_pStorage
    // for both reading and writing, but we want it to be const
    // in the former case.
    TL_PERS* pers_nc ATLAS_THREAD_SAFE = const_cast<TL_PERS*>(pers);
    setPStorage( pers_nc ); 
    m_mainConverter.pstoreToTrans (0, trans, msg);
  }
  
  virtual void transToPers(const TRANS* trans, PERS* pers, MsgStream& msg) {
    this->setTLPersObject( pers );
    m_mainConverter.virt_toPersistent(trans, msg);
    this->clearTLPersObject();
  }
 
protected:
  MAIN_CNV      m_mainConverter;
 
};
 
#endif