AthTPCnvSvc Class Reference

#include <AthTPCnvSvc.h>

Inheritance diagram for AthTPCnvSvc:

Collaboration diagram for AthTPCnvSvc:

Public Member Functions
	AthTPCnvSvc (const std::string &name, ISvcLocator *pSvcLocator)
	Constructor with parameters:
virtual	~AthTPCnvSvc () override
	Destructor:
virtual ITPCnvBase *	load_tpcnv (const std::string &cls) override
	load the T/P converter class named cls return NULL on failure.
virtual ITPCnvBase *	t2p_cnv (const std::string &transClassName, Athena::TPCnvType::Value type=Athena::TPCnvType::Athena) override
	return the T/P converter for a transient class (NULL if failure) ITPCnvSvc owns the ITPCnvBase pointer
virtual ITPCnvBase *	t2p_cnv (const CLID &transClid, Athena::TPCnvType::Value type=Athena::TPCnvType::Athena) override
	return the T/P converter for a transient class (NULL if failure) ITPCnvSvc owns the ITPCnvBase pointer
virtual ITPCnvBase *	p2t_cnv (const std::string &persClassName, Athena::TPCnvType::Value type=Athena::TPCnvType::Athena) override
	return the T/P converter for a persistent class (NULL if failure) ITPCnvSvc owns the ITPCnvBase pointer
virtual std::unique_ptr< ITPCnvBase >	t2p_cnv_unique (const std::string &transClassName) const override
	return the T/P converter for a transient class (NULL if failure) Ownership is returned to the caller.
virtual std::unique_ptr< ITPCnvBase >	t2p_cnv_unique (const CLID transClid) const override
	Return the T/P converter for a transient class.

Private Types
typedef std::vector< std::unique_ptr< ITPCnvBase > >	TpCnvs_t

Private Member Functions
	AthTPCnvSvc ()
	Default constructor:

Private Attributes
ServiceHandle< IClassIDSvc >	m_clidSvc
	handle to a IClassIDSvc to handle loading of types by CLID
TpCnvs_t	m_cnvs
	a registry of ITPCnvBase* instances
std::mutex	m_mutex

Detailed Description

Definition at line 30 of file AthTPCnvSvc.h.

Member Typedef Documentation

TpCnvs_t

typedef std::vector<std::unique_ptr<ITPCnvBase> > AthTPCnvSvc::TpCnvs_t

private

Definition at line 108 of file AthTPCnvSvc.h.

Constructor & Destructor Documentation

AthTPCnvSvc() [1/2]

AthTPCnvSvc::AthTPCnvSvc	(	const std::string &	name,
		ISvcLocator *	pSvcLocator )

Constructor with parameters:

Definition at line 35 of file AthTPCnvSvc.cxx.

                                                     : 
  base_class ( name, pSvcLocator ),
  m_clidSvc("ClassIDSvc/ClassIDSvc", name)
{
}

~AthTPCnvSvc()

AthTPCnvSvc::~AthTPCnvSvc ( )

overridevirtual

Destructor:

Definition at line 44 of file AthTPCnvSvc.cxx.

{
}

AthTPCnvSvc() [2/2]

AthTPCnvSvc::AthTPCnvSvc ( )

private

Default constructor:

Member Function Documentation

load_tpcnv()

ITPCnvBase * AthTPCnvSvc::load_tpcnv ( const std::string & cls )

overridevirtual

load the T/P converter class named cls return NULL on failure.

the converter is OWNED by the T/P converter service

Definition at line 54 of file AthTPCnvSvc.cxx.

{
  ITPCnvBase* cnv = ITPCnvBase::Factory::create (cls).release();
  if (cnv == nullptr) {
    ATH_MSG_INFO("could not load class [{}] via Reflex::PluginService", cls);
  }
  else {
    std::scoped_lock lock (m_mutex);
    m_cnvs.emplace_back (cnv);
  }
  return cnv;
}

p2t_cnv()

ITPCnvBase * AthTPCnvSvc::p2t_cnv ( const std::string & persClassName, Athena::TPCnvType::Value type = Athena::TPCnvType::Athena )

overridevirtual

return the T/P converter for a persistent class (NULL if failure) ITPCnvSvc owns the ITPCnvBase pointer

Definition at line 128 of file AthTPCnvSvc.cxx.

{
  ITPCnvBase* cnv = ITPCnvBase::Factory::create (prefix(type) + "_PERS_" + persClassName).release();
  if (cnv == nullptr && type != Athena::TPCnvType::Athena)
    return p2t_cnv (persClassName);
  if (cnv == nullptr) {
    ATH_MSG_WARNING("Could not load converter for persistent class [{}]",
                    persClassName);
  }
  else {
    std::scoped_lock lock (m_mutex);
    m_cnvs.emplace_back (cnv);
  }
  return cnv;
}

t2p_cnv() [1/2]

