TConverterRegistry.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2020 CERN for the benefit of the ATLAS collaboration
*/
#include "RootConversions/TConverterRegistry.h"
#include "RootConversions/TVirtualConverter.h"
#include "RootConversions/TConverterStreamer.h"
#include "CxxUtils/checker_macros.h"
#include "TMemberStreamer.h"
#include "TClass.h"
#include "TROOT.h"
 
 
void TConvertingBranchElement_init();
 
 
void TConverterRegistry::AddConverter (TVirtualConverter* conv)
{
  AddConverter (conv, false);
}
 
 
void TConverterRegistry::AddConverter (TVirtualConverter* conv,
                                       bool takeown)
{
  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);
}
 
 
bool TConverterRegistry::AddConverter (const char* convname)
{
  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;
}
 
 
TVirtualConverter* TConverterRegistry::GetConverter (const char* name,
                                                     int checksum) const
{
  lock_t lock (fMutex);
  MapType::const_iterator i = fMap.find (name);
  if (i != fMap.end()) {
    CheckSumMap::const_iterator i2 = i->second.find (checksum);
    if (i2 != i->second.end())
      return i2->second.first;
  }
  return 0;
}
 
 
void TConverterRegistry::AddStreamerConverter (const std::string& from_type,
                                               const std::string& to_type,
                                               TMemberStreamer* streamer)
{
  lock_t lock (fMutex);
  std::string key = from_type + "-" + to_type;
  SMapType::const_iterator i = fSMap.find (key);
  if (i != fSMap.end())
    delete i->second;
  fSMap[key] = streamer;
}
 
 
TMemberStreamer*
TConverterRegistry::GetStreamerConverter (const std::string& from_type,
                                          const std::string& to_type) const
{
  lock_t lock (fMutex);
  std::string key = from_type + "-" + to_type;
  SMapType::const_iterator i = fSMap.find (key);
  if (i != fSMap.end())
    return i->second;
  return 0;
}
 
 
TConverterRegistry* TConverterRegistry::Instance()
{
  // Do it like this so that the object gets destroyed automatically
  // at program termination.
  static TConverterRegistry instance ATLAS_THREAD_SAFE;
  return &instance;
}
 
 
TConverterRegistry::~TConverterRegistry()
{
  for (MapType::iterator i = fMap.begin(); i != fMap.end(); ++i) {
    for (CheckSumMap::iterator j = i->second.begin();
         j != i->second.end();
         ++j)
    {
      if (j->second.second)
        delete j->second.first;
    }
  }
 
  for (SMapType::iterator i = fSMap.begin(); i != fSMap.end(); ++i)
    delete i->second;
}