C++ TBuffer类代码示例

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

EnHandleResult CTcpPullServer::FireReceive(TSocketObj* pSocketObj, const BYTE* pData, int iLength)
{
	TBuffer* pBuffer = m_bfPool[pSocketObj->connID];
	ASSERT(pBuffer && pBuffer->IsValid());

	pBuffer->Cat(pData, iLength);

	return __super::FireReceive(pSocketObj, pBuffer->Length());
}

std::string DecryptSymmetrical(const std::string& key, const TBuffer& data) {
    assert(key.size() == AES::MAX_KEYLENGTH + AES::BLOCKSIZE);
    string result;
    result.resize(data.Size());
    CFB_Mode<AES>::Decryption cfbDecryption((byte*)key.data(), AES::MAX_KEYLENGTH,
                                            (byte*)key.data() + AES::MAX_KEYLENGTH);
    cfbDecryption.ProcessData((byte*)result.data(), (byte*)data.Data(), data.Size());
    return result;
}

//______________________________________________________________________________
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 SaveResult(xmlDocPtr doc, xsltStylesheetPtr stylesheet, TBuffer& to) {
     xmlOutputBufferPtr buf = xmlAllocOutputBuffer(NULL); // NULL means UTF8
     xsltSaveResultTo(buf, doc, stylesheet);
     if (buf->conv != NULL) {
         to.Assign((const char*)buf->conv->content, buf->conv->use);
     } else {
         to.Assign((const char*)buf->buffer->content, buf->buffer->use);
     }
     xmlOutputBufferClose(buf);
 }

//_______________________________________________________________________
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 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);
   }
}

EnHandleResult CTcpPullAgent::FireReceive(TSocketObj* pSocketObj, const BYTE* pData, int iLength)
{
	TBuffer* pBuffer = nullptr;
	GetConnectionReserved(pSocketObj, (PVOID*)&pBuffer);
	ASSERT(pBuffer && pBuffer->IsValid());

	pBuffer->Cat(pData, iLength);

	return __super::FireReceive(pSocketObj, pBuffer->Length());
}

//______________________________________________________________________________
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 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 TClient::SendOfflineMessage(const string& friendLogin, const TBuffer& data) {
    string response;
    response.resize(1);
    response[0] = RT_SendMessage;
    TOfflineMessage offlineMessage;
    offlineMessage.set_friendlogin(friendLogin);
    offlineMessage.set_encryptedmessage(data.Data(), data.Size());
    response += offlineMessage.SerializeAsString();
    response = EncryptSymmetrical(State.sessionkey(), Compress(response));
    UdtClient->Send(Serialize(response));
}

//___________________________________________________________________________________________
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);
    }
}