TConverterRegistry Class Reference

Registry for Root converters. More...

#include <TConverterRegistry.h>

Collaboration diagram for TConverterRegistry:

Public Member Functions
void	AddConverter (TVirtualConverter *conv)
	Add a new converter to the registry.
void	AddConverter (TVirtualConverter *conv, bool takeown)
	Add a new converter to the registry.
bool	AddConverter (const char *convname)
	Add a new converter to the registry.
TVirtualConverter *	GetConverter (const char *name, int checksum) const
	Look up a converter in the registry by name and checksum.
void	AddStreamerConverter (const std::string &from_type, const std::string &to_type, TMemberStreamer *streamer)
TMemberStreamer *	GetStreamerConverter (const std::string &from_type, const std::string &to_type) const

Static Public Member Functions
static TConverterRegistry *	Instance ()
	Return a pointer to the global registry instance.

Private Types
using	Payload = std::pair<TVirtualConverter*, bool>
using	CheckSumMap = std::map<UInt_t, Payload>
using	MapType = std::map<std::string, CheckSumMap, std::less<>>
using	lock_t = std::lock_guard<std::mutex>
using	SMapType = std::map<std::string, TMemberStreamer*>
	Streamer converters.

Private Member Functions
	~TConverterRegistry ()
	Destructor.

Private Attributes
MapType	fMap
	Map of registered converters.
std::mutex	fMutex
	Protect access to the map.
SMapType	fSMap

Detailed Description

Registry for Root converters.

Definition at line 40 of file TConverterRegistry.h.

Member Typedef Documentation

CheckSumMap

using TConverterRegistry::CheckSumMap = std::map<UInt_t, Payload>

private

Definition at line 112 of file TConverterRegistry.h.

lock_t

using TConverterRegistry::lock_t = std::lock_guard<std::mutex>

private

Definition at line 120 of file TConverterRegistry.h.

MapType

using TConverterRegistry::MapType = std::map<std::string, CheckSumMap, std::less<>>

private

Definition at line 113 of file TConverterRegistry.h.

Payload

using TConverterRegistry::Payload = std::pair<TVirtualConverter*, bool>

private

Definition at line 111 of file TConverterRegistry.h.

SMapType

using TConverterRegistry::SMapType = std::map<std::string, TMemberStreamer*>

private

Streamer converters.

Definition at line 124 of file TConverterRegistry.h.

Constructor & Destructor Documentation

~TConverterRegistry()

TConverterRegistry::~TConverterRegistry ( )

private

Destructor.

Destroy the registered converters.

Definition at line 156 of file TConverterRegistry.cxx.

{
  for (auto& [name, checksum_map] : fMap) {
    for (auto& [checksum, payload] : checksum_map) {
      if (payload.second)
        delete payload.first;
    }
  }
 
  for (auto& [key, streamer] : fSMap)
    delete streamer;
}

Member Function Documentation

AddConverter() [1/3]

bool TConverterRegistry::AddConverter

(

const char *

convname

)

Add a new converter to the registry.

Parameters

convname

The name of the converter class to add.

Returns

True if successful, false if the class couldn't be found.

This will also add a streamer for the class, to support conversion in non-split mode.

Definition at line 80 of file TConverterRegistry.cxx.

{
  TClass* cl = gROOT->GetClass (convname);
  if (!cl) return false;
  TClass* basecl = gROOT->GetClass ("TVirtualConverter");
  int offs = cl->GetBaseClassOffset (basecl);
  if (offs < 0) return false;
  char* cnv = reinterpret_cast<char*> (cl->New());
  AddConverter (reinterpret_cast<TVirtualConverter*> (cnv + offs), true);
  return true;
}

AddConverter() [2/3]

void TConverterRegistry::AddConverter

(

TVirtualConverter *

conv

)

Add a new converter to the registry.

Parameters

conv	The converter to add.

This will also add a streamer for the class, to support conversion in non-split mode.

The caller will retain ownership of the converter.

Definition at line 35 of file TConverterRegistry.cxx.

{
  AddConverter (conv, false);
}

AddConverter() [3/3]

void TConverterRegistry::AddConverter	(	TVirtualConverter *	conv,
		bool	takeown )

Add a new converter to the registry.

Parameters

conv	The converter to add.
takeown	If true, the registry takes ownership of the converter.

This will also add a streamer for the class, to support conversion in non-split mode.

Definition at line 49 of file TConverterRegistry.cxx.

{
  lock_t lock (fMutex);
  // Make sure the branch element is properly initialized.
  TConvertingBranchElement_init();
 
  // Look up the checksum->converter map.
  // (This will make an empty one if this is the first time we've
  // seen this name.)
  TClass* cls = conv->GetTransClass();
  CheckSumMap& cmap = fMap[cls->GetName()];
 
  // If this is the first converter for this transient class,
  // set up a streamer for non-split mode conversions.
  if (cmap.size() == 0)
    cls->AdoptStreamer (new TConverterStreamer (cmap, cls));
 
  // Add this converter to the map.
  cmap[conv->GetCheckSum()] = std::make_pair (conv, takeown);
}

AddStreamerConverter()

void TConverterRegistry::AddStreamerConverter	(	const std::string &	from_type,
		const std::string &	to_type,
		TMemberStreamer *	streamer )

Definition at line 113 of file TConverterRegistry.cxx.

{
  lock_t lock (fMutex);
  std::string key = from_type + "-" + to_type;
  auto i = fSMap.find (key);
  if (i != fSMap.end())
    delete i->second;
  fSMap[key] = streamer;
}

GetConverter()

TVirtualConverter * TConverterRegistry::GetConverter	(	const char *	name,
		int	checksum ) const

Look up a converter in the registry by name and checksum.

Parameters

name	The name of the (transient) class.
checksum	The checksum of the persistent class.

Returns

The converter, or nullptr if none.

Definition at line 99 of file TConverterRegistry.cxx.

{
  lock_t lock (fMutex);
  auto i = fMap.find (name);
  if (i != fMap.end()) {
    auto i2 = i->second.find (checksum);
    if (i2 != i->second.end())
      return i2->second.first;
  }
  return nullptr;
}

GetStreamerConverter()

TMemberStreamer * TConverterRegistry::GetStreamerConverter	(	const std::string &	from_type,
		const std::string &	to_type ) const

Definition at line 127 of file TConverterRegistry.cxx.

{
  lock_t lock (fMutex);
  std::string key = from_type + "-" + to_type;
  auto i = fSMap.find (key);
  if (i != fSMap.end())
    return i->second;
  return nullptr;
}

Instance()

TConverterRegistry * TConverterRegistry::Instance ( )

static

Return a pointer to the global registry instance.

Definition at line 142 of file TConverterRegistry.cxx.

{
  // Do it like this so that the object gets destroyed automatically
  // at program termination.
  static TConverterRegistry instance ATLAS_THREAD_SAFE;
  return &instance;
}

Member Data Documentation

fMap

MapType TConverterRegistry::fMap

private

Map of registered converters.

Definition at line 116 of file TConverterRegistry.h.

fMutex

std::mutex TConverterRegistry::fMutex

mutableprivate

Protect access to the map.

Definition at line 119 of file TConverterRegistry.h.

fSMap

SMapType TConverterRegistry::fSMap

private

Definition at line 125 of file TConverterRegistry.h.

---

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

• TConverterRegistry.h
• TConverterRegistry.cxx