SG::BaseInfoBase Class Reference

The non-template portion of the BaseInfo implementation. More...

#include <BaseInfo.h>

Collaboration diagram for SG::BaseInfoBase:

Public Types
typedef void *	castfn_t(void *p)
	Type of a pointer conversion function. More...
typedef void	init_func_t(BaseInfoBase *bib)
	Type for an initialization function. More...

Public Member Functions
CLID	clid () const
	Return the CLID for this class. More...
const std::type_info &	typeinfo () const
	Return the std::type_info for this class. More...
void *	cast (void *p, CLID clid) const
	Cast to a base pointer. More...
void *	cast (void *p, const std::type_info &tinfo) const
	Cast to a base pointer. More...
void *	castTo (void *p, CLID clid) const
	Cast to a derived pointer. More...
void *	castTo (void *p, const std::type_info &tinfo) const
	Cast to a derived pointer. More...
castfn_t *	castfn (CLID clid) const
	Return a function for casting to a base pointer. More...
castfn_t *	castfn (const std::type_info &tinfo) const
	Return a function for casting to a base pointer. More...
castfn_t *	castfnTo (CLID clid) const
	Return a function for casting to a derived pointer. More...
castfn_t *	castfnTo (const std::type_info &tinfo) const
	Return a function for casting to a derived pointer. More...
const std::vector< CLID > &	get_bases () const
	Return the class IDs of all known bases of T (that have class IDs). More...
std::vector< const std::type_info * >	get_ti_bases () const
	Return the type_info's of all known bases of T. More...
bool	is_base (CLID clid) const
	Return true if clid is the ID of a class that is known to be a base of T. More...
bool	is_base (const std::type_info &tinfo) const
	Return true if tinfo is the type_info of a class that is known to be a base of T. More...
bool	is_virtual (CLID clid) const
	Return true if clid is the ID of a class that is known to be a virtual base of T. More...
bool	is_virtual (const std::type_info &tinfo) const
	Return true if tinfo is the std::type_info of a class that is known to be a virtual base of T. More...
const CopyConversionBase *	copy_conversion (const std::type_info &tinfo) const
	Search for a copy conversion to tinfo. More...
const CopyConversionBase *	copy_conversion (CLID clid) const
	Search for a copy conversion to clid. More...
void	add_copy_conversion (const std::type_info &tinfo, const CopyConversionBase *cnv)
	Add a new copy conversion. More...
std::vector< CLID >	get_copy_conversions () const
	Return known copy conversions. More...
void	add_info (const std::type_info &tinfo, castfn_t *converter, castfn_t *converterTo, bool is_virtual)
	Add information about one base class. More...
void	maybeInit ()
	Run initializations for this class, if needed. More...

Static Public Member Functions
static const BaseInfoBase *	find (CLID clid)
	Find the BaseInfoBase instance for clid. More...
static const BaseInfoBase *	find (const std::type_info &tinfo)
	Find the BaseInfoBase instance for tinfo. More...
static void	addInit (const std::type_info *tinfo, init_func_t *init_func)
	Register an initialization function. More...

Protected Member Functions
	BaseInfoBase (const std::type_info &tinfo)
	Constructor. More...
	~BaseInfoBase ()
	Destructor. More...

Private Member Functions
	BaseInfoBase (const BaseInfoBase &)
BaseInfoBase &	operator= (const BaseInfoBase &)

Static Private Member Functions
static BaseInfoBase *	find1 (const std::type_info &tinfo)
	Helper for find. More...

Private Attributes
BaseInfoBaseImpl *	m_impl
	Pointer to internal state. More...

Friends
template<class D , class B >
struct	RegisterAddBaseInit
template<class D , class B >
struct	RegisterAddCopyConversionInit

Detailed Description

The non-template portion of the BaseInfo implementation.

Definition at line 450 of file Control/AthenaKernel/AthenaKernel/BaseInfo.h.

Member Typedef Documentation

castfn_t

typedef void* SG::BaseInfoBase::castfn_t(void *p)

Type of a pointer conversion function.

Definition at line 516 of file Control/AthenaKernel/AthenaKernel/BaseInfo.h.

init_func_t

typedef void SG::BaseInfoBase::init_func_t(BaseInfoBase *bib)

Type for an initialization function.

Definition at line 688 of file Control/AthenaKernel/AthenaKernel/BaseInfo.h.

Constructor & Destructor Documentation

BaseInfoBase() [1/2]

SG::BaseInfoBase::BaseInfoBase ( const std::type_info &  tinfo )

protected

