SGDataVectorGetterTool.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/

 
 
#include "SGDataVectorGetterTool.h"
#include "AthContainers/tools/DVLInfo.h"
#include "CxxUtils/checker_macros.h"
#include "TROOT.h"
#include "TMethodCall.h"
 
 
namespace D3PD {
 

SGDataVectorGetterTool::SGDataVectorGetterTool
  (const std::string& type,
   const std::string& name,
   const IInterface* parent)
    : SGGetterImpl (name, this->evtStore()),
      CollectionGetterToolImpl (type, name, parent),
      m_athenaPoolCnvSvc ("AthenaPoolCnvSvc", name),
      m_info (0),
      m_it (0)
{
  SGGETTERIMPL_PROPS;
}
 

StatusCode SGDataVectorGetterTool::initialize()
{
  CHECK( m_athenaPoolCnvSvc.retrieve() );
 
  // Initialize the code getting the collection from SG.
  CHECK( SGGetterImpl::initializeImpl() );
 
  // Find the DataVector/DataList information for this collection.
  m_info = getInfo (typeinfo());
 
  // We couldn't find it.
  // Maybe we haven't yet loaded a library that has a complete
  // instantiation of the DataVector class.  Try loading the pool
  // converter, and see if that'll do it.
  if (!m_info) {
    m_athenaPoolCnvSvc->converter (clid());
    m_info = getInfo (typeinfo());
  }
 
  // Maybe it didn't.  (Once we make the info method virtual, then loading
  // the converter should always do it.  But now, maybe not.)
  // As a last attempt, try to load a dictionary for the class.
  if (!m_info) {
    TClass* cls = gROOT->GetClass (m_typename.c_str());
    cls->GetBaseClass ("SG::AuxElement");
    m_info = getInfo (typeinfo());
  }
 
  // Ok, one more try...
  if (!m_info) {
    TClass* cls = gROOT->GetClass (m_typename.c_str());
    TMethodCall meth (cls, "initHelper", "");
    if (meth.IsValid())
      meth.Execute();
    m_info = getInfo (typeinfo());
  }
  if (!m_info) {
    TClass* cls = gROOT->GetClass (m_typename.c_str());
    TMethodCall meth (cls, "dvlinfo", "");
    if (meth.IsValid())
      meth.Execute();
    m_info = getInfo (typeinfo());
  }
 
  if (!m_info) {
    REPORT_MESSAGE (MSG::ERROR)
      << "Can't find DataVector/DataList info for class " << m_typename;
    return StatusCode::FAILURE;
  }
 
  // We need to convert from the type we get from SG to the DV/DL base class.
  CHECK( m_converter.init (typeinfo(), m_info->tinfo()) );
 
  return CollectionGetterToolImpl::initialize();
}
 

StatusCode SGDataVectorGetterTool::finalize()
{
  delete m_it;
  m_it = 0;
  return StatusCode::SUCCESS;
}
 

const std::type_info& SGDataVectorGetterTool::elementTypeinfo() const
{
  return m_info->elt_tinfo();
}
 

StatusCode SGDataVectorGetterTool::reset (bool allowMissing /*= false*/)
{
  delete m_it;
  const void* p0 = getUntyped (allowMissing);
  if (allowMissing && p0 == 0) {
    m_it = 0;
    return StatusCode::SUCCESS;
  }
  const void* p = m_converter.convertUntyped (p0);
  if (p) {
    // need non-const pointer to call `base`
    void* nonconst_p ATLAS_THREAD_SAFE = const_cast<void*> (p);
    SG::AuxVectorBase* auxbase = m_info->base (nonconst_p);
    if (auxbase && auxbase->trackIndices() && !auxbase->getConstStore()) {
      // Try to retrieve a corresponding aux store.
      const SG::IConstAuxStore* store =
        evtStore()->tryConstRetrieve<SG::IConstAuxStore> (m_resolver.key() + "Aux.");
      if (store)
        auxbase->setStore (store);
    }
    m_it = m_info->iterator (p);
    return StatusCode::SUCCESS;
  }
  else {
    m_it = 0;
    return StatusCode::FAILURE;
  }
}
 

const void* SGDataVectorGetterTool::nextUntyped()
{
  if (m_it)
    return m_it->next();
  return 0;
}
 

size_t SGDataVectorGetterTool::sizeHint (bool allowMissing /*= false*/)
{
  // need non-const pointer to call `size`
  void* p ATLAS_THREAD_SAFE = const_cast<void*>(m_converter.convertUntyped (getUntyped (allowMissing)));
  if (!p) return 0;
  return m_info->size (p);
}
 

const DataModel_detail::DVLInfoBase*
SGDataVectorGetterTool::getInfo (const std::type_info& ti)
{
  // If we have info for this class directly, use that.
  DataModel_detail::DVLInfoBase* info =
    DataModel_detail::DVLInfoBase::find (ti);
  if (info) return info;
 
  // We gotta check the base classes.  Fail if we don't have
  // base info.
  const SG::BaseInfoBase* bib = SG::BaseInfoBase::find (ti);
  if (!bib) return 0;
 
  // Pick the most-derived class among the possible bases.
  std::vector<const std::type_info*> bases = bib->get_ti_bases();
  for (size_t i = 0; i < bases.size(); i++) {
    DataModel_detail::DVLInfoBase* this_info =
      DataModel_detail::DVLInfoBase::find (*bases[i]);
    if (this_info) {
      if (info) {
        bib = SG::BaseInfoBase::find (this_info->tinfo());
        if (bib && bib->is_base (info->tinfo()))
          info = this_info;
      }
      else
        info = this_info;
    }
  }
  return info;
}
 
 
} // namespace D3PD