C++ TBuffer::IsReading方法代码示例

void KVList::Streamer(TBuffer &R__b)
{
    // Backwards-compatible streamer

    UInt_t R__s, R__c;
    if (R__b.IsReading()) {
        Version_t R__v = R__b.ReadVersion(&R__s, &R__c);
        if (R__v < 3) {
            // read in old KVList object which inherited from TList
            TList list;
            list.Streamer(R__b);
            TQObjSender fQObj;
            fQObj.Streamer(R__b);
            SetOwner(list.IsOwner()); // was list owner of objects ?
            list.SetOwner(kFALSE); // make sure old list doesn't delete objects when it goes out of scope
            TIter next(&list);
            TObject* obj;
            while ( (obj = next()) ) Add(obj);
            list.Clear();
        }
        else
            R__b.ReadClassBuffer(KVList::Class(),this,R__v,R__s,R__c);
    } else {
        R__b.WriteClassBuffer(KVList::Class(),this);
    }
}

//______________________________________________________________________________
void RunStat::Streamer(TBuffer &R__b)
{
   // Stream an object of class RunStat.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TObject::Streamer(R__b);
      R__b >> RunNumber;
      R__b >> IsCalib;
      R__b >> Axis;
      R__b >> Source;
      R__b >> Z;
      R__b >> Site;
      R__b >> StartSec;
      R__b >> StartNano;
      R__b >> EndSec;
      R__b >> EndNano;
      R__b >> FullTime;
      R__b >> Veto1;
      R__b >> Veto2;
      R__b >> Veto3;
      R__b >> Veto4;
      R__b >> Scale1;
      R__b >> Scale2;
      R__b >> Scale3;
      R__b >> Scale4;
      R__b >> ScaleE1;
      R__b >> ScaleE2;
      R__b >> ScaleE3;
      R__b >> ScaleE4;
      R__b.CheckByteCount(R__s, R__c, RunStat::IsA());
   } else {

void KVReconstructedEvent::Streamer(TBuffer & R__b)
{
   //Stream an object of class KVReconstructedEvent.
   //We set the particles' angles depending on whether mean or random angles
   //are wanted (fMeanAngles = kTRUE or kFALSE)

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(KVReconstructedEvent::Class(), this);
      // if the multidetector object exists, update some informations
      // concerning the detectors etc. hit by this particle
      if ( gMultiDetArray ){
      	//set angles
      	KVReconstructedNucleus *par;
      	while ((par = GetNextParticle())) {
         	if (HasMeanAngles())
               par->GetAnglesFromStoppingDetector("mean");
         	else
                par->GetAnglesFromStoppingDetector("random");
         	//reconstruct fAnalStatus information for KVReconstructedNucleus
         	if (par->GetStatus() == 99)        //AnalStatus has not been set for particles in group
            	if (par->GetGroup())
                KVReconstructedNucleus::AnalyseParticlesInGroup( par->GetGroup() );
         }
      }
   } else {
      R__b.WriteClassBuffer(KVReconstructedEvent::Class(), this);
   }
}

//_______________________________________________________________________
void TArrayL64::Streamer(TBuffer &b)
{
    // Stream a TArrayL64 object.

    if (b.IsReading()) {
        Int_t n;
        b >> n;
        Set(n);
        b.ReadFastArray(fArray,n);
    } else {

//______________________________________________________________________________
void GmpNormAna::Streamer(TBuffer &R__b)
{
   // Stream an object of class GmpNormAna.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(GmpNormAna::Class(),this);
   } else {
      R__b.WriteClassBuffer(GmpNormAna::Class(),this);
   }
}

//______________________________________________________________________________
void RapidRun::Streamer(TBuffer &R__b)
{
   // Stream an object of class RapidRun.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(RapidRun::Class(),this);
   } else {
      R__b.WriteClassBuffer(RapidRun::Class(),this);
   }
}

//______________________________________________________________________________
void Event::Streamer(TBuffer &R__b)
{
   // Stream an object of class Event.

   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(Event::Class(),this);
   } else {
      R__b.WriteClassBuffer(Event::Class(),this);
   }
}