Constructor.

Parameters

tinfo

The std::type_info for this class.

Definition at line 529 of file BaseInfo.cxx.

  : m_impl (new BaseInfoBaseImpl)
{
  m_impl->m_clid = CLIDRegistry::typeinfoToCLID (tinfo);
  m_impl->m_typeinfo = &tinfo;
  m_impl->m_needs_init = true;
 
  BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
  if (!BaseInfoBaseImpl::s_bi_by_ti)
    BaseInfoBaseImpl::s_bi_by_ti   = new BaseInfoBaseImpl::bi_by_ti_map_type;
  if (!BaseInfoBaseImpl::s_ti_by_name)
    BaseInfoBaseImpl::s_ti_by_name   = new BaseInfoBaseImpl::ti_by_name_map_type;
 
  // Register this instance in the static maps.
  (*BaseInfoBaseImpl::s_bi_by_ti)[&tinfo] = this;
  (*BaseInfoBaseImpl::s_ti_by_name)[tinfo.name()] = &tinfo;
}

~BaseInfoBase()

SG::BaseInfoBase::~BaseInfoBase ( )

protected

Destructor.

Definition at line 551 of file BaseInfo.cxx.

{
  for (BaseInfoBaseImpl::ti_copyconversion_type::iterator it =
         m_impl->m_ti_copyconversion_map.begin();
       it != m_impl->m_ti_copyconversion_map.end();
       ++it)
  {
    delete it->second;
  }
  delete m_impl;
}

BaseInfoBase() [2/2]

SG::BaseInfoBase::BaseInfoBase ( const BaseInfoBase &  )

private

Member Function Documentation

add_copy_conversion()

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

Add a new copy conversion.

Parameters

tinfo	The std::type_info of the target class.
cnv	A CopyConversionBase instance describing the conversion.

The BaseInfoBase takes ownership of the cnv object.

Definition at line 440 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  m_impl->m_ti_copyconversion_map.emplace_back (&tinfo, cnv);
}

add_info()

void SG::BaseInfoBase::add_info	(	const std::type_info &	tinfo,
		castfn_t *	converter,
		castfn_t *	converterTo,
		bool	is_virtual
	)

Add information about one base class.

Parameters

tinfo	The std::type_info of the base.
converter	Converter function. This should be able to convert a T* to a pointer to this base.
converterTo	Converter function. This should be able to convert a pointer to this base to a T*.
is_virtual	True if the derivation from this base to T is via virtual derivation.

Definition at line 479 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t slock (BaseInfoBaseImpl::s_mutex);
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  {
    const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
    if (!i) {
      m_impl->m_timap.emplace_back (&tinfo,
                                    BaseInfoBaseImpl::info (converter, converterTo, is_virtual));
    }
  }
 
  auto i = BaseInfoBaseImpl::s_bi_by_ti->find (&tinfo);
  if (i != BaseInfoBaseImpl::s_bi_by_ti->end()) {
    BaseInfoBaseImpl& impl = *i->second->m_impl;
    if (impl.m_clid == CLID_NULL)
      impl.m_clid = CLIDRegistry::typeinfoToCLID (tinfo);
  }
}

addInit()

void SG::BaseInfoBase::addInit ( const std::type_info *  tinfo, init_func_t *  init_func  )

static

Register an initialization function.

Parameters

tinfo	The std::type_info for the class being registered.
init_func	Function to initialize BaseInfo for the class.

Definition at line 673 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
  if (!BaseInfoBaseImpl::s_init_list)
    BaseInfoBaseImpl::s_init_list =
      new BaseInfoBaseImpl::init_list_t;
  BaseInfoBaseImpl::s_init_list->insert (std::make_pair (tinfo, init_func));
 
  if (BaseInfoBaseImpl::s_bi_by_ti) {
    auto i = BaseInfoBaseImpl::s_bi_by_ti->find (tinfo);
    if (i != BaseInfoBaseImpl::s_bi_by_ti->end()) {
      BaseInfoBaseImpl::lock_t lock (i->second->m_impl->m_mutex);
      BaseInfoBaseImpl& impl = *i->second->m_impl;
      impl.m_needs_init = true;
      if (impl.m_clid == CLID_NULL)
        impl.m_clid = CLIDRegistry::typeinfoToCLID (*tinfo);
    }
  }
}

cast() [1/2]

void * SG::BaseInfoBase::cast	(	void *	p,
		CLID	clid
	)		const

Cast to a base pointer.

Parameters

p	The pointer to cast (a T* cast to a void*).
clid	ID of the class to which to cast.

