DataBucket.icc

Go to the documentation of this file.

///////////////////////// -*- C++ -*- /////////////////////////////
 
/*
  Copyright (C) 2002-2025 CERN for the benefit of the ATLAS collaboration
*/
 
#include "AthenaKernel/IRegisterTransient.h"
#include "AthenaKernel/ClassID_traits.h"
#include "AthenaKernel/BaseInfo.h"
#include "AthenaKernel/tools/safe_clid.h"
#include "SGCore/ILockable.h"
#include "CxxUtils/AthUnlikelyMacros.h"
#include "CxxUtils/checker_macros.h"
 
#include <type_traits>
#include <concepts>
 
 
// Some helper functions.
namespace SG {
 
 
// If T is a DataObject, increment its reference count.
template <class T>
requires (!std::derived_from<T, DataObject>)
inline
void db_maybe_ref (T*)
{
}
inline
void db_maybe_ref (DataObject* ptr)
{
  ptr->addRef();
}
 
 
// Release the pointer PTR.
// If T is a DataObject, then decrement the reference count;
// otherwise, just delete it.
// The second parameter tells whether or not T is a DataObject.
template <class T>
requires (!std::derived_from<T, DataObject>)
inline
void db_free_ptr (T* ptr)
{
  delete ptr;
}
inline
void db_free_ptr (const DataObject* ptr)
{
  DataObject* ptr_nc ATLAS_THREAD_SAFE = const_cast<DataObject*>(ptr);
  ptr_nc->release();
}
 
} // namespace SG
 
 
///////////////////////////////////////////////////////////////////////////////
// CONSTRUCTORS
///////////////////////////////////////////////////////////////////////////////
template <typename T>
SG::DataBucket<T>::DataBucket(T* data)
  : m_ptr(data)
{
  // If T is a DataObject, increase the refcount.
  if (m_ptr)
    SG::db_maybe_ref (m_ptr);
}
 
template <typename T>
template <typename U>
SG::DataBucket<T>::DataBucket(std::unique_ptr<U> data)
    // Rely on our caller to retain constness.
    // cppcheck 2.12 puts the identifier used for the argument here in the
    // wrong scope potentially causing problems later, so uglify it.
  : DataBucket ([] (U* ptr_) { typedef typename std::remove_const<U>::type UNC;
                               UNC* tmp ATLAS_THREAD_SAFE = const_cast<UNC*> (ptr_);
                               return tmp; }
    (data.release()))
{
}
 
 
///////////////////////////////////////////////////////////////////////////////
// DATAOBJECT
///////////////////////////////////////////////////////////////////////////////
template <typename T>
const CLID& SG::DataBucket<T>::clID() const {return classID();}
 
template <typename T>
const CLID& SG::DataBucket<T>::classID() {
  typedef typename std::remove_pointer<T>::type BareTp;
  typedef typename std::remove_const<BareTp>::type BareT;
  return ClassID_traits<BareT>::ID();
}
 
 
/**
 * @brief Return the contents of the @c DataBucket,
 *        converted to type given by @a clid.  Note that only
 *        derived->base conversions are allowed here.
 * @param clid The class ID to which to convert.
 * @param irt To be called if we make a new instance.
 * @param isConst True if the object being converted is regarded as const.
 */
template <typename T>
void*
SG::DataBucket<T>::cast (CLID clid,
                         IRegisterTransient* irt /*= 0*/,
                         bool isConst /*=true*/)
{
  // First see if we're asking for class T.
  if (ATH_LIKELY (clid == classID())) {
    return m_ptr;
  }
 
  // Then try a conversion using static SG_BASES information.
  // This can all be unfolded at compile time, so is fast, but
  // doesn't take into account SG_ADD_BASES.
  void* ret = this->tryStaticConversion (clid);
  if (ret) {
    return ret;
  }
 
  // Then try using BaseInfo, in case of SG_ADD_BASES.
  ret = SG::BaseInfo<T>::cast (m_ptr, clid);
  if (ret || !isConst)
    return ret;
 
  // Is there a copy conversion available?
  const CopyConversionBase* cc = SG::BaseInfo<T>::baseinfo().copy_conversion (clid);
  if (cc) {
    vec_t::iterator end = m_cnvcopies.end();
    for (vec_t::iterator it = m_cnvcopies.begin(); it != end; ++it) {
      if (cc == it->first) {
        cc->convertUntyped (m_ptr, it->second);
        return it->second;
      }
    }
 
    void* newcont = cc->create();
    if (newcont) {
      cc->convertUntyped (m_ptr, newcont);
      m_cnvcopies.push_back (std::make_pair (cc, newcont));
      irt->registerTransient (newcont);
    }
    return newcont;
  }
 
  return 0;
}
 
 
/**
 * @brief Return the contents of the @c DataBucket,
 *        converted to type given by @a std::type_info.  Note that only
 *        derived->base conversions are allowed here.
 * @param tinfo The @a std::type_info of the type to which to convert.
 * @param irt To be called if we make a new instance.
 * @param isConst True if the object being converted is regarded as const.
 */
