PyROOTTypePatch.cxx

Go to the documentation of this file.

/*
 * Copyright (C) 2002-2022 CERN for the benefit of the ATLAS collaboration.
 */
#include "CxxUtils/checker_macros.h"
ATLAS_NO_CHECK_FILE_THREAD_SAFETY;
 
#include "RootUtils/PyROOTTypePatch.h"
#include "Rtypes.h"
#include "TGenericClassInfo.h"
#include "TClass.h"
#include "TROOT.h"
#include "TError.h"
#include "TClassTable.h"
#include <ctype.h>
#include <cassert>
 
 
using ROOT::Internal::TInitBehavior;
using ROOT::Internal::TDefaultInitBehavior;
using ROOT::Internal::DefineBehavior;
 
 
//****************************************************************************
// This is the class creation hook.
//
 
 
namespace {
 
 
class TypePatchInitBehavior
  : public TDefaultInitBehavior
{
public:
  virtual TClass *CreateClass(const char *cname, Version_t id,
                              const std::type_info &info, TVirtualIsAProxy *isa,
                              const char *dfil, const char *ifil,
                              Int_t dl, Int_t il) const;
 
  static TDefaultInitBehavior oldBehavior;
  static TDefaultInitBehavior* oldBehaviorPtr;
};
TDefaultInitBehavior  TypePatchInitBehavior::oldBehavior;
TDefaultInitBehavior* TypePatchInitBehavior::oldBehaviorPtr = 0;
 
 
TClass* TypePatchInitBehavior::CreateClass(const char *cname,
                                           Version_t id,
                                           const std::type_info &info,
                                           TVirtualIsAProxy *isa,
                                           const char *dfil,
                                           const char *ifil,
                                           Int_t dl,
                                           Int_t il) const
{
  // Do the default root behavior.
  TClass* cl = oldBehaviorPtr->CreateClass(cname, id, info, isa,
                                           dfil, ifil, dl, il);
 
  // Scan the new class.
  RootUtils::PyROOTTypePatch::scan_one (cl);
 
  // Return it.
  return cl;
}
 
 
} // anonymous namespace
 
 
//****************************************************************************
// Local helper functions.
//
 
 
namespace {
 
 
bool name_is_pair (const char* clsname)
{
  return (strncmp (clsname, "pair<", 5) == 0 || 
          strncmp (clsname, "std::pair<", 10) == 0);
}
 
 
void scan_for_pair()
{
  // Should hold the ROOT mutex before using TClassTable.
  R__WRITE_LOCKGUARD (ROOT::gCoreMutex);
 
  TClassTable::Init();
  while (const char* clsname = TClassTable::Next()) {
    if (name_is_pair (clsname)) {
      TClass* cls = gROOT->GetClass (clsname, kFALSE);
      if (cls)
        cls->GetListOfBases()->Clear();
    }
  }
}
 
 
} // anonymous namespace
 
 
namespace RootUtils {
 
 
void PyROOTTypePatch::initialize()
{
  // Return if we've already initialized.
  static bool initialized = false;
  if (initialized) return;
  initialized = true;
 
  // Scan all classes.
  scan_for_pair();
 
  // Register ourselves as a hook,
  // to be called in the future on class creation.
  TypePatchInitBehavior::oldBehaviorPtr = &TypePatchInitBehavior::oldBehavior;
  TInitBehavior* ib =
    const_cast<TInitBehavior*>(DefineBehavior(0,0));
  assert (sizeof(TDefaultInitBehavior) == sizeof (TypePatchInitBehavior));
  memcpy ((char*)&TypePatchInitBehavior::oldBehavior, (char*)ib,
          sizeof(TDefaultInitBehavior));
  static TypePatchInitBehavior sfaib;
  memcpy ((char*)ib, (char*)&sfaib, sizeof(TDefaultInitBehavior));
 
  // Make sure the TClass's for these are built.
  // Otherwise, CreateClass can get called while global dtors are running.
  gROOT->GetClass("TObjString");
  gROOT->GetClass("TTreeCache");
}
 
 
void PyROOTTypePatch::scan_one (TClass* cls)
{
  if (name_is_pair (cls->GetName())) {
    cls->GetListOfBases()->Clear();
  }
}
 
 
} // namespace RootUtils