TypeConverter.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration
*/
 
// $Id$
#include "D3PDMakerUtils/TypeConverter.h"
#include "AthenaKernel/BaseInfo.h"
#include "AthenaKernel/errorcheck.h"
#include "GaudiKernel/System.h"
#include <sstream>
 
 
namespace D3PD {
 
 
TypeConverter::TypeConverter()
  : m_srcTypeinfo (0),
    m_dstTypeinfo (0),
    m_srcBIB (0),
    m_dstBIB (0),
    m_strategy (INVALID)
{
}
 
 
StatusCode TypeConverter::init (const std::type_info& src_ti,
                                const std::type_info& dst_ti)
{
  if (tryInit (src_ti, dst_ti).isFailure()) {
    // Not a valid conversion.
    REPORT_MESSAGE (MSG::ERROR)
      << "Incompatible conversion: from " << srcName() << " to " << dstName();
    return StatusCode::FAILURE;
  }
  return StatusCode::SUCCESS;
}
 
 
StatusCode
TypeConverter::init (const std::type_info& src_ti,
                     const std::vector<const std::type_info*>& dst_tis,
                     size_t& which)
{
  size_t sz = dst_tis.size();
  for (which = 0; which < sz; which++) {
    if (tryInit (src_ti, *dst_tis[which]).isSuccess())
      return StatusCode::SUCCESS;
  }
 
  // Produce an error message listing the possible destination types.
  std::ostringstream dst_names;
  for (which = 0; which < sz; which++) {
    if (which > 0)
      dst_names << " ";
    dst_names << System::typeinfoName (*dst_tis[which]);
  }
  
  REPORT_MESSAGE (MSG::ERROR)
    << "Incompatible conversion: from " << srcName() << " to one of ["
    << dst_names.str() << "]";
  return StatusCode::FAILURE;
}
 
 
 
const void* TypeConverter::convertUntyped (const void* p) const
{
  switch (m_strategy) {
  case IDENTICAL:
    return p;
 
  case SRC_BASE: {
    // need non-const pointer
    void* nonconst_p ATLAS_THREAD_SAFE = const_cast<void*> (p);
    return m_srcBIB->cast (nonconst_p, *m_dstTypeinfo);
  }
  case DST_BASE: {
    // need non-const pointer
    void* nonconst_p ATLAS_THREAD_SAFE = const_cast<void*> (p);
    return m_dstBIB->castTo (nonconst_p, *m_srcTypeinfo);
  }
  default:
    std::abort();
  }
}
 
 
std::string TypeConverter::srcName() const
{
  if (!m_srcTypeinfo) return "";
  return System::typeinfoName (*m_srcTypeinfo);
}
 
 
std::string TypeConverter::dstName() const
{
  if (!m_dstTypeinfo) return "";
  return System::typeinfoName (*m_dstTypeinfo);
}
 
 
StatusCode TypeConverter::tryInit (const std::type_info& src_ti,
                                   const std::type_info& dst_ti)
{
  // Find the source BaseInfo.
  if (!m_srcBIB || m_srcBIB->typeinfo() != src_ti) {
    m_srcTypeinfo = &src_ti;
    m_srcBIB = SG::BaseInfoBase::find (src_ti);
  }
 
  // Find the destination BaseInfo.
  m_dstTypeinfo = &dst_ti;
  m_dstBIB = SG::BaseInfoBase::find (dst_ti);
 
  // Test for source and destination types identical.
  if (m_srcTypeinfo == m_dstTypeinfo) {
    m_strategy = IDENTICAL;
    return StatusCode::SUCCESS;
  }
 
  if (m_srcBIB && m_srcBIB->is_base (*m_dstTypeinfo)) {
    // Destination is a base of source --- use source BaseInfo.
    m_strategy = SRC_BASE;
    return StatusCode::SUCCESS;
  }
 
  if (m_dstBIB && m_dstBIB->is_base (*m_srcTypeinfo)) {
    // Source is a base of destination --- use destination BaseInfo.
    m_strategy = DST_BASE;
    return StatusCode::SUCCESS;
  }
 
  return StatusCode::FAILURE;
}
 
 
} // namespace D3PD