Returns

The pointer cast to the requested type, returned as a void*. clid must be known to be a base of T; otherwise, 0 will be returned.

Definition at line 166 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->cast (p, *ti);
  return 0;
}

cast() [2/2]

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

Cast to a base pointer.

Parameters

p	The pointer to cast (a T* cast to a void*).
clid	type_info of the class to which to cast.

Returns

The pointer cast to the requested type, returned as a void*. tinfo must be known to be a base of T; otherwise, 0 will be returned.

Definition at line 183 of file BaseInfo.cxx.

{
  if (BaseInfoBase::castfn_t* converter = castfn (tinfo)) {
    return converter (p);
  }
  return nullptr;
}

castfn() [1/2]

BaseInfoBase::castfn_t * SG::BaseInfoBase::castfn

(

CLID

clid

)

const

Return a function for casting to a base pointer.

Parameters

clid	ID of the class to which to cast.

Returns

A function to convert a pointer to a T to a pointer to the type identified by clid. clid must be known to be a base of T; otherwise, 0 will be returned.

Definition at line 236 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->castfn (*ti);
  return 0;
}

castfn() [2/2]

BaseInfoBase::castfn_t * SG::BaseInfoBase::castfn

(

const std::type_info &

tinfo

)

const

Return a function for casting to a base pointer.

Parameters

clid	type_info of the class to which to cast.

Returns

A function to convert a pointer to a T to a pointer to the type identified by tinfo. tinfo must be known to be a base of T; otherwise, 0 will be returned.

Definition at line 254 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  if (i)
    return i->m_converter;
  return nullptr;
}

castfnTo() [1/2]

BaseInfoBase::castfn_t * SG::BaseInfoBase::castfnTo

(

CLID

clid

)

const

Return a function for casting to a derived pointer.

Parameters

clid	ID of the class B from which to cast.

Returns

A function to convert a pointer to a B to a pointer to a T. B must be known to be a base of T; otherwise, 0 will be returned. 0 will also be returned if the dynamic_cast fails.

Definition at line 272 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->castfnTo (*ti);
  return 0;
}

castfnTo() [2/2]

BaseInfoBase::castfn_t * SG::BaseInfoBase::castfnTo

(

const std::type_info &

tinfo

)

const

Return a function for casting to a derived pointer.

Parameters

clid	type_info of the class B from which to cast.

Returns

A function to convert a pointer to a B to a pointer to a T. B must be known to be a base of T; otherwise, 0 will be returned. 0 will also be returned if the dynamic_cast fails.

Definition at line 290 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  if (i)
    return i->m_converterTo;
  return nullptr;
}

castTo() [1/2]

void * SG::BaseInfoBase::castTo	(	void *	p,
		CLID	clid
	)		const

Cast to a derived pointer.

Parameters

p	The pointer to cast (a B* cast to a void*).
clid	ID of the class B from which to cast.

Returns

The pointer cast to the requested type, returned as a void*. clid must be known to be a base of T; otherwise, 0 will be returned. 0 will also be returned if the dynamic_cast fails.

Definition at line 201 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->castTo (p, *ti);
  return 0;
}

castTo() [2/2]

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

Cast to a derived pointer.

Parameters

p	The pointer to cast (a B* cast to a void*).
clid	type_info of the class B from which to cast.

Returns

The pointer cast to the requested type, returned as a void*. tinfo must be known to be a base of T; otherwise, 0 will be returned. 0 will also be returned if the dynamic_cast fails.

Definition at line 219 of file BaseInfo.cxx.

{
  if (BaseInfoBase::castfn_t* converterTo = castfnTo (tinfo)) {
    return converterTo (p);
  }
  return nullptr;
}

clid()

CLID SG::BaseInfoBase::clid

(

)

const

Return the CLID for this class.

Definition at line 141 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  return m_impl->m_clid;
}

copy_conversion() [1/2]

const CopyConversionBase * SG::BaseInfoBase::copy_conversion

(

CLID

clid

)

const

Search for a copy conversion to clid.

Parameters

clid	The class to which we want to convert.

Returns the conversion instance or 0.

Definition at line 423 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->copy_conversion (*ti);
  return 0;
}

copy_conversion() [2/2]

const CopyConversionBase * SG::BaseInfoBase::copy_conversion

(

const std::type_info &

tinfo

)

const

Search for a copy conversion to tinfo.

Parameters

tinfo

The class to which we want to convert.

Returns the conversion instance or 0.

