ROOT8367Workaround::TBufferFileWorkaround Class Reference

Inheritance diagram for ROOT8367Workaround::TBufferFileWorkaround:

Collaboration diagram for ROOT8367Workaround::TBufferFileWorkaround:

Public Member Functions
void *	ReadObjectAnyNV (const TClass *)

Static Public Member Functions
static void *doReadObjectAny	NO_SANITIZE_UNDEFINED (TBufferFile *buf, const TClass *cl)

Detailed Description

Definition at line 73 of file TrigTSerializer.cxx.

Member Function Documentation

NO_SANITIZE_UNDEFINED()

static void* doReadObjectAny ROOT8367Workaround::TBufferFileWorkaround::NO_SANITIZE_UNDEFINED ( TBufferFile *  buf, const TClass *  cl  )

inlinestatic

Definition at line 78 of file TrigTSerializer.cxx.

  {
    TBufferFileWorkaround* ba = reinterpret_cast<TBufferFileWorkaround*>(buf);
    return ba->ReadObjectAnyNV(cl);
  }

ReadObjectAnyNV()

void * ROOT8367Workaround::TBufferFileWorkaround::ReadObjectAnyNV

(

const TClass *

clCast

)

Definition at line 86 of file TrigTSerializer.cxx.

{
   R__ASSERT(IsReading());
 
   // make sure fMap is initialized
   InitMap();
 
   // before reading object save start position
   UInt_t startpos = UInt_t(fBufCur-fBuffer);
 
   // attempt to load next object as TClass clCast
   UInt_t tag;       // either tag or byte count
   TClass *clRef = ReadClass(clCast, &tag);
   TClass *clOnfile = 0;
   Int_t baseOffset = 0;
   if (clRef && (clRef!=(TClass*)(-1)) && clCast) {
      //baseOffset will be -1 if clRef does not inherit from clCast.
      baseOffset = clRef->GetBaseClassOffset(clCast);
      if (baseOffset == -1) {
         // The 2 classes are unrelated, maybe there is a converter between the 2.
 
         if (!clCast->GetSchemaRules() ||
             !clCast->GetSchemaRules()->HasRuleWithSourceClass(clRef->GetName()))
         {
            // There is no converter
            Error("ReadObject", "got object of wrong class! requested %s but got %s",
                  clCast->GetName(), clRef->GetName());
 
            CheckByteCount(startpos, tag, (TClass*)0); // avoid mis-leading byte count error message
            return 0; // We better return at this point
         }
         baseOffset = 0; // For now we do not support requesting from a class that is the base of one of the class for which there is transformation to ....
         
         //Info("ReadObjectAny","Using Converter StreamerInfo from %s to %s",clRef->GetName(),clCast->GetName());
         clOnfile = clRef;
         clRef = const_cast<TClass*>(clCast);
 
      }
      if (clCast->GetState() > TClass::kEmulated && clRef->GetState() <= TClass::kEmulated) {
         //we cannot mix a compiled class with an emulated class in the inheritance
         Error("ReadObject", "trying to read an emulated class (%s) to store in a compiled pointer (%s)",
               clRef->GetName(),clCast->GetName());
         CheckByteCount(startpos, tag, (TClass*)0); // avoid mis-leading byte count error message
         return 0;
      }
   }
 
   // check if object has not already been read
   // (this can only happen when called via CheckObject())
   char *obj;
   if (fVersion > 0) {
      obj = (char *) (Long_t)fMap->GetValue(startpos+kMapOffset);
      if (obj == (void*) -1) obj = 0;
      if (obj) {
         CheckByteCount(startpos, tag, (TClass*)0);
         return (obj+baseOffset);
      }
   }
 
   // unknown class, skip to next object and return 0 obj
   if (clRef == (TClass*) -1) {
      if (fBufCur >= fBufMax) return 0;
      if (fVersion > 0)
         MapObject((TObject*) -1, startpos+kMapOffset);
      else
         MapObject((void*)0, 0, fMapCount);
      CheckByteCount(startpos, tag, (TClass*)0);
      return 0;
   }
 
   if (!clRef) {
 
      // got a reference to an already read object
      if (fVersion > 0) {
         tag += fDisplacement;
         tag = CheckObject(tag, clCast);
      } else {
         if (tag > (UInt_t)fMap->GetSize()) {
            Error("ReadObject", "object tag too large, I/O buffer corrupted");
            return 0;
            // exception
         }
      }
      obj = (char *) (Long_t)fMap->GetValue(tag);
      clRef = (TClass*) (Long_t)fClassMap->GetValue(tag);
 
      if (clRef && (clRef!=(TClass*)(-1)) && clCast) {
         //baseOffset will be -1 if clRef does not inherit from clCast.
         baseOffset = clRef->GetBaseClassOffset(clCast);
         if (baseOffset == -1) {
            Error("ReadObject", "Got object of wrong class (Got %s while expecting %s)",
                  clRef->GetName(),clCast->GetName());
            // exception
            baseOffset = 0;
         }
      }
 
      // There used to be a warning printed here when:
      //   obj && isTObject && !((TObject*)obj)->IsA()->InheritsFrom(clReq)
      // however isTObject was based on clReq (now clCast).
      // If the test was to fail, then it is as likely that the object is not a TObject
      // and then we have a potential core dump.
      // At this point (missing clRef), we do NOT have enough information to really
      // answer the question: is the object read of the type I requested.
 
   } else {
 
      // allocate a new object based on the class found
      obj = (char*)clRef->New();
      if (!obj) {
         Error("ReadObject", "could not create object of class %s",
               clRef->GetName());
         // exception
         return 0;
      }
 
      // add to fMap before reading rest of object
      if (fVersion > 0)
         MapObject(obj, clRef, startpos+kMapOffset);
      else
         MapObject(obj, clRef, fMapCount);
 
      // let the object read itself
      clRef->Streamer( obj, *this, clOnfile );
 
      CheckByteCount(startpos, tag, clRef);
   }
 
   return obj+baseOffset;
}

---

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

• TrigTSerializer.cxx