#include <string.h>
#include <stdio.h>
#include "TROOT.h"
#include "TClass.h"
#include "TFile.h"
#include "TBranch.h"
#include "TTree.h"
#include "TBasket.h"
#include "TBrowser.h"
#include "TLeaf.h"
#include "TLeafObject.h"
#include "TLeafB.h"
#include "TLeafC.h"
#include "TLeafI.h"
#include "TLeafF.h"
#include "TLeafS.h"
#include "TLeafD.h"
#include "TLeafL.h"
#include "TLeafO.h"
#include "TMessage.h"
#include "TClonesArray.h"
#include "TVirtualPad.h"
#include "TSystem.h"
#include "TStreamerInfo.h"
#include "TBranchBrowsable.h"
#include "TTreeCache.h"
TBranch *gBranch;
R__EXTERN TTree *gTree;
Int_t TBranch::fgCount = 0;
const Int_t kMaxRAM = 10;
const Int_t kMaxLen = 512;
ClassImp(TBranch)
TBranch::TBranch(): TNamed(), TAttFill(0,1001)
{
fCompress = 0;
fBasketSize = 32000;
fEntryOffsetLen = 1000;
fMaxBaskets = 10;
fReadBasket = 0;
fReadEntry = -1;
fWriteBasket = 0;
fEntries = 0;
fTotBytes = 0;
fZipBytes = 0;
fSplitLevel = 0;
fNBasketRAM = kMaxRAM+1;
fBasketRAM = new Int_t[kMaxRAM]; for (Int_t i=0;i<kMaxRAM;i++) fBasketRAM[i] = -1;
fBasketEntry = 0;
fBasketBytes = 0;
fBasketSeek = 0;
fEntryNumber = 0;
fEntryBuffer = 0;
fNleaves = 0;
fTree = 0;
fAddress = 0;
fOffset = 0;
fDirectory = 0;
fSkipZip = kFALSE;
fFileName = "";
fBrowsables = 0;
gBranch = this;
}
TBranch::TBranch(const char *name, void *address, const char *leaflist, Int_t basketsize, Int_t compress)
:TNamed(name,leaflist), TAttFill(0,1001)
{
gBranch = this;
Int_t i;
fCompress = compress;
if (compress == -1 && gTree->GetDirectory()) {
TFile *bfile = gTree->GetDirectory()->GetFile();
if (bfile) fCompress = bfile->GetCompressionLevel();
}
if (basketsize < 100) basketsize = 100;
fBasketSize = basketsize;
fEntryOffsetLen = 0;
fMaxBaskets = 10;
fReadBasket = 0;
fReadEntry = -1;
fWriteBasket = 0;
fEntryNumber = 0;
fEntryBuffer = 0;
fEntries = 0;
fTotBytes = 0;
fZipBytes = 0;
fSplitLevel = 0;
fOffset = 0;
fNleaves = 0;
fBrowsables = 0;
fSkipZip = kFALSE;
fAddress = (char*)address;
fNBasketRAM = kMaxRAM+1;
fBasketRAM = new Int_t[kMaxRAM]; for (i=0;i<kMaxRAM;i++) fBasketRAM[i] = -1;
fBasketBytes = new Int_t[fMaxBaskets];
fBasketEntry = new Long64_t[fMaxBaskets];
fBasketSeek = new Long64_t[fMaxBaskets];
for (i=0;i<fMaxBaskets;i++) {
fBasketBytes[i] = 0;
fBasketEntry[i] = 0;
fBasketSeek[i] = 0;
}
char * varcur = (char*)leaflist;
char * var = varcur;
Int_t lenvar = 0;
Int_t offset = 0;
char *leafname = new char[64];
char *leaftype = new char[32];
strcpy(leaftype,"F");
while (1) {
lenvar++;
if (*var == ':' || *var == 0) {
strncpy(leafname,varcur,lenvar-1);
leafname[lenvar-1] = 0;
char *ctype = strstr(leafname,"/");
if (ctype) { *ctype=0; strcpy(leaftype,ctype+1);}
TLeaf *leaf = 0;
if (*leaftype == 'C') {
leaf = new TLeafC(leafname,leaftype);
} else if (*leaftype == 'O') {
leaf = new TLeafO(leafname,leaftype);
} else if (*leaftype == 'B') {
leaf = new TLeafB(leafname,leaftype);
} else if (*leaftype == 'b') {
leaf = new TLeafB(leafname,leaftype);
leaf->SetUnsigned();
} else if (*leaftype == 'S') {
leaf = new TLeafS(leafname,leaftype);
} else if (*leaftype == 's') {
leaf = new TLeafS(leafname,leaftype);
leaf->SetUnsigned();
} else if (*leaftype == 'I') {
leaf = new TLeafI(leafname,leaftype);
} else if (*leaftype == 'i') {
leaf = new TLeafI(leafname,leaftype);
leaf->SetUnsigned();
} else if (*leaftype == 'F') {
leaf = new TLeafF(leafname,leaftype);
} else if (*leaftype == 'f') {
leaf = new TLeafF(leafname,leaftype);
} else if (*leaftype == 'L') {
leaf = new TLeafL(leafname,leaftype);
} else if (*leaftype == 'l') {
leaf = new TLeafL(leafname,leaftype);
leaf->SetUnsigned();
} else if (*leaftype == 'D') {
leaf = new TLeafD(leafname,leaftype);
} else if (*leaftype == 'd') {
leaf = new TLeafD(leafname,leaftype);
}
if (!leaf) {
Error("TLeaf","Illegal data type for %s/%s",*leaftype,name,leaflist);
MakeZombie();
return;
}
if (leaf->IsZombie()) {
delete leaf;
Error("TBranch","Illegal leaf:%s/%s",name,leaflist);
MakeZombie();
return;
}
leaf->SetBranch(this);
leaf->SetAddress((char*)(fAddress+offset));
leaf->SetOffset(offset);
if (leaf->GetLeafCount()) fEntryOffsetLen = 1000;
if (leaf->InheritsFrom("TLeafC")) fEntryOffsetLen = 1000;
fNleaves++;
fLeaves.Add(leaf);
gTree->GetListOfLeaves()->Add(leaf);
if (*var == 0) break;
varcur = var+1;
offset += leaf->GetLenType()*leaf->GetLen();
lenvar = 0;
}
var++;
}
delete [] leafname;
delete [] leaftype;
fTree = gTree;
fDirectory = fTree->GetDirectory();
fFileName = "";
TBasket *basket = fTree->CreateBasket(this);
fBaskets.AddAt(basket,0);
}
TBranch::TBranch(const TBranch& tb):
TNamed(tb),
TAttFill(tb),
fCompress(tb.fCompress),
fBasketSize(tb.fBasketSize),
fEntryOffsetLen(tb.fEntryOffsetLen),
fWriteBasket(tb.fWriteBasket),
fEntryNumber(tb.fEntryNumber),
fOffset(tb.fOffset),
fMaxBaskets(tb.fMaxBaskets),
fSplitLevel(tb.fSplitLevel),
fNleaves(tb.fNleaves),
fReadBasket(tb.fReadBasket),
fReadEntry(tb.fReadEntry),
fEntries(tb.fEntries),
fTotBytes(tb.fTotBytes),
fZipBytes(tb.fZipBytes),
fBranches(tb.fBranches),
fLeaves(tb.fLeaves),
fBaskets(tb.fBaskets),
fNBasketRAM(tb.fNBasketRAM),
fBasketRAM(tb.fBasketRAM),
fBasketBytes(tb.fBasketBytes),
fBasketEntry(tb.fBasketEntry),
fBasketSeek(tb.fBasketSeek),
fTree(tb.fTree),
fAddress(tb.fAddress),
fDirectory(tb.fDirectory),
fFileName(tb.fFileName),
fEntryBuffer(tb.fEntryBuffer),
fBrowsables(tb.fBrowsables)
{
}
TBranch& TBranch::operator=(const TBranch& tb)
{
if(this!=&tb) {
TNamed::operator=(tb);
TAttFill::operator=(tb);
fCompress=tb.fCompress;
fBasketSize=tb.fBasketSize;
fEntryOffsetLen=tb.fEntryOffsetLen;
fWriteBasket=tb.fWriteBasket;
fEntryNumber=tb.fEntryNumber;
fOffset=tb.fOffset;
fMaxBaskets=tb.fMaxBaskets;
fSplitLevel=tb.fSplitLevel;
fNleaves=tb.fNleaves;
fReadBasket=tb.fReadBasket;
fReadEntry=tb.fReadEntry;
fEntries=tb.fEntries;
fTotBytes=tb.fTotBytes;
fZipBytes=tb.fZipBytes;
fBranches=tb.fBranches;
fLeaves=tb.fLeaves;
fBaskets=tb.fBaskets;
fNBasketRAM=tb.fNBasketRAM;
fBasketRAM=tb.fBasketRAM;
fBasketBytes=tb.fBasketBytes;
fBasketEntry=tb.fBasketEntry;
fBasketSeek=tb.fBasketSeek;
fTree=tb.fTree;
fAddress=tb.fAddress;
fDirectory=tb.fDirectory;
fFileName=tb.fFileName;
fEntryBuffer=tb.fEntryBuffer;
fBrowsables=tb.fBrowsables;
}
return *this;
}
TBranch::~TBranch()
{
if (fBasketRAM) delete [] fBasketRAM;
if (fBasketEntry) delete [] fBasketEntry;
if (fBasketBytes) delete [] fBasketBytes;
if (fBasketSeek) delete [] fBasketSeek;
fBasketRAM = 0;
fBasketEntry = 0;
fBasketBytes = 0;
fBasketSeek = 0;
fLeaves.Delete();
fBaskets.Delete();
delete fBrowsables;
if (fDirectory && fDirectory != fTree->GetDirectory()) {
TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(GetFileName());
if (file ) delete file;
}
fTree = 0;
fDirectory = 0;
gBranch = 0;
}
void TBranch::AddBasket(TBasket &b, Bool_t ondisk, Long64_t startEntry)
{
TBasket *basket = &b;
basket->SetBranch(this);
if (fWriteBasket >= fMaxBaskets) {
ExpandBasketArrays();
}
Int_t where = fWriteBasket;
if (startEntry != fEntryNumber) {
if (!ondisk) {
Warning("AddBasket","The assumption that out-of-order basket only comes from disk based ntuple is false.");
}
for(Int_t i=fWriteBasket-1; i>0; --i) {
if (fBasketEntry[i] < startEntry) {
where = i+1;
break;
} else if (fBasketEntry[i] == startEntry) {
Error("AddBasket","An out-of-order basket matches the entry number of an existing basket.");
}
}
if (where < fWriteBasket) {
for (Int_t j=fWriteBasket; j > where; --j) {
fBasketEntry[j] = fBasketEntry[j-1];
fBasketBytes[j] = fBasketBytes[j-1];
fBasketSeek[j] = fBasketSeek[j-1];
}
}
}
fBasketEntry[where] = startEntry;
if (ondisk) {
fBasketBytes[where] = basket->GetNbytes();
fBasketSeek[where] = basket->GetSeekKey();
++fWriteBasket;
} else {
fBaskets.AddAtAndExpand(basket,fWriteBasket);
if (fWriteBasket >= fMaxBaskets) {
ExpandBasketArrays();
}
fTree->IncrementTotalBuffers(basket->GetBufferSize());
}
fEntries += basket->GetNevBuf();
fEntryNumber += basket->GetNevBuf();
if (ondisk) {
fTotBytes += basket->GetObjlen() + basket->GetKeylen() ;
fZipBytes += basket->GetNbytes();
fTree->AddTotBytes(basket->GetObjlen() + basket->GetKeylen());
fTree->AddZipBytes(basket->GetNbytes());
}
}
void TBranch::Browse(TBrowser *b)
{
if (fNleaves > 1) {
fLeaves.Browse(b);
} else {
TString name = GetName();
Int_t pos = name.First('[');
if (pos!=kNPOS) name.Remove(pos);
GetTree()->Draw(name, "", b ? b->GetDrawOption() : "");
if (gPad) gPad->Update();
}
}
void TBranch::DropBaskets(Option_t* option)
{
Bool_t all = kFALSE;
TString opt = option;
opt.ToLower();
if (opt.Contains("all"))
all = kTRUE;
Int_t i,j;
TBasket *basket;
if (fNBasketRAM < kMaxRAM) {
for (i=0;i<kMaxRAM;i++) {
j = fBasketRAM[i];
if (j < 0) continue;
if ((j == fReadBasket || j == fWriteBasket) && !all) continue;
basket = (TBasket*)fBaskets.UncheckedAt(j);
if (!basket) continue;
basket->DropBuffers();
GetListOfBaskets()->RemoveAt(j);
delete basket;
fBasketRAM[i] = -1;
fNBasketRAM--;
}
if (fNBasketRAM < 0) {
Error("DropBaskets", "fNBasketRAM =%d",fNBasketRAM);
fNBasketRAM = 0;
}
i = 0;
for (j=0;j<kMaxRAM;j++) {
if (fBasketRAM[j] < 0) continue;
fBasketRAM[i] = fBasketRAM[j];
i++;
}
return;
}
Int_t nbaskets = GetListOfBaskets()->GetEntriesFast();
fNBasketRAM = 0;
for (j=0;j<nbaskets-1;j++) {
basket = (TBasket*)fBaskets.UncheckedAt(j);
if (!basket) continue;
if (fNBasketRAM < kMaxRAM) fBasketRAM[fNBasketRAM] = j;
fNBasketRAM++;
if ((j == fReadBasket || j == fWriteBasket) && !all) continue;
basket->DropBuffers();
GetListOfBaskets()->RemoveAt(j);
delete basket;
fNBasketRAM--;
fBasketRAM[fNBasketRAM] = -1;
if (!fTree->MemoryFull(0)) break;
}
if (all) {
TObjArray *lb = GetListOfBranches();
Int_t nb = lb->GetEntriesFast();
for (Int_t j = 0; j < nb; j++) {
TBranch* branch = (TBranch*) lb->UncheckedAt(j);
if (!branch) continue;
branch->DropBaskets("all");
}
}
}
void TBranch::ExpandBasketArrays()
{
Int_t newsize = TMath::Max(10,Int_t(1.5*fMaxBaskets));
fBasketBytes = TStorage::ReAllocInt(fBasketBytes, newsize, fMaxBaskets);
fBasketEntry = (Long64_t*)TStorage::ReAlloc(fBasketEntry,
newsize*sizeof(Long64_t),fMaxBaskets*sizeof(Long64_t));
fBasketSeek = (Long64_t*)TStorage::ReAlloc(fBasketSeek,
newsize*sizeof(Long64_t),fMaxBaskets*sizeof(Long64_t));
fMaxBaskets = newsize;
for (Int_t i=fWriteBasket;i<fMaxBaskets;i++) {
fBasketBytes[i] = 0;
fBasketEntry[i] = 0;
fBasketSeek[i] = 0;
}
}
Int_t TBranch::Fill()
{
if (TestBit(kDoNotProcess)) return 0;
TBasket *basket = GetBasket(fWriteBasket);
if (!basket) return 0;
TBuffer *buf = basket->GetBufferRef();
Int_t nsize = 0;
if (buf->IsReading()) {
basket->SetWriteMode();
}
buf->ResetMap();
Int_t lold = buf->Length();
Int_t objectStart = 0;
Int_t last = 0;
Int_t lnew = 0;
Int_t nbytes = 0;
if ( fEntryBuffer!=0 ) {
if ( fEntryBuffer->IsA() == TMessage::Class() ) {
objectStart = 8;
}
if ( fEntryBuffer->TestBit(TBuffer::kNotDecompressed) ) {
if (basket->GetNevBuf()) {
WriteBasket(basket);
return Fill();
}
Int_t startpos = fEntryBuffer->Length();
fEntryBuffer->SetBufferOffset(0);
static TBasket toread_fLast;
fEntryBuffer->SetReadMode();
toread_fLast.Streamer(*fEntryBuffer);
fEntryBuffer->SetWriteMode();
last = toread_fLast.GetLast();
fEntryBuffer->SetBufferOffset(startpos);
buf->SetBufferOffset(0);
buf->SetBit(TBuffer::kNotDecompressed);
basket->Update(lold);
} else {
const UInt_t kNewClassTag = 0xFFFFFFFF;
const UInt_t kByteCountMask = 0x40000000;
UInt_t tag, startpos = fEntryBuffer->Length();
fEntryBuffer->SetBufferOffset(objectStart);
*fEntryBuffer >> tag;
if ( tag & kByteCountMask ) {
*fEntryBuffer >> tag;
}
if ( tag == kNewClassTag ) {
char s[80];
fEntryBuffer->ReadString(s, 80);
} else {
fEntryBuffer->SetBufferOffset(objectStart);
}
objectStart = fEntryBuffer->Length();
fEntryBuffer->SetBufferOffset(startpos);
basket->Update(lold, objectStart - fEntryBuffer->GetBufferDisplacement());
}
fEntries++;
fEntryNumber++;
UInt_t len, startpos = fEntryBuffer->Length();
if (startpos > UInt_t(objectStart)) {
len = fEntryBuffer->Length() - objectStart;
} else {
len = fEntryBuffer->BufferSize() - objectStart;
}
buf->WriteBuf( fEntryBuffer->Buffer() + objectStart , len );
if ( fEntryBuffer->TestBit(TBuffer::kNotDecompressed) ) {
lnew = nbytes = last;
} else {
lnew = buf->Length();
nbytes = lnew - lold;
}
} else {
basket->Update(lold);
fEntries++;
fEntryNumber++;
FillLeaves(*buf);
lnew = buf->Length();
nbytes = lnew - lold;
}
if (fEntryOffsetLen) {
Int_t nevbuf = basket->GetNevBuf();
nsize = nevbuf*sizeof(Int_t);
} else {
if (!basket->GetNevBufSize()) basket->SetNevBufSize(nbytes);
}
if ( (fSkipZip && (lnew>=TBuffer::kMinimalSize))
|| (buf->TestBit(TBuffer::kNotDecompressed))
|| (lnew +2*nsize +nbytes >= fBasketSize) ) {
if (fTree->TestBit(TTree::kCircular)) return nbytes;
Int_t nout = basket->WriteBuffer();
fBasketBytes[fWriteBasket] = basket->GetNbytes();
fBasketSeek[fWriteBasket] = basket->GetSeekKey();
Int_t addbytes = basket->GetObjlen() + basket->GetKeylen() ;
if (fDirectory != 0 && fDirectory != gROOT && fDirectory->IsWritable()) {
delete basket;
fBaskets[fWriteBasket] = 0;
}
fZipBytes += nout;
fTotBytes += addbytes;
fTree->AddTotBytes(addbytes);
fTree->AddZipBytes(nout);
basket = fTree->CreateBasket(this);
fWriteBasket++;
fBaskets.AddAtAndExpand(basket,fWriteBasket);
if (fWriteBasket >= fMaxBaskets) {
ExpandBasketArrays();
}
fBasketEntry[fWriteBasket] = fEntryNumber;
return (nout >= 0) ? nbytes : -1;
}
return nbytes;
}
void TBranch::FillLeaves(TBuffer &b)
{
for (Int_t i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
leaf->FillBasket(b);
}
}
TBranch *TBranch::FindBranch(const char* searchname)
{
char brname[kMaxLen];
char longsearchname[kMaxLen];
TIter next(GetListOfBranches());
strcpy(longsearchname,GetName());
char *dim = (char*)strstr(longsearchname,"[");
if (dim) dim[0]='\0';
if (longsearchname[strlen(longsearchname)-1] != '.') {
strcat(longsearchname,".");
}
strcat(longsearchname,searchname);
TBranch *branch;
while ((branch = (TBranch*)next())) {
strcpy(brname,branch->GetName());
dim = (char*)strstr(brname,"[");
if (dim) dim[0]='\0';
if (!strcmp(searchname,brname)) return branch;
if (!strcmp(longsearchname,brname)) return branch;
}
return 0;
}
TLeaf *TBranch::FindLeaf(const char* searchname)
{
char leafname[kMaxLen];
char leaftitle[kMaxLen];
char longname[kMaxLen];
char longtitle[kMaxLen];
TIter next (GetListOfLeaves());
TLeaf *leaf;
while ((leaf = (TLeaf*)next())) {
strcpy(leafname,leaf->GetName());
char *dim = (char*)strstr(leafname,"[");
if (dim) dim[0]='\0';
if (!strcmp(searchname,leafname)) return leaf;
strcpy(leaftitle,leaf->GetTitle());
dim = (char*)strstr(leaftitle,"[");
if (dim) dim[0]='\0';
if (!strcmp(searchname,leaftitle)) return leaf;
TBranch * branch = leaf->GetBranch();
if (branch) {
sprintf(longname,"%s.%s",branch->GetName(),leafname);
char *dim = (char*)strstr(longname,"[");
if (dim) dim[0]='\0';
if (!strcmp(searchname,longname)) return leaf;
sprintf(longname,"%s.%s",branch->GetName(),searchname);
if (!strcmp(longname,leafname)) return leaf;
sprintf(longtitle,"%s.%s",branch->GetName(),leaftitle);
dim = (char*)strstr(longtitle,"[");
if (dim) dim[0]='\0';
if (!strcmp(searchname,longtitle)) return leaf;
if (strstr(searchname,".")
&& !strcmp(searchname,branch->GetName())) return leaf;
}
}
return 0;
}
TBasket *TBranch::GetBasket(Int_t basketnumber)
{
static Int_t nerrors = 0;
if (basketnumber <0 || basketnumber > fWriteBasket) return 0;
TBasket *basket = (TBasket*)fBaskets.UncheckedAt(basketnumber);
if (basket) return basket;
gBranch = this;
TDirectory *cursav = gDirectory;
TFile *file = GetFile(0);
basket = new TBasket(file);
if (fSkipZip) basket->SetBit(TBuffer::kNotDecompressed);
basket->SetBranch(this);
if (fBasketBytes[basketnumber] == 0) {
fBasketBytes[basketnumber] = basket->ReadBasketBytes(fBasketSeek[basketnumber],file);
}
TTreeCache *tpf = (TTreeCache*)file->GetCacheRead();
if (tpf) tpf->AddBranch(this);
Int_t badread = basket->ReadBasketBuffers(fBasketSeek[basketnumber],fBasketBytes[basketnumber],file);
if (badread || basket->GetSeekKey() != fBasketSeek[basketnumber]) {
cursav->cd();
nerrors++;
if (nerrors > 10) return 0;
if (nerrors == 10) {
printf(" file probably overwritten: stopping reporting error messages\n");
if (fBasketSeek[basketnumber] > 2000000000) {
printf("===>File is more than 2 Gigabytes\n");
return 0;
}
if (fBasketSeek[basketnumber] > 1000000000) {
printf("===>Your file is may be bigger than the maximum file size allowed on your system\n");
printf(" Check your AFS maximum file size limit for example\n");
return 0;
}
}
Error("GetBasket","File: %s at byte:%lld, branch:%s, entry:%d, badread=%d",file->GetName(),basket->GetSeekKey(),GetName(),fReadEntry,badread);
return 0;
}
cursav->cd();
fBaskets.AddAt(basket,basketnumber);
if (fNBasketRAM < kMaxRAM) fBasketRAM[fNBasketRAM] = basketnumber;
fNBasketRAM++;
return basket;
}
Long64_t TBranch::GetBasketSeek(Int_t basketnumber) const
{
if (basketnumber <0 || basketnumber > fWriteBasket) return 0;
return fBasketSeek[basketnumber];
}
TList *TBranch::GetBrowsables() {
if (fBrowsables) return fBrowsables;
fBrowsables=new TList();
TVirtualBranchBrowsable::FillListOfBrowsables(*fBrowsables, this);
return fBrowsables;
}
const char *TBranch::GetIconName() const
{
if (IsFolder())
return "TBranchElement-folder";
else
return "TBranchElement-leaf";
}
Int_t TBranch::GetEntry(Long64_t entry, Int_t getall)
{
if (TestBit(kDoNotProcess) && !getall) return 0;
if (entry < 0 || entry >= fEntryNumber) return 0;
Int_t nbytes;
Long64_t first = fBasketEntry[fReadBasket];
Long64_t last;
if (fReadBasket == fWriteBasket) last = fEntryNumber - 1;
else last = fBasketEntry[fReadBasket+1] - 1;
if (entry < first || entry > last) {
fReadBasket = TMath::BinarySearch(fWriteBasket+1, fBasketEntry, entry);
first = fBasketEntry[fReadBasket];
}
TBasket *basket = (TBasket*)fBaskets.UncheckedAt(fReadBasket);
if (!basket) {
basket = GetBasket(fReadBasket);
if (!basket) return -1;
}
basket->PrepareBasket(entry);
TBuffer *buf = basket->GetBufferRef();
if (!buf) {
TFile *file = GetFile(0);
basket->ReadBasketBuffers(fBasketSeek[fReadBasket],fBasketBytes[fReadBasket],file);
buf = basket->GetBufferRef();
}
buf->ResetMap();
if (!buf->IsReading()) {
basket->SetReadMode();
}
Int_t bufbegin;
Int_t *entryOffset = basket->GetEntryOffset();
if (entryOffset) bufbegin = entryOffset[entry-first];
else bufbegin = basket->GetKeylen() + (entry-first)*basket->GetNevBufSize();
buf->SetBufferOffset(bufbegin);
Int_t *displacement = basket->GetDisplacement();
if (displacement) buf->SetBufferDisplacement(displacement[entry-first]);
else buf->SetBufferDisplacement();
ReadLeaves(*buf);
nbytes = buf->Length() - bufbegin;
fReadEntry = entry;
return nbytes;
}
Int_t TBranch::GetEntryExport(Long64_t entry, Int_t ,
TClonesArray *li, Int_t nentries)
{
if (TestBit(kDoNotProcess)) return 0;
if (entry < 0 || entry >= fEntryNumber) return 0;
Int_t nbytes;
Long64_t first = fBasketEntry[fReadBasket];
Long64_t last;
if (fReadBasket == fWriteBasket) last = fEntryNumber - 1;
else last = fBasketEntry[fReadBasket+1] - 1;
if (entry < first || entry > last) {
fReadBasket = TMath::BinarySearch(fWriteBasket+1, fBasketEntry, entry);
first = fBasketEntry[fReadBasket];
}
TBasket *basket = GetBasket(fReadBasket);
if (!basket) return 0;
TBuffer *buf = basket->GetBufferRef();
if (!buf->IsReading()) {
basket->SetReadMode();
}
Int_t bufbegin;
Int_t *entryOffset = basket->GetEntryOffset();
if (entryOffset) bufbegin = entryOffset[entry-first];
else bufbegin = basket->GetKeylen() + (entry-first)*basket->GetNevBufSize();
buf->SetBufferOffset(bufbegin);
Int_t *displacement = basket->GetDisplacement();
if (displacement) buf->SetBufferDisplacement(displacement[entry-first]);
else buf->SetBufferDisplacement();
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(0);
leaf->ReadBasketExport(*buf,li,nentries);
nbytes = buf->Length() - bufbegin;
fReadEntry = entry;
return nbytes;
}
TFile *TBranch::GetFile(Int_t mode)
{
if (fDirectory) return fDirectory->GetFile();
TFile *file = (TFile*)gROOT->GetListOfFiles()->FindObject(fFileName.Data());
if (file) {
fDirectory = (TDirectory*)file;
return file;
}
if (fFileName.Length() == 0) return 0;
TString bFileName = fFileName;
char *bname = gSystem->ExpandPathName(fFileName.Data());
if (!gSystem->IsAbsoluteFileName(bname) && !strstr(bname, ":/")) {
const char *tfn = fTree->GetCurrentFile()->GetName();
char *tname = gSystem->ExpandPathName(tfn);
if (gSystem->IsAbsoluteFileName(tname) || strstr(tname, ":/")) {
bFileName = gSystem->DirName(tname);
bFileName += "/";
bFileName += fFileName;
}
delete [] tname;
}
delete [] bname;
if (mode) file = TFile::Open(bFileName, "recreate");
else file = TFile::Open(bFileName);
if (file->IsZombie()) {delete file; return 0;}
fDirectory = (TDirectory*)file;
return file;
}
TLeaf *TBranch::GetLeaf(const char *name) const
{
Int_t i;
for (i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
if (!strcmp(leaf->GetName(),name)) return leaf;
}
return 0;
}
Int_t TBranch::GetRow(Int_t)
{
return 1;
}
TBranch *TBranch::GetMother() const
{
const TObjArray *array = fTree->GetListOfBranches();
Int_t n = array->GetEntriesFast();
for (Int_t i=0; i < n; ++i) {
TBranch *branch = (TBranch*)array->UncheckedAt(i);
TBranch *br = branch->GetSubBranch(this);
if (br) {
return branch;
}
}
return 0;
}
TBranch *TBranch::GetSubBranch(const TBranch *br) const
{
if (br == this) return (TBranch*)this;
Int_t len = fBranches.GetEntriesFast();
for(Int_t i = 0; i < len; ++i) {
TBranch *branch = (TBranch*)(fBranches.UncheckedAt( i ));
if (branch == 0) continue;
if (branch == br) return (TBranch*)this;
TBranch *br2 = branch->GetSubBranch(br);
if (br2) return br2;
}
return 0;
}
Long64_t TBranch::GetTotalSize() const
{
TBuffer b(TBuffer::kWrite,10000);
TBranch::Class()->WriteBuffer(b,(TBranch*)this);
Long64_t totbytes = 0;
if (fZipBytes > 0) totbytes = fTotBytes;
return totbytes + b.Length();
}
Bool_t TBranch::IsAutoDelete() const
{
return TestBit(kAutoDelete);
}
Bool_t TBranch::IsFolder() const
{
if (fNleaves > 1) return kTRUE;
TList* browsables=const_cast<TBranch*>(this)->GetBrowsables();
return (browsables && browsables->GetSize());
}
void TBranch::KeepCircular(Long64_t maxEntries)
{
Int_t dentries = (Int_t)(fEntries - maxEntries);
TBasket *basket = (TBasket*)fBaskets.UncheckedAt(0);
basket->MoveEntries(dentries);
fEntries = maxEntries;
fEntryNumber = maxEntries;
Int_t nb = fBranches.GetEntriesFast();
TBranch *branch;
for (Int_t i=0;i<nb;i++) {
branch = (TBranch*)fBranches.UncheckedAt(i);
branch->KeepCircular(maxEntries);
}
}
Int_t TBranch::LoadBaskets()
{
Int_t nimported = 0;
Int_t nbaskets = fBaskets.GetEntriesFast();
TFile *file = GetFile(0);
TBasket *basket;
gBranch = this;
for (Int_t i=0;i<nbaskets;i++) {
basket = (TBasket*)fBaskets.UncheckedAt(i);
if (basket) continue;
basket = new TBasket(file);
basket->SetBranch(this);
if (fBasketBytes[i] == 0) {
fBasketBytes[i] = basket->ReadBasketBytes(fBasketSeek[i],file);
}
Int_t badread = basket->ReadBasketBuffers(fBasketSeek[i],fBasketBytes[i],file);
if (badread) {
Error("Loadbaskets","Error while reading basket buffer %d of branch %s",i,GetName());
return -1;
}
fBaskets.AddAt(basket,i);
nimported++;
}
return nimported;
}
void TBranch::Print(Option_t *) const
{
const int kLINEND = 77;
Float_t cx = 1;
int aLength = strlen (GetTitle());
if (strcmp(GetName(),GetTitle()) == 0) aLength = 0;
int len = aLength;
aLength += (aLength / 54 + 1) * 80 + 100;
if (aLength < 200) aLength = 200;
char *bline = new char[aLength];
Long64_t totBytes = GetTotalSize();
if (fZipBytes) cx = (fTotBytes+0.00001)/fZipBytes;
if (len) sprintf(bline,"*Br%5d :%-9s : %-54s *",fgCount,GetName(),GetTitle());
else sprintf(bline,"*Br%5d :%-9s : %-54s *",fgCount,GetName()," ");
if (strlen(bline) > UInt_t(kLINEND)) {
char *tmp = new char[strlen(bline)+1];
if (len) strcpy(tmp, GetTitle());
sprintf(bline,"*Br%5d :%-9s : ",fgCount,GetName());
int pos = strlen (bline);
int npos = pos;
int beg=0, end;
while (beg < len) {
for (end=beg+1; end < len-1; end ++)
if (tmp[end] == ':') break;
if (npos + end-beg+1 >= 78) {
while (npos < kLINEND) {
bline[pos ++] = ' ';
npos ++;
}
bline[pos ++] = '*';
bline[pos ++] = '\n';
bline[pos ++] = '*';
npos = 1;
for (; npos < 12; npos ++)
bline[pos ++] = ' ';
bline[pos-2] = '|';
}
for (int n = beg; n <= end; n ++)
bline[pos+n-beg] = tmp[n];
pos += end-beg+1;
npos += end-beg+1;
beg = end+1;
}
while (npos < kLINEND) {
bline[pos ++] = ' ';
npos ++;
}
bline[pos ++] = '*';
bline[pos] = '\0';
delete[] tmp;
}
Printf(bline);
if (fTotBytes > 2000000000) {
Printf("*Entries :%lld : Total Size=%11lld bytes File Size = %lld *",fEntries,totBytes,fZipBytes);
} else {
if (fZipBytes > 0) {
Printf("*Entries :%9lld : Total Size=%11lld bytes File Size = %10lld *",fEntries,totBytes,fZipBytes);
} else {
if (fWriteBasket > 0) {
Printf("*Entries :%9lld : Total Size=%11lld bytes All baskets in memory *",fEntries,totBytes);
} else {
Printf("*Entries :%9lld : Total Size=%11lld bytes One basket in memory *",fEntries,totBytes);
}
}
}
Printf("*Baskets :%9d : Basket Size=%11d bytes Compression= %6.2f *",fWriteBasket,fBasketSize,cx);
Printf("*............................................................................*");
delete [] bline;
fgCount++;
}
void TBranch::ReadBasket(TBuffer &)
{
}
void TBranch::ReadLeaves(TBuffer &b)
{
for (Int_t i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
leaf->ReadBasket(b);
}
}
void TBranch::Refresh(TBranch *b)
{
fEntryOffsetLen = b->fEntryOffsetLen;
fWriteBasket = b->fWriteBasket;
fEntryNumber = b->fEntryNumber;
fMaxBaskets = b->fMaxBaskets;
fEntries = b->fEntries;
fTotBytes = b->fTotBytes;
fZipBytes = b->fZipBytes;
fReadBasket = 0;
fNBasketRAM = 0;
delete [] fBasketBytes;
delete [] fBasketEntry;
delete [] fBasketSeek;
fBasketBytes = new Int_t[fMaxBaskets];
fBasketEntry = new Long64_t[fMaxBaskets];
fBasketSeek = new Long64_t[fMaxBaskets];
Int_t i;
for (i=0;i<fMaxBaskets;i++) {
fBasketBytes[i] = b->fBasketBytes[i];
fBasketEntry[i] = b->fBasketEntry[i];
fBasketSeek[i] = b->fBasketSeek[i];
}
fBaskets.Delete();
Int_t nbaskets = b->fBaskets.GetSize();
fBaskets.Expand(nbaskets);
TBasket *basket = (TBasket*)b->fBaskets.UncheckedAt(fWriteBasket);
fBaskets.AddAt(basket,fWriteBasket);
b->fBaskets.RemoveAt(fWriteBasket);
basket->SetBranch(this);
}
void TBranch::Reset(Option_t *)
{
Int_t nbaskets = fBaskets.GetEntries();
fBaskets.Delete();
fReadBasket = 0;
fReadEntry = -1;
fWriteBasket = 0;
fEntries = 0;
fTotBytes = 0;
fZipBytes = 0;
fEntryNumber = 0;
for (Int_t i=0;i<fMaxBaskets;i++) {
if (fBasketBytes) fBasketBytes[i] = 0;
if (fBasketEntry) fBasketEntry[i] = 0;
if (fBasketSeek) fBasketSeek[i] = 0;
}
if (nbaskets) {
TBasket *basket = fTree->CreateBasket(this);
fBaskets.AddAt(basket,0);
}
}
void TBranch::ResetAddress()
{
fAddress = 0;
Int_t i;
for (i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
leaf->SetAddress(0);
}
Int_t nbranches = fBranches.GetEntriesFast();
for (i=0;i<nbranches;i++) {
TBranch *abranch = (TBranch*)fBranches[i];
abranch->ResetAddress();
}
}
void TBranch::SetAddress(void *add)
{
if (TestBit(kDoNotProcess)) return;
fReadEntry = -1;
fAddress = (char*)add;
Int_t i,offset;
for (i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
offset = leaf->GetOffset();
if (TestBit(kIsClone)) offset = 0;
leaf->SetAddress(fAddress+offset);
}
}
void TBranch::SetAutoDelete(Bool_t autodel)
{
if (autodel) SetBit(kAutoDelete,1);
else SetBit(kAutoDelete,0);
}
void TBranch::SetBasketSize(Int_t buffsize)
{
if (buffsize < 100+fEntryOffsetLen) buffsize = 100+fEntryOffsetLen;
fBasketSize = buffsize;
}
void TBranch::SetBufferAddress(TBuffer *buf)
{
if ( (fNleaves != 1)
|| (strcmp("TLeafObject",fLeaves.UncheckedAt(0)->ClassName())!=0) ) {
Error("TBranch::SetAddress","Filling from a TBuffer can only be done with a not split object branch. Request ignored.");
} else {
fReadEntry = -1;
fEntryBuffer = buf;
}
}
void TBranch::SetCompressionLevel(Int_t level)
{
fCompress = level;
Int_t nb = fBranches.GetEntriesFast();
for (Int_t i=0;i<nb;i++) {
TBranch *branch = (TBranch*)fBranches.UncheckedAt(i);
branch->SetCompressionLevel(level);
}
}
void TBranch::SetEntries(Long64_t entries)
{
fEntries = entries;
fEntryNumber = entries;
}
void TBranch::SetFile(TFile *file)
{
if (file == 0) file = fTree->GetCurrentFile();
fDirectory = (TDirectory*)file;
if (file == fTree->GetCurrentFile()) fFileName = "";
else fFileName = file->GetName();
TIter nextb(GetListOfBaskets());
TBasket *basket;
while ((basket = (TBasket*)nextb())) {
basket->SetParent(file);
}
TIter next(GetListOfBranches());
TBranch *branch;
while ((branch = (TBranch*)next())) {
branch->SetFile(file);
}
}
void TBranch::SetFile(const char *fname)
{
fFileName = fname;
fDirectory = 0;
TIter next(GetListOfBranches());
TBranch *branch;
while ((branch = (TBranch*)next())) {
branch->SetFile(fname);
}
}
void TBranch::Streamer(TBuffer &b)
{
if (b.IsReading()) {
UInt_t R__s, R__c;
fTree = gTree;
fAddress = 0;
gROOT->SetReadingObject(kTRUE);
Version_t v = b.ReadVersion(&R__s, &R__c);
if (v > 9) {
TBranch::Class()->ReadBuffer(b, this, v, R__s, R__c);
fDirectory = gDirectory;
if (fFileName.Length() != 0) fDirectory = 0;
fNleaves = fLeaves.GetEntriesFast();
for (Int_t i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
leaf->SetBranch(this);
}
if (!fSplitLevel && fBranches.GetEntriesFast()) fSplitLevel = 1;
gROOT->SetReadingObject(kFALSE);
return;
}
if (v > 5) {
Int_t i,ijunk;
Stat_t djunk;
TNamed::Streamer(b);
if (v > 7) TAttFill::Streamer(b);
b >> fCompress;
b >> fBasketSize;
b >> fEntryOffsetLen;
b >> fWriteBasket;
b >> ijunk; fEntryNumber = (Long64_t)ijunk;
b >> fOffset;
b >> fMaxBaskets;
if (v > 6) b >> fSplitLevel;
b >> djunk; fEntries = (Long64_t)djunk;
b >> djunk; fTotBytes = (Long64_t)djunk;
b >> djunk; fZipBytes = (Long64_t)djunk;
fBranches.Streamer(b);
gBranch = this;
fLeaves.Streamer(b);
fBaskets.Streamer(b);
fBasketBytes = new Int_t[fMaxBaskets];
fBasketEntry = new Long64_t[fMaxBaskets];
fBasketSeek = new Long64_t[fMaxBaskets];
Char_t isArray;
b >> isArray;
b.ReadFastArray(fBasketBytes,fMaxBaskets);
b >> isArray;
for (i=0;i<fMaxBaskets;i++) {b >> ijunk; fBasketEntry[i] = ijunk;}
b >> isArray;
for (i=0;i<fMaxBaskets;i++) {
if (isArray == 2) b >> fBasketSeek[i];
else {Int_t bsize; b >> bsize; fBasketSeek[i] = (Long64_t)bsize;};
}
fFileName.Streamer(b);
b.CheckByteCount(R__s, R__c, TBranch::IsA());
fDirectory = gDirectory;
if (fFileName.Length() != 0) fDirectory = 0;
fNleaves = fLeaves.GetEntriesFast();
for (i=0;i<fNleaves;i++) {
TLeaf *leaf = (TLeaf*)fLeaves.UncheckedAt(i);
leaf->SetBranch(this);
}
if (!fSplitLevel && fBranches.GetEntriesFast()) fSplitLevel = 1;
gROOT->SetReadingObject(kFALSE);
b.CheckByteCount(R__s, R__c, TBranch::IsA());
return;
}
Int_t n,i,ijunk;
Stat_t djunk;
TNamed::Streamer(b);
b >> fCompress;
b >> fBasketSize;
b >> fEntryOffsetLen;
b >> fMaxBaskets;
b >> fWriteBasket;
b >> ijunk; fEntryNumber = (Long64_t)ijunk;
b >> djunk; fEntries = (Long64_t)djunk;
b >> djunk; fTotBytes = (Long64_t)djunk;
b >> djunk; fZipBytes = (Long64_t)djunk;
b >> fOffset;
fBranches.Streamer(b);
gBranch = this;
fLeaves.Streamer(b);
fBaskets.Streamer(b);
fNleaves = fLeaves.GetEntriesFast();
fBasketEntry = new Long64_t[fMaxBaskets];
b >> n;
for (i=0;i<n;i++) {b >> ijunk; fBasketEntry[i] = ijunk;}
fBasketBytes = new Int_t[fMaxBaskets];
if (v > 4) {
n = b.ReadArray(fBasketBytes);
} else {
for (n=0;n<fMaxBaskets;n++) fBasketBytes[n] = 0;
}
if (v < 2) {
fBasketSeek = new Long64_t[fMaxBaskets];
for (n=0;n<fWriteBasket;n++) {
fBasketSeek[n] = GetBasket(n)->GetSeekKey();
}
} else {
fBasketSeek = new Long64_t[fMaxBaskets];
b >> n;
for (n=0;n<fMaxBaskets;n++) {
Int_t aseek;
b >> aseek;
fBasketSeek[n] = Long64_t(aseek);
}
}
fDirectory = gDirectory;
if (v > 2) {
fFileName.Streamer(b);
if (fFileName.Length() != 0) fDirectory = 0;
}
if (v < 4) SetAutoDelete(kTRUE);
if (!fSplitLevel && fBranches.GetEntriesFast()) fSplitLevel = 1;
gROOT->SetReadingObject(kFALSE);
b.CheckByteCount(R__s, R__c, TBranch::IsA());
} else {
Int_t maxBaskets = fMaxBaskets;
fMaxBaskets = fBaskets.GetEntriesFast();
if (fMaxBaskets < 10) fMaxBaskets=10;
TBranch::Class()->WriteBuffer(b,this);
fMaxBaskets = maxBaskets;
}
}
void TBranch::WriteBasket(TBasket* basket)
{
Int_t nout = basket->WriteBuffer();
fBasketBytes[fWriteBasket] = basket->GetNbytes();
fBasketSeek[fWriteBasket] = basket->GetSeekKey();
Int_t addbytes = basket->GetObjlen() + basket->GetKeylen() ;
if (fDirectory != gROOT && fDirectory->IsWritable()) {
delete basket;
fBaskets[fWriteBasket] = 0;
}
fZipBytes += nout;
fTotBytes += addbytes;
fTree->AddTotBytes(addbytes);
fTree->AddZipBytes(nout);
basket = fTree->CreateBasket(this);
fWriteBasket++;
fBaskets.AddAtAndExpand(basket,fWriteBasket);
if (fWriteBasket >= fMaxBaskets) {
ExpandBasketArrays();
}
fBasketEntry[fWriteBasket] = fEntryNumber;
}
ROOT page - Class index - Class Hierarchy - Top of the page
This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.