TConvertingStreamerInfo.cxx

Go to the documentation of this file.

/*
  Copyright (C) 2002-2021 CERN for the benefit of the ATLAS collaboration
*/
#include "RootConversions/TConvertingStreamerInfo.h"
#include "RootConversions/TConverterRegistry.h"
#include "RootUtils/WithRootErrorHandler.h"
#include "CxxUtils/checker_macros.h"
#include "TStreamerElement.h"
#include "TMemberStreamer.h"
#include "TROOT.h"
#include "TClass.h"
#include "TError.h"
#include <string>
#include <vector>
#include <cassert>
#include <memory>
#include <mutex>
 
 
TConvertingStreamerInfo::TConvertingStreamerInfo()
{
}
 
 
void TConvertingStreamerInfo::Initialize()
{
  static bool initialized ATLAS_THREAD_SAFE = false;
  static std::mutex initmutex;
  std::lock_guard<std::mutex> lock (initmutex);
 
  if (initialized)
    return;
  initialized = true;
 
  TClass* cl = gROOT->GetClass ("TStreamerInfo", true);
 
  // Make sure the I/O plugin has been loaded.
  // This will change the new hook for the TStreamerInfo class,
  // so we need to make sure that this is done before we change
  // it ourselves.
  TVirtualStreamerInfo::Factory ();
  if (!cl) {
    ::Error ("TConvertingStreamerInfo",
             "Can't find TClass for TStreamerInfo");
    return;
  }
 
  // Change the @c New() method for @c TStreamerInfo to make
  // an instance of this class instead.
  cl->SetNew (TConvertingStreamerInfo::new_TConvertingStreamerInfo);
}
 
 
void* TConvertingStreamerInfo::new_TConvertingStreamerInfo (void *p)
{
  if (p)
    return new (p) TConvertingStreamerInfo;
  return new TConvertingStreamerInfo;
}
 
 
void TConvertingStreamerInfo::BuildOld()
{
  using namespace std::placeholders;
  RootUtils::WithRootErrorHandler errHand (std::bind (&TConvertingStreamerInfo::errhand,
                                                      this,
                                                      _1, _2, _3, _4));
  TStreamerInfo::BuildOld();
}
 
 
bool TConvertingStreamerInfo::patch (const std::string& field,
                                     const std::string& from,
                                     const std::string& to)
{
  static std::mutex mutex;
  std::lock_guard<std::mutex> lock (mutex);
 
  if (TMemberStreamer* conv =
      TConverterRegistry::Instance()->GetStreamerConverter (from, to))
  {
    Int_t offset;
    TStreamerElement* elem = GetStreamerElement (field.c_str(), offset);
    TClass* cl = gROOT->GetClass (to.c_str());
    if (elem && cl) {
      elem->SetTypeName (to.c_str());
      elem->Update (elem->GetClass(), cl);
      elem->SetNewType (elem->GetType());
      elem->SetStreamer (conv);
      return true;
    }
  }
 
  return false;
}
 
 
bool TConvertingStreamerInfo::parse (const std::string& smsg)
{
  if (smsg.substr (0, 15) != "Cannot convert ") return false;
 
  std::string::size_type ifrom = smsg.find (" from type:");
  if (ifrom == std::string::npos) return false;
  
  std::string::size_type ifield = smsg.rfind ("::", ifrom);
  if (ifield == std::string::npos) return false;
 
  std::string field (smsg, ifield+2, ifrom - (ifield+2));
 
  std::string::size_type ito = smsg.find (" to type:");
  if (ito == std::string::npos) return false;
 
  ifrom += 11;
  while (ifrom < ito && smsg[ifrom] == ' ')
    ++ifrom;
  std::string from (smsg, ifrom, ito - ifrom);
 
  std::string::size_type iskip = smsg.find (", skip element");
  if (iskip == std::string::npos) return false;
 
  ito += 9;
  while (ito < iskip && smsg[ito] == ' ')
    ++ito;
  std::string to (smsg, ito, iskip - ito);
 
  return patch (field, from, to);
}
 
 
bool TConvertingStreamerInfo::errhand (int /*level*/,
                                       Bool_t /*abort*/,
                                       const char* /*location*/,
                                       const char* msg)
{
  return !parse (msg);
}