T_AthenaPoolViewVectorCnv.icc

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
/**
 * @file AthenaPoolCnvSvc/T_AthenaPoolViewVectorCnv.icc
 * @author scott snyder <snyder@bnl.gov>
 * @date Jan, 2016
 * @brief Athena pool converter for a ViewVector class.
 */
 
 
#include "CxxUtils/no_sanitize_undefined.h"
 
 
/**
 * @brief Constructor.
 * @param svcloc The Gaudi service locator.
 */
template <class DV>
T_AthenaPoolViewVectorCnv<DV>::T_AthenaPoolViewVectorCnv (ISvcLocator* svcloc)
  : Base (svcloc)
{
}
 
 
template <class DV>
std::vector<pool::Guid>
T_AthenaPoolViewVectorCnv<DV>::initGuids (const std::type_info& ti) const
{
  std::vector<Guid> guids;
  
  // Make a list of all the guids that this converter can read.
  // First, add the entry for pers_t.
  pool::TypeH typ = pool::DbReflex::forTypeInfo (ti);
  if (!typ)
    AthenaPoolCnvSvc::throwExcNoDictForClass (ti);
  guids.push_back (pool::DbReflex::guid (typ));
 
  // Now look for entries for previous versions.
  // Look for a version tag in the type name and try replacing it with
  // previous versions.  Eg, if the name for pers_t contains `_v3',
  // then we also look for guids for the same name with `_v3' replaced
  // by `_v2' and `_v1'.
 
  std::string name = typ.Name();
  std::string::size_type vpos = 0;
  while ((vpos = name.find ("_v", vpos)) != std::string::npos) {
    vpos += 2;
    std::string::size_type vpos2 = vpos;
    if (isdigit (name[vpos2])) {
      ++vpos2;
      while (vpos2 < name.size() && isdigit (name[vpos2]))
        ++vpos2;
      if (vpos2 < name.size() && name[vpos2] == '>') {
        int vers = atoi (name.substr (vpos, vpos2-vpos).c_str());
        while (--vers > 0) {
          std::string name2 = name.substr(0,vpos) + CxxUtils::strformat("%d", vers) + name.substr(vpos2,std::string::npos);
          pool::TypeH typ2 = pool::DbReflex::forTypeName (name2);
          if (typ2)
            guids.push_back (pool::DbReflex::guid (typ2));
        }
      }
    }
  }
 
  return guids;
}
 
  
/**
 * @brief Standard Gaudi initialize method.
 */
template <class DV>
StatusCode
T_AthenaPoolViewVectorCnv<DV>::initialize()
{
  CHECK( Base::initialize() );
 
  m_guids = initGuids (typeid(pers_t));
  m_guids2 = initGuids (typeid(pers2_t));
 
  return StatusCode::SUCCESS;
}
 
 
/**
 * @brief Convert a transient object to persistent form.
 * @param trans The transient object to convert.
 *
 * Returns a newly-allocated persistent object.
 */
template <class DV>
typename T_AthenaPoolViewVectorCnv<DV>::pers_t*
T_AthenaPoolViewVectorCnv<DV>::createPersistent( trans_t* trans )
{
  AthenaPoolCnvSvc::debugCreatePersistent (ClassID_traits<DV>::ID());
  pers_t* pers =  new pers_t (*trans);
  pers->setClearOnPersistent();
  return pers;
}
 
 
/**
 * @brief Read the persistent object and convert it to transient.
 *
 * Returns a newly-allocated transient object.
 * Errors are reported by raising exceptions.
 */
template <class DV>
typename T_AthenaPoolViewVectorCnv<DV>::trans_t*
T_AthenaPoolViewVectorCnv<DV>::createTransient NO_SANITIZE_UNDEFINED ()
{
  AthenaPoolCnvSvc::debugCreateTransient (ClassID_traits<DV>::ID());
  // See if we're looking at one of the guids we can handle.
  // FIXME: For old persistent versions, this works by essentially doing
  // a reinterpret_cast from the version on the file to the current version.
  // That works for current ElementLink classes, but it's not very nice.
  // This also gets a ubsan warning with gcc6.2, so we suppress it
  // for this function.
  for (const pool::Guid& guid : m_guids) {
    if( this->compareClassGuid( guid ) ) {
      std::unique_ptr<pers_t> v (this->template poolReadObject< pers_t >());
      if (guid != m_guids.front()) {
        auto v2 = std::make_unique<pers_t> (*v);
        // Strictly superfluous, but allows suppressing the ubsan warning 
        // about implicit reinterpret_cast by moving the locus into this
        // function (which we've tagged with NO_SANITIZE_UNDEFINED)
        // rather than in a libtsdc++ function.
        delete v.release();
        v = std::move (v2);
        // root read rule doesn't do anything in this case.
        v->toTransient();
      }
      v->clearPersistent();
      return v.release();
    }
  }
 
 
  for (const pool::Guid& guid : m_guids2) {
    if( this->compareClassGuid( guid ) ) {
      std::unique_ptr<pers2_t> v (this->template poolReadObject< pers2_t >());
      auto c = std::make_unique<ConstDataVector<trans_t> > (*v);
      // FIXME: To get rid of this @c const_cast, the converter interfaces
      // need to be changed to allow returning a const pointer
      // all the way back to StoreGate.
      trans_t* vv ATLAS_THREAD_SAFE = const_cast<trans_t*>(c.release()->asDataVector());
      vv->clearPersistent();
      return vv;
    }
  }
   
  // Didn't recognize the ID.
  AthenaPoolCnvSvc::throwExcUnsupportedVersion (typeid(pers_t),
                                                this->m_i_poolToken->classID());
  return 0;
}