ITPCnvBase * AthTPCnvSvc::t2p_cnv ( const CLID & transClid, Athena::TPCnvType::Value type = Athena::TPCnvType::Athena )

overridevirtual

return the T/P converter for a transient class (NULL if failure) ITPCnvSvc owns the ITPCnvBase pointer

Definition at line 93 of file AthTPCnvSvc.cxx.

{
  std::string trans_type;
  if (!m_clidSvc->getTypeNameOfID(transClid, trans_type).isSuccess()) {
    ATH_MSG_INFO("could not get a type-name for clid [{}]", transClid);
    return nullptr;
  }
 
  ITPCnvBase* cnv = ITPCnvBase::Factory::create (prefix(type) + "_TRANS_" + trans_type).release();
  if (cnv == nullptr) {
    // try a typeinfo-name before bailing out...
    if (!m_clidSvc->getTypeInfoNameOfID(transClid, trans_type).isSuccess()) {
      ATH_MSG_INFO("could not get a typeinfo-name for clid [{}]", transClid);
      return nullptr;
    }
    cnv = ITPCnvBase::Factory::create (prefix(type) + "_TRANS_" + trans_type).release();
  }
  if (cnv == nullptr && type != Athena::TPCnvType::Athena)
    return t2p_cnv (transClid);
  if (cnv == nullptr) {
    ATH_MSG_WARNING("could not load converter for transient CLID [{}] ({})",
                    transClid, trans_type);
  }
  else {
    std::scoped_lock lock (m_mutex);
    m_cnvs.emplace_back (cnv);
  }
  return cnv;
}

t2p_cnv() [2/2]

ITPCnvBase * AthTPCnvSvc::t2p_cnv ( const std::string & transClassName, Athena::TPCnvType::Value type = Athena::TPCnvType::Athena )

overridevirtual

return the T/P converter for a transient class (NULL if failure) ITPCnvSvc owns the ITPCnvBase pointer

Definition at line 71 of file AthTPCnvSvc.cxx.

{
  ITPCnvBase* cnv = ITPCnvBase::Factory::create (prefix(type) + "_TRANS_" + transClassName).release();
  if (cnv == nullptr && type != Athena::TPCnvType::Athena)
    return t2p_cnv (transClassName);
  if (cnv == nullptr) {
    ATH_MSG_WARNING("Could not load converter for transient class [{}]",
                    transClassName);
  }
  else {
    std::scoped_lock lock (m_mutex);
    m_cnvs.emplace_back (cnv);
  }
  return cnv;
}

t2p_cnv_unique() [1/2]

std::unique_ptr< ITPCnvBase > AthTPCnvSvc::t2p_cnv_unique ( const CLID transClid ) const

overridevirtual

Return the T/P converter for a transient class.

Returns null on failure (with no warning printed). Ownership is returned to the caller.

Definition at line 161 of file AthTPCnvSvc.cxx.

{
  std::string trans_type;
  if (!m_clidSvc->getTypeNameOfID(transClid, trans_type).isSuccess()) {
    return nullptr;
  }
 
  std::unique_ptr<ITPCnvBase> cnv = ITPCnvBase::Factory::create (/*prefix(type) +*/ "_TRANS_" + trans_type);
  if (cnv == nullptr) {
    // try a typeinfo-name before bailing out...
    if (!m_clidSvc->getTypeInfoNameOfID(transClid, trans_type).isSuccess()) {
      return nullptr;
    }
    cnv = ITPCnvBase::Factory::create (/*prefix(type) +*/ "_TRANS_" + trans_type);
  }
  /*
  ** FIXME: support other types.
  if (cnv == nullptr && type != Athena::TPCnvType::Athena)
    return t2p_cnv (transClid);
  */
  return cnv;
}

t2p_cnv_unique() [2/2]

std::unique_ptr< ITPCnvBase > AthTPCnvSvc::t2p_cnv_unique ( const std::string & transClassName ) const

overridevirtual

return the T/P converter for a transient class (NULL if failure) Ownership is returned to the caller.

Return the T/P converter for a transient class.

Ownership is returned to the caller.

Definition at line 150 of file AthTPCnvSvc.cxx.

{
  return ITPCnvBase::Factory::create ("_TRANS_" + transClassName);
}

Member Data Documentation

m_clidSvc

ServiceHandle<IClassIDSvc> AthTPCnvSvc::m_clidSvc

private

handle to a IClassIDSvc to handle loading of types by CLID

Definition at line 106 of file AthTPCnvSvc.h.

m_cnvs

TpCnvs_t AthTPCnvSvc::m_cnvs

private

a registry of ITPCnvBase* instances

Definition at line 111 of file AthTPCnvSvc.h.

m_mutex

std::mutex AthTPCnvSvc::m_mutex

mutableprivate

Definition at line 114 of file AthTPCnvSvc.h.

---

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

• AthTPCnvSvc.h
• AthTPCnvSvc.cxx