Definition at line 405 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  for (const auto& p : m_impl->m_ti_copyconversion_map) {
    if (p.first == &tinfo)
      return p.second;
  }
  return 0;
}

find() [1/2]

const BaseInfoBase * SG::BaseInfoBase::find ( CLID  clid )

static

Find the BaseInfoBase instance for clid.

Parameters

clid	The class ID of the class for which we want information.

Returns 0 if no BaseInfoBase instance is available.

Definition at line 570 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return BaseInfoBase::find (*ti);
  return 0;
}

find() [2/2]

const BaseInfoBase * SG::BaseInfoBase::find ( const std::type_info &  tinfo )

static

Find the BaseInfoBase instance for tinfo.

Parameters

tinfo

The std::type_info of the class for which we want information.

Returns 0 if no BaseInfoBase instance is available.

Definition at line 633 of file BaseInfo.cxx.

{
  BaseInfoBase* bib = find1 (tinfo);
 
  // If we didn't find it, try looking up by name.
  // This to deal with the issue of sometimes getting duplicate
  // @c std::type_info instances.
  if (!bib) {
    const std::type_info* tinfo2 = nullptr;
    {
      BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
      if (BaseInfoBaseImpl::s_ti_by_name) {
        BaseInfoBaseImpl::ti_by_name_map_type::iterator i = 
          BaseInfoBaseImpl::s_ti_by_name->find (tinfo.name());
        if (i != BaseInfoBaseImpl::s_ti_by_name->end() && i->second != &tinfo) {
          tinfo2 = i->second;
        }
      }
    }
    if (tinfo2) {
      bib = find1 (*tinfo2);
    }
  }
 
  if (bib) {
    BaseInfoBaseImpl& impl = *bib->m_impl;
    BaseInfoBaseImpl::lock_t lock (impl.m_mutex);
    if (impl.m_clid == CLID_NULL)
      impl.m_clid = CLIDRegistry::typeinfoToCLID (*impl.m_typeinfo);
  }
 
  return bib;
}

find1()

BaseInfoBase * SG::BaseInfoBase::find1 ( const std::type_info &  tinfo )

staticprivate

Helper for find.

Parameters

tinfo

The std::type_info of the class for which we want information.

Returns 0 if no BaseInfoBase instance is available.

Definition at line 586 of file BaseInfo.cxx.

{
  BaseInfoBase* bib = nullptr;
  {
    BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
    if (!BaseInfoBaseImpl::s_bi_by_ti) return 0;
    BaseInfoBaseImpl::bi_by_ti_map_type::iterator i = 
      BaseInfoBaseImpl::s_bi_by_ti->find (&tinfo);
    if (i != BaseInfoBaseImpl::s_bi_by_ti->end()) {
      bib = i->second;
      BaseInfoBaseImpl::lock_t lock (bib->m_impl->m_mutex);
      if (!bib->m_impl->m_needs_init)
        return bib;
      bib->m_impl->m_needs_init = false;
    }
  }
 
  // Try the initlist.
  while (true) {
    BaseInfoBase::init_func_t* init = nullptr;
    {
      BaseInfoBaseImpl::lock_t lock (BaseInfoBaseImpl::s_mutex);
      if (!BaseInfoBaseImpl::s_init_list) break;
      BaseInfoBaseImpl::bi_by_ti_map_type::iterator i = 
        BaseInfoBaseImpl::s_bi_by_ti->find (&tinfo);
      if (i != BaseInfoBaseImpl::s_bi_by_ti->end())
        bib = i->second;
      BaseInfoBaseImpl::init_list_t::iterator it = 
        BaseInfoBaseImpl::s_init_list->find (&tinfo);
      if (it == BaseInfoBaseImpl::s_init_list->end()) break;
      init = it->second;
      BaseInfoBaseImpl::s_init_list->erase (it);
    }
    init (bib);
  }
 
  return bib;
}

get_bases()

const std::vector< CLID > & SG::BaseInfoBase::get_bases

(

)

const

Return the class IDs of all known bases of T (that have class IDs).

The list will include T itself.

Definition at line 304 of file BaseInfo.cxx.

{
  if (!m_impl->m_bases.isValid()) {
    BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
    const BaseInfoBaseImpl::ti_map_type& map = m_impl->m_timap;
    std::vector<CLID> v;
    v.reserve (map.size());
    for (const auto& p : map) {
      CLID clid = CLIDRegistry::typeinfoToCLID (*p.first);
      if (clid != CLID_NULL)
        v.push_back (clid);
    }
    m_impl->m_bases.set (std::move (v));
  }
  return *m_impl->m_bases.ptr();
}