//______________________________________________________________________________
void TMatlab::Streamer(TBuffer &R__b)
{
   // Stream an object of class TMatlab.

   UInt_t R__s, R__c;
   if (R__b.IsReading()) {
      Version_t R__v = R__b.ReadVersion(&R__s, &R__c); if (R__v) { }
      TQQObject::Streamer(R__b);
      R__b >> fEvalReturn;
      R__b.CheckByteCount(R__s, R__c, TMatlab::IsA());
   } else {

void KVCsI_e475s::Streamer(TBuffer& R__b)
{
   // Stream an object of class KVCsI.
   // We set the pointers to the calibrator objects

   if (R__b.IsReading()) {
      KVCsI_e475s::Class()->ReadBuffer(R__b, this);
      fcalibLT  = (KVFunctionCal*)GetCalibrator("Channel->MeV(LT)");
      //printf("")
   } else {
      KVCsI_e475s::Class()->WriteBuffer(R__b, this);
   }
}

void KVBIC::Streamer(TBuffer& R__b)
{
   // Stream an object of class KVBIC.
   // We set the pointers to the calibrator objects
   // We add the linear calibrator if it is missing

   if (R__b.IsReading()) {
      KVBIC::Class()->ReadBuffer(R__b, this);
      fLinCal = (KVLinCal*)GetCalibrator("Linear calibration PG");
   } else {
      KVBIC::Class()->WriteBuffer(R__b, this);
   }
}

void KVChIo::Streamer(TBuffer &R__b)
{
    // Stream an object of class KVChIo.
    // We set the pointers to the calibrator objects

    if (R__b.IsReading()) {
        KVChIo::Class()->ReadBuffer(R__b, this);
        fVoltE = (KVVoltEnergy *) GetCalibrator("Volt-Energy");
        fChVoltPG  =  (KVChannelVolt *) GetCalibrator("Channel-Volt PG");
        fChVoltGG  =  (KVChannelVolt *) GetCalibrator("Channel-Volt GG");
    } else {
        KVChIo::Class()->WriteBuffer(R__b, this);
    }
}

//___________________________________________________________________________________________
void KVIntegerList::Streamer(TBuffer& R__b)
{
//Streamer specifique
//l'écriture dans un fichier root se fait par l'intermédiaire de la classe TNamed
//seul, le nom et la partition et sa population sont enregistrées dans le fichier
//la lecture utilise aussi le streamer de TNamed, puis il y a un appel a la routine
// protected DeducePartitionFromTNamed() qui permet de recréer complètement l'objet KVIntegerList
   if (R__b.IsReading()) {
      R__b.ReadClassBuffer(TNamed::Class(), this);
      DeducePartitionFromTNamed();
   } else {
      SetTitle(Form("%d", GetPopulation()));
      R__b.WriteClassBuffer(TNamed::Class(), this);
   }
}

void KVINDRAReconEvent::Streamer(TBuffer & R__b)
{
   //Stream an object of class KVINDRAReconEvent.
   //We loop over the newly-read particles in order to set their
   //IsOK() status by comparison with the event's code mask.

    if (R__b.IsReading()) {
        R__b.ReadClassBuffer(KVINDRAReconEvent::Class(), this);
        KVINDRAReconNuc *par;
        while ((par = GetNextParticle())) {
            par->SetIsOK(CheckCodes(par->GetCodes()));
        }
    } else {
        R__b.WriteClassBuffer(KVINDRAReconEvent::Class(), this);
    }
}

void KVTGID::Streamer(TBuffer & R__b)
{
    // Stream an object of class KVTGID.
    // If the name of the KVTGIDFunction has been set (version > 1) then
    // we use it to reset the function pointer

    if (R__b.IsReading()) {
        KVTGID::Class()->ReadBuffer(R__b, this);
        if (fTGIDFunctionName != "") {
            SetFunction((Double_t(*)(Double_t *, Double_t *)) gROOT->
                        ProcessLineFast(fTGIDFunctionName.Data()));
        }
    } else {
        KVTGID::Class()->WriteBuffer(R__b, this);
    }
}

void KVHarpeeSi::Streamer(TBuffer &R__b){
   // Stream an object of class KVHarpeeSi.
   // We set the pointers to the calibrator objects

   if (R__b.IsReading()) {
      KVHarpeeSi::Class()->ReadBuffer(R__b, this);
	  TIter next( GetListOfCalibrators() );
	  TObject *cal = NULL;
	  while( ( cal = next() ) ){
		  if( cal->InheritsFrom("KVRecombination") )
      		  fPHD  =  (KVRecombination *)cal;
		  else if( cal->InheritsFrom("KVFunctionCal") )
			  fCanalE = (KVFunctionCal *)cal;
	  }
   } else {
      KVHarpeeSi::Class()->WriteBuffer(R__b, this);
   }
}