TConverterStreamer Class Reference

Root streamer that calls our converter when reading in non-split mode. More...

#include <TConverterStreamer.h>

Inheritance diagram for TConverterStreamer:

Collaboration diagram for TConverterStreamer:

Public Types
using	Payload = std::pair<TVirtualConverter*, bool>
using	CheckSumMap = std::map<UInt_t, Payload>

Public Member Functions
	TConverterStreamer (const CheckSumMap &convmap, TClass *cls)
	Constructor.
virtual void	operator() (TBuffer &b, void *obj)
	Standard Root streamer interface.

Private Member Functions
void	FindVersion (TBuffer &buf, UInt_t &startpos, UInt_t &bcnt, Version_t &version)
	Read the initial byte count/version from an object.
Version_t	R__FindStreamerInfoVersion (const TClass *cl, UInt_t checksum)
	Translate a Root checksum to a class version number.

Private Attributes
const CheckSumMap &	fConvmap
	The checksum -> converter map passed to the constructor.
TClass *	fClass
	The transient class we're reading.
UInt_t	fStreamerChecksum
	Cached checksum for the last object read.
TFile *	fLastFile
	Cached file for the last object read.

Detailed Description

Root streamer that calls our converter when reading in non-split mode.

Definition at line 44 of file TConverterStreamer.h.

Member Typedef Documentation

CheckSumMap

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

Definition at line 49 of file TConverterStreamer.h.

Payload

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

Definition at line 48 of file TConverterStreamer.h.

Constructor & Destructor Documentation

TConverterStreamer()

TConverterStreamer::TConverterStreamer	(	const CheckSumMap &	convmap,
		TClass *	cls )

Constructor.

Parameters

convmap	Map from checksums to converter instances.
cls	The transient class that we're reading.

Definition at line 24 of file TConverterStreamer.cxx.

  : fConvmap (convmap),
    fClass (cls),
    fStreamerChecksum (0),
    fLastFile (nullptr)
{
}

Member Function Documentation

FindVersion()

void TConverterStreamer::FindVersion ( TBuffer & buf, UInt_t & startpos, UInt_t & bcnt, Version_t & version )

private

Read the initial byte count/version from an object.

Parameters

	buf	The Root I/O buffer.
[out]	startpos	The starting position of the object.
[out]	bcnt	The length of the object, in bytes.
[out]	version	The version of the object being read.

As a side effect, this sets fStreamerChecksum.

Definition at line 75 of file TConverterStreamer.cxx.

{
  const UInt_t kByteCountMask     = 0x40000000;  // OR the byte count with this
 
  // before reading object save start position
  startpos = buf.Length();
 
  // read byte count (older files don't have byte count)
  // byte count is packed in two individual shorts, this to be
  // backward compatible with old files that have at this location
  // only a single short (i.e. the version)
  union {
    UInt_t     cnt;
    Version_t  vers[2];
  } v;
#ifdef R__BYTESWAP
  // cppcheck-suppress uninitvar
  buf >> v.vers[1];
  buf >> v.vers[0];
#else
  // cppcheck-suppress uninitvar
  buf >> v.vers[0];
  buf >> v.vers[1];
#endif
  if (!(v.cnt & kByteCountMask)) {
    // no bytecount, go back before reading version
    buf.SetBufferOffset(buf.Length() - sizeof(UInt_t));
    v.cnt = 0;
  }
  bcnt = (v.cnt & ~kByteCountMask);
  buf >> version;
 
  TFile* parent = (TFile*)buf.GetParent();
  if (fLastFile != parent) {
    // new file, reset
    fStreamerChecksum = 0;
  }
  if (fClass && fClass->GetClassVersion() != 0) {
    if (version <= 0) {
      buf >> fStreamerChecksum;
      version = R__FindStreamerInfoVersion(fClass,
                                           fStreamerChecksum);
    } else if (version == 1) {
      // hand made streamer list caching,
      // change that when TFile::GetStreamerInfoCache() is out      
      if (fLastFile == parent) {
        // the same file, nothing changed?
      }
      else if (parent && parent->GetVersion() < 40000)
      {
        // We could have a file created using a Foreign class before
        // the introduction of the CheckSum.  We need to check
        if ((!fClass->IsLoaded() || fClass->IsForeign()) &&
            fClass->GetStreamerInfos()->GetLast() > 1)
        {
          const TList* list  = parent->GetStreamerInfoList();
          const TStreamerInfo* local = (TStreamerInfo*)list->FindObject(fClass->GetName());
          if (local) {
            fStreamerChecksum = local->GetCheckSum();
            version = R__FindStreamerInfoVersion(fClass,
                                                 fStreamerChecksum);
          }
          else {
            version = 0;
          }
        }
      }
    }
  }
  fLastFile = parent;
}

operator()()

void TConverterStreamer::operator() ( TBuffer & b, void * obj )

virtual

Standard Root streamer interface.

Parameters

b	Buffer for Root I/O.
obj	Object being read or written.

Definition at line 39 of file TConverterStreamer.cxx.

{
  if (b.IsReading()) {
    // Reading --- do we need to convert?
    UInt_t startpos, bcnt;
    Version_t version;
    FindVersion (b, startpos, bcnt, version);
    // find converter for the object shape checksum
    // (checksum is read from the file in FindVersion)
    auto i = fConvmap.find (fStreamerChecksum);
 
    if (i != fConvmap.end()) {
      // Found a converter --- call it.
      i->second.first->ReadBuffer (b, obj, version, startpos, bcnt);
    }
    else {
      // No converter --- read normally.
      fClass->ReadBuffer(b, obj, version, startpos, bcnt);
    }
  }
  else {
    // Writing --- just do the standard thing.
    fClass->WriteBuffer(b, obj);
  }
}

R__FindStreamerInfoVersion()

Version_t TConverterStreamer::R__FindStreamerInfoVersion ( const TClass * cl, UInt_t checksum )

private

Translate a Root checksum to a class version number.

Parameters

cl	The class being examined.
checksum	The checksum to translate.

Returns

The class version number of cl with checksum checksum, or 0 if there's no match.

Definition at line 158 of file TConverterStreamer.cxx.

{
  //FIXME
  // use TBuffer::R__FindStreamerInfoVersion() instead of this function
  // with the next ROOT release
 
  //find the version number in the StreamerInfos corresponding to checksum
  Version_t version = 0;
  Int_t ninfos = cl->GetStreamerInfos()->GetEntriesFast();
  for (Int_t i = 1; i < ninfos; i++) {
    // TClass::fStreamerInfos has a lower bound not equal to 0,
    // so we should use At and not use UncheckedAt
    TStreamerInfo* info = (TStreamerInfo*)cl->GetStreamerInfos()->At(i);
    if (!info) {
      continue;
    }
    if (info->GetCheckSum() == checksum) {
      version = i;
      break;
    }
  }
  return(version);
}

Member Data Documentation

fClass

TClass* TConverterStreamer::fClass

private

The transient class we're reading.

Definition at line 94 of file TConverterStreamer.h.

fConvmap

const CheckSumMap& TConverterStreamer::fConvmap

private

The checksum -> converter map passed to the constructor.

Definition at line 91 of file TConverterStreamer.h.

fLastFile

TFile* TConverterStreamer::fLastFile

private

Cached file for the last object read.

Definition at line 100 of file TConverterStreamer.h.

fStreamerChecksum

UInt_t TConverterStreamer::fStreamerChecksum

private

Cached checksum for the last object read.

Definition at line 97 of file TConverterStreamer.h.

---

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

• TConverterStreamer.h
• TConverterStreamer.cxx