template <typename T>
void* SG::DataBucket<T>::cast (const std::type_info& tinfo,
                               IRegisterTransient* irt /*= 0*/,
                               bool isConst /*= true*/)
{
  // First see if we're asking for class T.
  if (ATH_LIKELY (tinfo == typeid(T))) {
    return m_ptr;
  }
 
  // Then try a conversion using static SG_BASES information.
  // This can all be unfolded at compile time, so is fast, but
  // doesn't take into account SG_ADD_BASES.
  void* ret = this->tryStaticConversion (tinfo);
  if (ret) {
    return ret;
  }
 
  // Then try using BaseInfo, in case of SG_ADD_BASES.
  ret = SG::BaseInfo<T>::cast (m_ptr, tinfo);
  if (ret || !isConst) {
    return ret;
  }
 
  // Is there a copy conversion available?
  const CopyConversionBase* cc = SG::BaseInfo<T>::baseinfo().copy_conversion (tinfo);
  if (cc) {
    vec_t::iterator end = m_cnvcopies.end();
    for (vec_t::iterator it = m_cnvcopies.begin(); it != end; ++it) {
      if (cc == it->first) {
        cc->convertUntyped (m_ptr, it->second);
        return it->second;
      }
    }
 
    void* newcont = cc->create();
    if (newcont) {
      cc->convertUntyped (m_ptr, newcont);
      m_cnvcopies.push_back (std::make_pair (cc, newcont));
      irt->registerTransient (newcont);
    }
    return newcont;
  }
 
  return 0;
}
 
 
/**
 * @brief Return the contents of the @c DataBucket,
 *        converted to type given by @a clid.  Note that only
 *        derived->base conversions are allowed here.
 * @param clid The class ID to which to convert.
 * @param tinfo The @a std::type_info of the type to which to convert.
 * @param irt To be called if we make a new instance.
 * @param isConst True if the object being converted is regarded as const.
 *
 * This allows the callee to choose whether to use clid or tinfo.
 * Here we use clid.
 */
template <typename T>
inline
void* SG::DataBucket<T>::cast (CLID clid,
                               const std::type_info& /*tinfo*/,
                               SG::IRegisterTransient* irt /*= 0*/,
                               bool isConst /*= true*/)
{
  // Don't use virtual dispatch for this call.
  return DataBucket::cast (clid, irt, isConst);
}
 
 
// The DataBucket destructor is put into an explicit namespace scope to get rid
// of a pesky warning from DPC++. Unfortunately Clang has an issue with the
// class name having a scope declaration on the destructor for some reason.
namespace SG {
 
template <typename T>
DataBucket<T>::~DataBucket()
{
  // Delete any copies.
  vec_t::iterator end = m_cnvcopies.end();
  for (vec_t::iterator it = m_cnvcopies.begin(); it != end; ++it) {
    it->first->destroy (it->second);
  }
 
  // Either delete m_ptr or decrement the refcount,
  // depending on whether or not T is a DataObject.
  if (m_ptr)
    SG::db_free_ptr(m_ptr);
}
 
} // namespace SG
 
 
namespace {
 
 
template <class T>
void call_lock (T* p, std::true_type)
{
  typedef typename std::remove_const<T>::type T_nc;
  ILockable* l = dynamic_cast<ILockable*> (const_cast<T_nc*>(p));
  if (l) l->lock();
}
 
 
template <class T>
void call_lock (T*, std::false_type)
{
}
 
 
} // anonymous namespace
 
 
/**
 * If the held object derives from @c ILockable, call @lock() on it.
 */
template <class T>
void SG::DataBucket<T>::lock()
{
  call_lock (m_ptr, typename std::is_polymorphic<T>::type());
}
 
 
/**
 * @brief Try a conversion using static SG_BASES information.
 * @param clid The class ID to which to convert.
 *
 * This can all be unfolded at compile time, so is fast, but
 * doesn't take into account SG_ADD_BASES.
 */
template <class T>
inline
void* SG::DataBucket<T>::tryStaticConversion (CLID clid)
{
  auto tryconv = [&] (auto* p, bool /*is_virtual*/)
  {
    using base_t = typename std::remove_pointer_t<decltype(p)>;
    if (clid == SG::safe_clid<base_t>()) {
      return static_cast<void*> (static_cast<base_t*> (m_ptr));
    }
    return static_cast<void*> (nullptr);
  };
  return SG::Bases<T>::bases::foreach_ (tryconv);
}
 
 
/**
 * @brief Try a conversion using static SG_BASES information.
 * @param tinfo The @a std::type_info of the type to which to convert.
 *
 * This can all be unfolded at compile time, so is fast, but
 * doesn't take into account SG_ADD_BASES.
 */
template <class T>
inline
void* SG::DataBucket<T>::tryStaticConversion (const std::type_info& tinfo)
{
  auto tryconv = [&] (auto* p, bool /*is_virtual*/)
  {
    using base_t = typename std::remove_pointer_t<decltype(p)>;
    if (tinfo == typeid(base_t)) {
      return static_cast<void*> (static_cast<base_t*> (m_ptr));
    }
    return static_cast<void*> (nullptr);
  };
  return SG::Bases<T>::bases::foreach_ (tryconv);
}