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-2023 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 { return new DST; }
 
  virtual void destroy (void* p) const { delete reinterpret_cast<DST*>(p); }
 
  virtual void convertUntyped (const void* src, void* dst) const
  {
    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;
 
 
  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);
 
 
  // gcc 4.3 complains about the code genreflex generates for these.
  // They're not useful from python anyway, so just suppress them.
#ifndef __REFLEX__
 
  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;
#endif
 
 
  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 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);
 
 
  ~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 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