Control/AthenaKernel/AthenaKernel/BaseInfo.h

Go to the documentation of this file.

// This file's extension implies that it's C, but it's really -*- C++ -*-.
/*
  Copyright (C) 2002-2026 CERN for the benefit of the ATLAS collaboration
*/
 
#ifndef ATHENAKERNEL_BASEINFO_H
#define ATHENAKERNEL_BASEINFO_H
 
#include "CxxUtils/checker_macros.h"
#include "AthenaKernel/Bases.h"
#include "GaudiKernel/ClassID.h"
#include <vector>
#include <typeinfo>
#include <type_traits>
 
 
//===========================================================================
// Macros used to declare base class information.
//

#define SG_VIRTUAL(T) Virtual<T>
 

#define SG_BASES(D, ...) \
  namespace SG        {          \
    template<> struct Bases<D >{ \
      using bases = BaseList<__VA_ARGS__>; \
    };                           \
    template struct RegisterBaseInit<D >; \
    template struct BaseInit<D >; \
} struct sg_dummy // to swallow semicolon
 

#define SG_BASE(D, B) SG_BASES(D, B)
 

#define SG_BASES1(D, B) SG_BASES(D, B)
 

#define SG_BASES2(D, B1, B2) SG_BASES(D, B1, B2)
 

#define SG_BASES3(D, B1, B2, B3) SG_BASES(D, B1, B2, B3)
 

#define SG_BASES4(D, B1, B2, B3, B4) SG_BASES(D, B1, B2, B3, B4)
 

#define SG_ADD_BASE(D, B) \
  namespace SG        {          \
    template struct AddBaseInit<D, B >;            \
} struct sg_dummy // to swallow semicolon
 

#define SG_ADD_COPY_CONVERSION(D, C) \
  namespace SG        {          \
    template struct AddCopyConversionInit<D, C >;            \
} struct sg_dummy // to swallow semicolon
 
 
 
namespace SG {
 

template <class T>
struct BaseType;
 
 
// Forward declaration.
template <class T>
class BaseInfoImpl;
 
 
struct BaseInfoBaseImpl;
 
 
//===========================================================================
// Copy conversion declarations.
//
 

class CopyConversionBase
{
public:
  virtual ~CopyConversionBase() {}

  virtual void* create() const = 0;

  virtual void destroy (void* p) const = 0;

  virtual void convertUntyped (const void* src, void* dst) const = 0;
};
 

template <class SRC, class DST>
class CopyConversion
  : public CopyConversionBase
{
public:
  typedef DST target_type;

  virtual void* create() const override { return new DST; }

  virtual void destroy (void* p) const override { delete reinterpret_cast<DST*>(p); }

  virtual void convertUntyped (const void* src, void* dst) const override
  {
    convert (*reinterpret_cast<const SRC*>(src),
             *reinterpret_cast<DST*>(dst));
  }

  virtual void convert (const SRC& src, DST& dst) const = 0;
};
 
 
//===========================================================================
// Base class declaration.
// This factors out the part of the implementation that doesn't
// depend on the template parameter @a T.
//
 
 
template <class D, class B>
struct RegisterAddBaseInit;
template <class D, class B>
struct RegisterAddCopyConversionInit;
 

class BaseInfoBase
{
public:
  template <class D, class B>
  friend struct RegisterAddBaseInit;
  template <class D, class B>
  friend struct RegisterAddCopyConversionInit;
 
 
  using destroy_fn = void (void*);
 

  CLID clid() const;
 

  const std::type_info& typeinfo() const;
  

  void* cast (void* p, CLID clid) const;

  void* cast (void* p, const std::type_info& tinfo) const;
 

  void* castTo (void* p, CLID clid) const;

  void* castTo (void* p, const std::type_info& tinfo) const;
 

  typedef void* castfn_t (void* p);
 

  castfn_t* castfn (CLID clid) const;
 

  castfn_t* castfn (const std::type_info& tinfo) const;

  castfn_t* castfnTo (CLID clid) const;
 

  castfn_t* castfnTo (const std::type_info& tinfo) const;
 

  const std::vector<CLID>& get_bases () const;

  std::vector<const std::type_info*> get_ti_bases () const;

  bool is_base (CLID clid) const;

  bool is_base (const std::type_info& tinfo) const;
 

  bool is_virtual (CLID clid) const;

  bool is_virtual (const std::type_info& tinfo) const;
 

  const CopyConversionBase* copy_conversion (const std::type_info& tinfo) const;
 

  const CopyConversionBase* copy_conversion (CLID clid) const;
 

  void destroy (void* p) const;
 

  void add_copy_conversion (const std::type_info& tinfo,
                            const CopyConversionBase* cnv);
 

  std::vector<CLID> get_copy_conversions() const;
 
 
#ifndef __REFLEX__
  void add_info (const std::type_info& tinfo,
                 castfn_t* converter,
                 castfn_t* converterTo,
                 bool is_virtual);
#endif
 

  static const BaseInfoBase* find (CLID clid);
 

  static const BaseInfoBase* find (const std::type_info& tinfo);
 

  typedef void init_func_t (BaseInfoBase* bib);
 
 
#ifndef __REFLEX__
  static void addInit (const std::type_info* tinfo,
                       init_func_t* init_func);
#endif
 

  void maybeInit();
 
 
protected:
  BaseInfoBase (const std::type_info& tinfo, destroy_fn* destroy);
 

  ~BaseInfoBase();
 
 
private:
  static BaseInfoBase* find1 (const std::type_info& tinfo);
 

  BaseInfoBaseImpl* m_impl;
 
  BaseInfoBase (const BaseInfoBase&);
  BaseInfoBase& operator= (const BaseInfoBase&);
};
 
 
//===========================================================================
// The templated @c BaseInfo class.
//

template <class T>
class BaseInfo
{
public:
  template <class D, class B>
  friend struct RegisterAddCopyConversionInit;
  template <class D, class B>
  friend struct RegisterAddBaseInit;
 

  static void* cast (T* p, CLID clid);

  static void* cast (T* p, const std::type_info& tinfo);
 

  static T* castTo (void* p, CLID clid);

  static T* castTo (void* p, const std::type_info& tinfo);
 

  static BaseInfoBase::castfn_t* castfn (CLID clid);
 

  static BaseInfoBase::castfn_t* castfn (const std::type_info& tinfo);
 

  static BaseInfoBase::castfn_t* castfnTo (CLID clid);
 

  static BaseInfoBase::castfn_t* castfnTo (const std::type_info& tinfo);
 

  static const std::vector<CLID>& get_bases ();
 

  static std::vector<const std::type_info*> get_ti_bases ();
 

  static bool is_base (CLID clid);

  static bool is_base (const std::type_info& tinfo);
 

  static bool is_virtual (CLID clid);

  static bool is_virtual (const std::type_info& tinfo);
 

  static void destroy (T* p);
 

  static const BaseInfoBase& baseinfo ();
 
 
  static void maybeInit ();
 
 
private:
  static BaseInfoImpl<T>& instance();
 
  static BaseInfoImpl<T> s_instance ATLAS_THREAD_SAFE;
};
 
 
} // namespace SG
 
 
#include "AthenaKernel/BaseInfo.icc"
 
 
#endif // not ATHENAKERNEL_BASEINFO_H