TConvertingStreamerInfo Class Reference

Variant of TStreamerInfo to handle conversions. More...

#include <TConvertingStreamerInfo.h>

Inheritance diagram for TConvertingStreamerInfo:

Collaboration diagram for TConvertingStreamerInfo:

Public Member Functions
	TConvertingStreamerInfo ()
	Constructor. More...
virtual void	BuildOld ()
	Compare with class definition to handle schema evolution. More...

Static Public Member Functions
static void	Initialize ()
	Set up conversions. More...

Private Member Functions
bool	errhand (int level, Bool_t abort, const char *location, const char *msg)
	Error message interceptor. More...
bool	parse (const std::string &msg)
	Error message parser. More...
bool	patch (const std::string &field, const std::string &from, const std::string &to)
TConvertingStreamerInfo &	operator= (const TConvertingStreamerInfo &)=delete
	TConvertingStreamerInfo (const TConvertingStreamerInfo &)=delete

Static Private Member Functions
static void *	new_TConvertingStreamerInfo (void *p)
	new() method for this object. More...

Detailed Description

Variant of TStreamerInfo to handle conversions.

Definition at line 34 of file TConvertingStreamerInfo.h.

Constructor & Destructor Documentation

TConvertingStreamerInfo() [1/2]

TConvertingStreamerInfo::TConvertingStreamerInfo

(

)

Constructor.

Definition at line 31 of file TConvertingStreamerInfo.cxx.

{
}

TConvertingStreamerInfo() [2/2]

TConvertingStreamerInfo::TConvertingStreamerInfo ( const TConvertingStreamerInfo &  )

privatedelete

Member Function Documentation

BuildOld()

void TConvertingStreamerInfo::BuildOld ( )

virtual

Compare with class definition to handle schema evolution.

This is a standard TStreamerInfo method. We override this to intercept warning messages that it produces. If we see a warning related to one of the conversions that we handle, we patch up the TStreamerElement and swallow the warning.

Definition at line 93 of file TConvertingStreamerInfo.cxx.

{
  using namespace std::placeholders;
  RootUtils::WithRootErrorHandler errHand (std::bind (&TConvertingStreamerInfo::errhand,
                                                      this,
                                                      _1, _2, _3, _4));
  TStreamerInfo::BuildOld();
}

errhand()

bool TConvertingStreamerInfo::errhand ( int  level, Bool_t  abort, const char *  location, const char *  msg  )

private

Error message interceptor.

Parameters

level	Error message level.
abort	Abort flag.
location	Function that raised the error.
msg	Error message.

We interpose this in front of the default error handler while BuildOld is running. If we see a message corresponding to a conversion that we handle, we fix up the TStreamerElement and swallow the message.

Definition at line 194 of file TConvertingStreamerInfo.cxx.

{
  return !parse (msg);
}

Initialize()

void TConvertingStreamerInfo::Initialize ( )

static

Set up conversions.

Definition at line 39 of file TConvertingStreamerInfo.cxx.

{
  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);
}

new_TConvertingStreamerInfo()

void * TConvertingStreamerInfo::new_TConvertingStreamerInfo ( void *  p )

staticprivate

new() method for this object.

Parameters

p	Address for placement new, or 0.

Returns

Address of the new object.

This is installed as the New method in TStreamerInfo's TClass. Thus, when we read from a file a TBranchElement, we actually make an instance of this class.

Parameters

p	Address for placement new, or 0.

Returns

Address of the new object.

This is installed as the New method in TStreamerInfo's TClass. Thus, when we read from a file a TStreamerInfo, we actually make an instance of this class.

Definition at line 77 of file TConvertingStreamerInfo.cxx.

{
  if (p)
    return new (p) TConvertingStreamerInfo;
  return new TConvertingStreamerInfo;
}

operator=()

TConvertingStreamerInfo& TConvertingStreamerInfo::operator= ( const TConvertingStreamerInfo &  )

privatedelete

parse()

bool TConvertingStreamerInfo::parse ( const std::string &  smsg )

private

Error message parser.

Parameters

msg	The error message.

Returns

True if the message was handled; false otherwise.

If this is an error message corresponding to a conversion that we handle, we fix up the TStreamerElement and return true. Otherwise, return false.

Definition at line 150 of file TConvertingStreamerInfo.cxx.

{
  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);
}

patch()

bool TConvertingStreamerInfo::patch ( const std::string &  field, const std::string &  from, const std::string &  to  )

private

Parameters

Streamer	patcher.
field	Name of the field to patch.
from	Original (persistent) type.
to	Target (transient) type.

Returns

True if the conversion was handled; false otherwise.

This is called after an error message for a type mismatch has been successfully parsed. Fix up the TStreamerElement and return true if this is a conversion we handle; return false otherwise.

Definition at line 115 of file TConvertingStreamerInfo.cxx.

{
  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;
}

---

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

• TConvertingStreamerInfo.h
• TConvertingStreamerInfo.cxx