get_copy_conversions()

std::vector< CLID > SG::BaseInfoBase::get_copy_conversions

(

)

const

Return known copy conversions.

Returns the CLIDs of all target classes that have been registered with this one for copy conversion.

Definition at line 455 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  std::vector<CLID> out;
  out.reserve (m_impl->m_ti_copyconversion_map.size());
  for (const auto& i : m_impl->m_ti_copyconversion_map) {
    CLID clid = CLIDRegistry::typeinfoToCLID (*i.first);
    if (clid != CLID_NULL)
      out.push_back (clid);
  }
  return out;
}

get_ti_bases()

std::vector< const std::type_info * > SG::BaseInfoBase::get_ti_bases

(

)

const

Return the type_info's of all known bases of T.

The list will include T itself.

Definition at line 326 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::ti_map_type& map = m_impl->m_timap;
  std::vector<const std::type_info*> v;
  v.reserve (map.size());
  for (const auto& i : map)
    v.push_back (i.first);
  return v;
}

is_base() [1/2]

bool SG::BaseInfoBase::is_base

(

CLID

clid

)

const

Return true if clid is the ID of a class that is known to be a base of T.

T is considered to be its own base for this purpose.

Parameters

clid	The ID of the class to test.

Definition at line 344 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->is_base (*ti);
  return 0;
}

is_base() [2/2]

bool SG::BaseInfoBase::is_base

(

const std::type_info &

tinfo

)

const

Return true if tinfo is the type_info of a class that is known to be a base of T.

T is considered to be its own base for this purpose.

Parameters

clid	The ID of the class to test.

Definition at line 359 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  return i != 0;
}

is_virtual() [1/2]

bool SG::BaseInfoBase::is_virtual

(

CLID

clid

)

const

Return true if clid is the ID of a class that is known to be a virtual base of T.

(This will always be false for T itself.)

Parameters

clid	The ID of the class to test.

Definition at line 373 of file BaseInfo.cxx.

{
  const std::type_info* ti = CLIDRegistry::CLIDToTypeinfo (clid);
  if (ti)
    return this->is_virtual (*ti);
  return false;
}

is_virtual() [2/2]

bool SG::BaseInfoBase::is_virtual

(

const std::type_info &

tinfo

)

const

Return true if tinfo is the std::type_info of a class that is known to be a virtual base of T.

(This will always be false for T itself.)

Parameters

tinfo

The std::type_info of the class to test.

Definition at line 388 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  const BaseInfoBaseImpl::info* i = m_impl->findInfo (tinfo);
  if (i)
    return i->m_is_virtual;
  return false;
}

maybeInit()

void SG::BaseInfoBase::maybeInit

(

)

Run initializations for this class, if needed.

Definition at line 698 of file BaseInfo.cxx.

{
  // This may be null during initialization, if we're initializing a
  // BaseInfo<T>::s_instance instance which references another type
  // for which the s_instance constructor has not yet been run.
  if (!m_impl) return;
 
  bool needs_init = false;
  const std::type_info* ti = nullptr;
  {
    BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
    needs_init = m_impl->m_needs_init;
    ti = m_impl->m_typeinfo;
  }
  
  if (needs_init)
    find (*ti);
}

operator=()

BaseInfoBase& SG::BaseInfoBase::operator= ( const BaseInfoBase &  )

private

typeinfo()

const std::type_info & SG::BaseInfoBase::typeinfo

(

)

const

Return the std::type_info for this class.

Definition at line 151 of file BaseInfo.cxx.

{
  BaseInfoBaseImpl::lock_t lock (m_impl->m_mutex);
  return *m_impl->m_typeinfo;
}

Friends And Related Function Documentation

RegisterAddBaseInit

template<class D , class B >

friend struct RegisterAddBaseInit

friend

Definition at line 454 of file Control/AthenaKernel/AthenaKernel/BaseInfo.h.

RegisterAddCopyConversionInit

template<class D , class B >

friend struct RegisterAddCopyConversionInit

friend

Definition at line 456 of file Control/AthenaKernel/AthenaKernel/BaseInfo.h.

Member Data Documentation

m_impl

BaseInfoBaseImpl* SG::BaseInfoBase::m_impl

private

Pointer to internal state.

Definition at line 734 of file Control/AthenaKernel/AthenaKernel/BaseInfo.h.

---

The documentation for this class was generated from the following files:

• Control/AthenaKernel/AthenaKernel/BaseInfo.h
• BaseInfo.cxx