#include "Riostream.h"
#include "Strlen.h"
#include "TDirectory.h"
#include "TFile.h"
#include "TMapFile.h"
#include "TClassTable.h"
#include "TInterpreter.h"
#include "THashList.h"
#include "TBrowser.h"
#include "TFree.h"
#include "TKey.h"
#include "TROOT.h"
#include "TError.h"
#include "Bytes.h"
#include "TClass.h"
#include "TRegexp.h"
#include "TProcessUUID.h"
#include "TVirtualMutex.h"
TDirectory *gDirectory;
const UInt_t kIsBigFile = BIT(16);
const Int_t kMaxLen = 2048;
//Begin_Html
/*
<img src="gif/tdirectory_classtree.gif">
*/
//End_Html
ClassImp(TDirectory)
//Begin_Html
/*
<img src="gif/fildir.gif">
*/
//End_Html
TDirectory::TDirectory() : TNamed(), fMother(0)
{
fFile = 0;
fList = 0;
fKeys = 0;
fWritable = kFALSE;
fBufferSize = 0;
}
TDirectory::TDirectory(const char *name, const char *title, Option_t *classname, TDirectory* initMotherDir)
: TNamed(name, title), fMother(0)
{
if (initMotherDir==0) initMotherDir = gDirectory;
if (strchr(name,'/')) {
::Error("TDirectory::TDirectory","directory name (%s) cannot contain a slash", name);
gDirectory = 0;
return;
}
if (strlen(GetName()) == 0) {
::Error("TDirectory::TDirectory","directory name cannot be \"\"");
gDirectory = 0;
return;
}
Build(initMotherDir ? initMotherDir->GetFile() : 0, initMotherDir);
TDirectory* motherdir = GetMotherDir();
TFile* f = GetFile();
if ((motherdir==0) || (f==0)) return;
if (!f->IsWritable()) return;
if (motherdir->GetKey(name)) {
Error("TDirectory","An object with name %s exists already", name);
return;
}
TClass *cl = IsA();
if (strlen(classname) != 0) cl = gROOT->GetClass(classname);
if (!cl) {
Error("TDirectory","Invalid class name: %s",classname);
return;
}
fBufferSize = 0;
fWritable = kTRUE;
if (f->IsBinary()) {
fSeekParent = f->GetSeekDir();
Int_t nbytes = TDirectory::Sizeof();
TKey *key = new TKey(fName,fTitle,cl,nbytes,motherdir);
fNbytesName = key->GetKeylen();
fSeekDir = key->GetSeekKey();
if (fSeekDir == 0) return;
char *buffer = key->GetBuffer();
TDirectory::FillBuffer(buffer);
Int_t cycle = motherdir->AppendKey(key);
key->WriteFile(cycle);
} else {
fSeekParent = 0;
fNbytesName = 0;
fSeekDir = f->DirCreateEntry(this);
if (fSeekDir == 0) return;
}
fModified = kFALSE;
R__LOCKGUARD2(gROOTMutex);
gROOT->GetUUIDs()->AddUUID(fUUID,this);
}
TDirectory::TDirectory(const TDirectory &directory) : TNamed(directory)
{
((TDirectory&)directory).Copy(*this);
}
TDirectory::~TDirectory()
{
if (!gROOT) {
return;
}
if (fList) {
fList->Delete("slow");
SafeDelete(fList);
}
if (fKeys) {
fKeys->Delete("slow");
SafeDelete(fKeys);
}
if (gDirectory == this) {
if (gFile != this) {
gFile->cd();
} else {
gDirectory = gROOT;
gFile = 0;
}
}
TDirectory* mom = GetMotherDir();
if (mom) {
mom->GetList()->Remove(this);
}
if (gDebug) {
Info("~TDirectory", "dtor called for %s", GetName());
}
}
void TDirectory::Append(TObject *obj)
{
if (obj == 0 || fList == 0) return;
fList->Add(obj);
obj->SetBit(kMustCleanup);
if (!fMother) return;
if (fMother->IsA() == TMapFile::Class()) {
TMapFile *mfile = (TMapFile*)fMother;
mfile->Add(obj);
}
}
Int_t TDirectory::AppendKey(TKey *key)
{
fModified = kTRUE;
key->SetMotherDir(this);
TKey *oldkey = (TKey*)fKeys->FindObject(key->GetName());
if (!oldkey) {
fKeys->Add(key);
return 1;
}
TObjLink *lnk = fKeys->FirstLink();
while (lnk) {
oldkey = (TKey*)lnk->GetObject();
if (!strcmp(oldkey->GetName(), key->GetName()))
break;
lnk = lnk->Next();
}
fKeys->AddBefore(lnk, key);
return oldkey->GetCycle() + 1;
}
void TDirectory::Browse(TBrowser *b)
{
Char_t name[kMaxLen];
if (b) {
TObject *obj = 0;
TIter nextin(fList);
TKey *key = 0, *keyo = 0;
TIter next(fKeys);
cd();
while ((obj = nextin())) {
if (fKeys->FindObject(obj->GetName())) continue;
b->Add(obj, obj->GetName());
}
while ((key = (TKey *) next())) {
int skip = 0;
if (!keyo || (keyo && strcmp(keyo->GetName(), key->GetName()))) {
skip = 0;
obj = fList->FindObject(key->GetName());
if (obj) {
sprintf(name, "%s", obj->GetName());
b->Add(obj, name);
if (obj->IsFolder()) skip = 1;
}
}
if (!skip) {
sprintf(name, "%s;%d", key->GetName(), key->GetCycle());
b->Add(key, name);
}
keyo = key;
}
}
}
void TDirectory::Build(TFile* motherFile, TDirectory* motherDir)
{
if (motherDir && strlen(GetName()) != 0) motherDir->Append(this);
fModified = kTRUE;
fWritable = kFALSE;
fDatimeC.Set();
fDatimeM.Set();
fNbytesKeys = 0;
fSeekDir = 0;
fSeekParent = 0;
fSeekKeys = 0;
fList = new THashList(100,50);
fKeys = new THashList(100,50);
fMother = motherDir;
fFile = motherFile ? motherFile : gFile;
SetBit(kCanDelete);
}
TDirectory *TDirectory::GetDirectory(const char *apath,
Bool_t printError, const char *funcname)
{
Int_t nch = 0;
if (apath) nch = strlen(apath);
if (!nch) {
return this;
}
if (funcname==0 || strlen(funcname)==0) funcname = "GetDirectory";
TDirectory *result = this;
char *path = new char[nch+1]; path[0] = 0;
if (nch) strcpy(path,apath);
char *s = (char*)strchr(path, ':');
if (s) {
*s = '\0';
R__LOCKGUARD2(gROOTMutex);
TDirectory *f = (TDirectory *)gROOT->GetListOfFiles()->FindObject(path);
if (!f && !strcmp(gROOT->GetName(), path)) f = gROOT;
if (s) *s = ':';
if (f) {
result = f;
if (s && *(s+1)) result = f->GetDirectory(s+1,printError,funcname);
delete [] path; return result;
} else {
if (printError) Error(funcname, "No such file %s", path);
delete [] path; return 0;
}
}
if (path[0] == '/') {
TDirectory *td = fFile;
if (!fFile) td = gROOT;
result = td->GetDirectory(path+1,printError,funcname);
delete [] path; return result;
}
TObject *obj;
char *slash = (char*)strchr(path,'/');
if (!slash) {
if (!strcmp(path, "..")) {
result = GetMotherDir();
delete [] path; return result;
}
obj = Get(path);
if (!obj) {
if (printError) Error(funcname,"Unknown directory %s", path);
delete [] path; return 0;
}
if (!obj->InheritsFrom(TDirectory::Class())) {
if (printError) Error(funcname,"Object %s is not a directory", path);
delete [] path; return 0;
}
delete [] path; return (TDirectory*)obj;
}
char subdir[kMaxLen];
strcpy(subdir,path);
slash = (char*)strchr(subdir,'/');
*slash = 0;
if (!strcmp(subdir, "..")) {
TDirectory* mom = GetMotherDir();
if (mom)
result = mom->GetDirectory(slash+1,printError,funcname);
delete [] path; return result;
}
obj = Get(subdir);
if (!obj) {
if (printError) Error(funcname,"Unknown directory %s", subdir);
delete [] path; return 0;
}
if (!obj->InheritsFrom(TDirectory::Class())) {
if (printError) Error(funcname,"Object %s is not a directory", subdir);
delete [] path; return 0;
}
result = ((TDirectory*)obj)->GetDirectory(slash+1,printError,funcname);
delete [] path; return result;
}
Bool_t TDirectory::cd(const char *path)
{
return cd1(path);
}
Bool_t TDirectory::cd1(const char *apath)
{
Int_t nch = 0;
if (apath) nch = strlen(apath);
if (!nch) {
gDirectory = this;
gFile = GetFile();
return kTRUE;
}
TDirectory *where = GetDirectory(apath,kTRUE,"cd");
if (where) {
where->cd();
return kTRUE;
}
return kFALSE;
}
Bool_t TDirectory::Cd(const char *path)
{
return Cd1(path);
}
Bool_t TDirectory::Cd1(const char *apath)
{
Int_t nch = 0;
if (apath) nch = strlen(apath);
if (!nch) return kTRUE;
TDirectory *where = gDirectory->GetDirectory(apath,kTRUE,"Cd");
if (where) {
where->cd();
return kTRUE;
}
return kFALSE;
}
void TDirectory::Clear(Option_t *)
{
if (fList) fList->Clear();
}
void TDirectory::Close(Option_t *)
{
if (!fList) {
return;
}
Save();
Bool_t fast = kTRUE;
TObjLink *lnk = fList->FirstLink();
while (lnk) {
if (lnk->GetObject()->IsA() == TDirectory::Class()) {fast = kFALSE;break;}
lnk = lnk->Next();
}
if (fast) fList->Delete();
else fList->Delete("slow");
if (fKeys) {
fKeys->Delete("slow");
}
if (gDirectory == this) {
TDirectory *cursav = GetMotherDir();
if (cursav && cursav != this) {
cursav->cd();
} else {
gFile = 0;
if (this == gROOT) {
gDirectory = 0;
} else {
gDirectory = gROOT;
}
}
}
}
void TDirectory::DeleteAll(Option_t *)
{
fList->Delete("slow");
}
void TDirectory::Delete(const char *namecycle)
{
if (gDebug)
Info("Delete","Call for this = %s namecycle = %s",
GetName(), (namecycle ? namecycle : "null"));
TDirectory::TContext ctxt(gDirectory, this);
Short_t cycle;
char name[kMaxLen];
DecodeNameCycle(namecycle, name, cycle);
Int_t deleteall = 0;
Int_t deletetree = 0;
if(strcmp(name,"*") == 0) deleteall = 1;
if(strcmp(name,"*T") == 0){ deleteall = 1; deletetree = 1;}
if(strcmp(name,"T*") == 0){ deleteall = 1; deletetree = 1;}
if(strlen(namecycle) == 0){ deleteall = 1; deletetree = 1;}
TRegexp re(name,kTRUE);
TString s;
Int_t deleteOK = 0;
if (cycle >= 9999 ) {
TNamed *idcur;
TIter next(fList);
while ((idcur = (TNamed *) next())) {
deleteOK = 0;
s = idcur->GetName();
if (deleteall || s.Index(re) != kNPOS) {
deleteOK = 1;
if (idcur->IsA() == TDirectory::Class()) {
deleteOK = 2;
if (!deletetree && deleteall) deleteOK = 0;
}
}
if (deleteOK != 0) {
fList->Remove(idcur);
if (deleteOK==2) {
if (deletetree)
((TDirectory*) idcur)->ReadAll("dirs");
idcur->Delete(deletetree ? "T*;*" : "*");
delete idcur;
} else
idcur->Delete(name);
}
}
}
if (cycle != 9999 ) {
if (IsWritable()) {
TKey *key;
TIter nextkey(GetListOfKeys());
while ((key = (TKey *) nextkey())) {
deleteOK = 0;
s = key->GetName();
if (deleteall || s.Index(re) != kNPOS) {
if (cycle == key->GetCycle()) deleteOK = 1;
if (cycle > 9999) deleteOK = 1;
if (!strcmp(key->GetClassName(),"TDirectory")) {
deleteOK = 2;
if (!deletetree && deleteall) deleteOK = 0;
if (cycle == key->GetCycle()) deleteOK = 2;
}
}
if (deleteOK) {
if (deleteOK==2) {
TDirectory* dir = GetDirectory(key->GetName(), kTRUE, "Delete");
if (dir!=0) {
dir->Delete("T*;*");
fList->Remove(dir);
delete dir;
}
}
key->Delete();
fKeys->Remove(key);
fModified = kTRUE;
delete key;
}
}
TFile* f = GetFile();
if (fModified && (f!=0)) {
WriteKeys();
WriteDirHeader();
f->WriteFree();
f->WriteHeader();
}
}
}
}
void TDirectory::Draw(Option_t *option)
{
fList->R__FOR_EACH(TObject,Draw)(option);
}
void TDirectory::FillBuffer(char *&buffer)
{
Version_t version = TDirectory::Class_Version();
if (fSeekKeys > TFile::kStartBigFile) version += 1000;
tobuf(buffer, version);
fDatimeC.FillBuffer(buffer);
fDatimeM.FillBuffer(buffer);
tobuf(buffer, fNbytesKeys);
tobuf(buffer, fNbytesName);
if (version > 1000) {
tobuf(buffer, fSeekDir);
tobuf(buffer, fSeekParent);
tobuf(buffer, fSeekKeys);
} else {
tobuf(buffer, (Int_t)fSeekDir);
tobuf(buffer, (Int_t)fSeekParent);
tobuf(buffer, (Int_t)fSeekKeys);
}
fUUID.FillBuffer(buffer);
if (fFile && fFile->GetVersion() < 40000) return;
if (version <=1000) for (Int_t i=0;i<3;i++) tobuf(buffer,Int_t(0));
}
TKey *TDirectory::FindKey(const char *keyname) const
{
Short_t cycle;
char name[kMaxLen];
DecodeNameCycle(keyname, name, cycle);
return GetKey(name,cycle);
}
TKey *TDirectory::FindKeyAny(const char *keyname) const
{
TDirectory *dirsav = gDirectory;
Short_t cycle;
char name[kMaxLen];
DecodeNameCycle(keyname, name, cycle);
TIter next(GetListOfKeys());
TKey *key;
while ((key = (TKey *) next())) {
if (!strcmp(name, key->GetName()))
if ((cycle == 9999) || (cycle >= key->GetCycle())) {
((TDirectory*)this)->cd();
return key;
}
}
next.Reset();
while ((key = (TKey *) next())) {
if (!strcmp(key->GetClassName(),"TDirectory")) {
TDirectory* subdir =
((TDirectory*)this)->GetDirectory(key->GetName(), kTRUE, "FindKeyAny");
TKey *k = (subdir!=0) ? subdir->FindKeyAny(keyname) : 0;
if (k) return k;
}
}
if (dirsav) dirsav->cd();
return 0;
}
TObject *TDirectory::FindObject(const TObject *obj) const
{
return fList->FindObject(obj);
}
TObject *TDirectory::FindObject(const char *name) const
{
return fList->FindObject(name);
}
TObject *TDirectory::FindObjectAny(const char *aname) const
{
TObject *obj = fList->FindObject(aname);
if (obj) return obj;
TDirectory *dirsav = gDirectory;
Short_t cycle;
char name[kMaxLen];
DecodeNameCycle(aname, name, cycle);
TIter next(GetListOfKeys());
TKey *key;
while ((key = (TKey *) next())) {
if (!strcmp(name, key->GetName())) {
if (cycle == 9999) return key->ReadObj();
if (cycle >= key->GetCycle()) return key->ReadObj();
}
}
next.Reset();
while ((key = (TKey *) next())) {
if (!strcmp(key->GetClassName(),"TDirectory")) {
TDirectory* subdir =
((TDirectory*)this)->GetDirectory(key->GetName(), kTRUE, "FindKeyAny");
TKey *k = subdir==0 ? 0 : subdir->FindKeyAny(aname);
if (k) { if (dirsav) dirsav->cd(); return k->ReadObj();}
}
}
if (dirsav) dirsav->cd();
return 0;
}
TObject *TDirectory::Get(const char *namecycle)
{
Short_t cycle;
char name[kMaxLen];
DecodeNameCycle(namecycle, name, cycle);
char *namobj = name;
Int_t nch = strlen(name);
for (Int_t i = nch-1; i > 0; i--) {
if (name[i] == '/') {
name[i] = 0;
TDirectory* dirToSearch=GetDirectory(name);
namobj = name + i + 1;
name[i] = '/';
return dirToSearch?dirToSearch->Get(namobj):0;
}
}
TObject *idcur = fList->FindObject(namobj);
if (idcur) {
if (idcur==this && strlen(namobj)!=0) {
idcur = 0;
} else if (cycle == 9999) {
return idcur;
} else {
if (idcur->InheritsFrom(TCollection::Class()))
idcur->Delete();
delete idcur;
idcur = 0;
}
}
TKey *key;
TIter nextkey(GetListOfKeys());
while ((key = (TKey *) nextkey())) {
if (strcmp(namobj,key->GetName()) == 0) {
if ((cycle == 9999) || (cycle == key->GetCycle())) {
TDirectory::TContext ctxt(this);
idcur = key->ReadObj();
break;
}
}
}
return idcur;
}
void *TDirectory::GetObjectUnchecked(const char *namecycle)
{
return GetObjectChecked(namecycle,(TClass*)0);
}
void *TDirectory::GetObjectChecked(const char *namecycle, const char* classname)
{
return GetObjectChecked(namecycle,ROOT::GetROOT()->GetClass(classname));
}
void *TDirectory::GetObjectChecked(const char *namecycle, const TClass* expectedClass)
{
Short_t cycle;
char name[kMaxLen];
DecodeNameCycle(namecycle, name, cycle);
char *namobj = name;
Int_t nch = strlen(name);
for (Int_t i = nch-1; i > 0; i--) {
if (name[i] == '/') {
name[i] = 0;
TDirectory* dirToSearch=GetDirectory(name);
namobj = name + i + 1;
name[i] = '/';
if (dirToSearch) {
return dirToSearch->GetObjectChecked(namobj, expectedClass);
} else {
return 0;
}
}
}
if (expectedClass==0 || expectedClass->InheritsFrom(TObject::Class())) {
TObject *objcur = fList->FindObject(namobj);
if (objcur) {
if (objcur==this && strlen(namobj)!=0) {
objcur = 0;
} else if (cycle == 9999) {
if (expectedClass && objcur->IsA()->GetBaseClassOffset(expectedClass) == -1) return 0;
else return objcur;
} else {
if (objcur->InheritsFrom(TCollection::Class()))
objcur->Delete();
delete objcur;
objcur = 0;
}
}
}
void *idcur = 0;
TKey *key;
TIter nextkey(GetListOfKeys());
while ((key = (TKey *) nextkey())) {
if (strcmp(namobj,key->GetName()) == 0) {
if ((cycle == 9999) || (cycle == key->GetCycle())) {
TDirectory::TContext ctxt(this);
idcur = key->ReadObjectAny(expectedClass);
break;
}
}
}
return idcur;
}
Int_t TDirectory::GetBufferSize() const
{
if (fBufferSize <= 0) return fFile->GetBestBuffer();
else return fBufferSize;
}
TKey *TDirectory::GetKey(const char *name, Short_t cycle) const
{
TKey *key;
TIter next(GetListOfKeys());
while ((key = (TKey *) next()))
if (!strcmp(name, key->GetName())) {
if (cycle == 9999) return key;
if (cycle >= key->GetCycle()) return key;
}
return 0;
}
const char *TDirectory::GetPathStatic() const
{
static char *path = 0;
const int kMAXDEPTH = 128;
const TDirectory *d[kMAXDEPTH];
const TDirectory *cur = this;
int depth = 0, len = 0;
d[depth++] = cur;
len = strlen(cur->GetName()) + 1;
while (cur->fMother && depth < kMAXDEPTH) {
cur = (TDirectory *)cur->fMother;
d[depth++] = cur;
len += strlen(cur->GetName()) + 1;
}
if (path) delete [] path;
path = new char[len+2];
for (int i = depth-1; i >= 0; i--) {
if (i == depth-1) {
strcpy(path, d[i]->GetName());
strcat(path, ":");
if (i == 0) strcat(path, "/");
} else {
strcat(path, "/");
strcat(path, d[i]->GetName());
}
}
return path;
}
const char *TDirectory::GetPath() const
{
TString* buf = &(const_cast<TDirectory*>(this)->fPathBuffer);
FillFullPath(*buf);
if (GetMotherDir()==0)
buf->Append("/");
return buf->Data();
}
void TDirectory::FillFullPath(TString& buf) const
{
TDirectory* mom = GetMotherDir();
if (mom!=0) {
mom->FillFullPath(buf);
buf += "/";
buf += GetName();
} else {
buf = GetName();
buf +=":";
}
}
TDirectory *TDirectory::mkdir(const char *name, const char *title)
{
if (!name || !title || !strlen(name)) return 0;
if (!strlen(title)) title = name;
if (strchr(name,'/')) {
::Error("TDirectory::mkdir","directory name (%s) cannot contain a slash", name);
return 0;
}
if (GetKey(name)) {
Error("mkdir","An object with name %s exists already",name);
return 0;
}
TDirectory::TContext ctxt(this);
TDirectory *newdir = new TDirectory(name, title, "", this);
return newdir;
}
void TDirectory::ls(Option_t *option) const
{
TROOT::IndentLevel();
cout <<ClassName()<<"*\t\t"<<GetName()<<"\t"<<GetTitle()<<endl;
TROOT::IncreaseDirLevel();
TString opta = option;
TString opt = opta.Strip(TString::kBoth);
Bool_t memobj = kTRUE;
Bool_t diskobj = kTRUE;
TString reg = "*";
if (opt.BeginsWith("-m")) {
diskobj = kFALSE;
if (opt.Length() > 2)
reg = opt(2,opt.Length());
} else if (opt.BeginsWith("-d")) {
memobj = kFALSE;
if (opt.Length() > 2)
reg = opt(2,opt.Length());
} else if (!opt.IsNull())
reg = opt;
TRegexp re(reg, kTRUE);
if (memobj) {
TObject *obj;
TIter nextobj(fList);
while ((obj = (TObject *) nextobj())) {
TString s = obj->GetName();
if (s.Index(re) == kNPOS) continue;
obj->ls(option);
}
}
if (diskobj) {
TKey *key;
TIter next(GetListOfKeys());
while ((key = (TKey *) next())) {
TString s = key->GetName();
if (s.Index(re) == kNPOS) continue;
key->ls();
}
}
TROOT::DecreaseDirLevel();
}
void TDirectory::Paint(Option_t *option)
{
fList->R__FOR_EACH(TObject,Paint)(option);
}
void TDirectory::Print(Option_t *option) const
{
fList->R__FOR_EACH(TObject,Print)(option);
}
void TDirectory::Purge(Short_t)
{
if (!IsWritable()) return;
TDirectory::TContext ctxt(this);
TKey *key;
TIter prev(GetListOfKeys(), kIterBackward);
while ((key = (TKey*)prev())) {
TKey *keyprev = (TKey*)GetListOfKeys()->Before(key);
if (!keyprev) break;
if (key->GetKeep() == 0) {
if (strcmp(key->GetName(), keyprev->GetName()) == 0) key->Delete();
}
}
TFile* f = GetFile();
if (fModified && (f!=0)) {
WriteKeys();
WriteDirHeader();
f->WriteFree();
f->WriteHeader();
}
}
void TDirectory::pwd() const
{
Printf("%s", GetPath());
}
void TDirectory::ReadAll(Option_t* opt)
{
TDirectory::TContext ctxt(this);
TKey *key;
TIter next(GetListOfKeys());
Bool_t readdirs = ((opt!=0) && ((strcmp(opt,"dirs")==0) || (strcmp(opt,"dirs*")==0)));
if (readdirs)
while ((key = (TKey *) next())) {
if (strcmp(key->GetClassName(),"TDirectory")!=0) continue;
TDirectory *dir = GetDirectory(key->GetName(), kTRUE, "ReadAll");
if ((dir!=0) && (strcmp(opt,"dirs*")==0)) dir->ReadAll("dirs*");
}
else
while ((key = (TKey *) next())) {
TObject *thing = GetList()->FindObject(key->GetName());
if (thing) { delete thing; }
thing = key->ReadObj();
}
}
Int_t TDirectory::ReadKeys()
{
if (fFile==0) return 0;
if (!fFile->IsBinary())
return fFile->DirReadKeys(this);
TDirectory::TContext ctxt(this);
fKeys->Delete();
Int_t nbytes = fNbytesName + TDirectory::Sizeof();
char *header = new char[nbytes];
char *buffer = header;
fFile->Seek(fSeekDir);
fFile->ReadBuffer(buffer,nbytes);
buffer += fNbytesName;
Version_t versiondir;
frombuf(buffer,&versiondir);
fDatimeC.ReadBuffer(buffer);
fDatimeM.ReadBuffer(buffer);
frombuf(buffer, &fNbytesKeys);
frombuf(buffer, &fNbytesName);
if (versiondir > 1000) {
frombuf(buffer, &fSeekDir);
frombuf(buffer, &fSeekParent);
frombuf(buffer, &fSeekKeys);
} else {
Int_t sdir,sparent,skeys;
frombuf(buffer, &sdir); fSeekDir = (Long64_t)sdir;
frombuf(buffer, &sparent); fSeekParent = (Long64_t)sparent;
frombuf(buffer, &skeys); fSeekKeys = (Long64_t)skeys;
}
delete [] header;
Int_t nkeys = 0;
Long64_t fsize = fFile->GetSize();
if ( fSeekKeys > 0) {
TKey *headerkey = new TKey(fSeekKeys, fNbytesKeys, this);
headerkey->ReadFile();
buffer = headerkey->GetBuffer();
headerkey->ReadKeyBuffer(buffer);
TKey *key;
frombuf(buffer, &nkeys);
for (Int_t i = 0; i < nkeys; i++) {
key = new TKey(this);
key->ReadKeyBuffer(buffer);
if (key->GetSeekKey() < 64 || key->GetSeekKey() > fsize) {
Error("ReadKeys","reading illegal key, exiting after %d keys",i);
fKeys->Remove(key);
nkeys = i;
break;
}
if (key->GetSeekPdir() < 64 || key->GetSeekPdir() > fsize) {
Error("ReadKeys","reading illegal key, exiting after %d keys",i);
fKeys->Remove(key);
nkeys = i;
break;
}
fKeys->Add(key);
}
delete headerkey;
}
return nkeys;
}
void TDirectory::RecursiveRemove(TObject *obj)
{
fList->RecursiveRemove(obj);
}
void TDirectory::rmdir(const char *name)
{
if ((name==0) || (*name==0)) return;
TString mask(name);
mask+=";*";
Delete(mask);
}
void TDirectory::Save()
{
TDirectory::TContext ctxt(this);
SaveSelf();
if (fList) {
TObject *idcur;
TIter next(fList);
while ((idcur = next())) {
if (idcur->InheritsFrom(TDirectory::Class())) {
TDirectory *dir = (TDirectory*)idcur;
dir->Save();
}
}
}
}
void TDirectory::SaveSelf(Bool_t force)
{
if (IsWritable() && (fModified || force) && fFile) {
Bool_t dowrite = kTRUE;
if (fFile->GetListOfFree())
dowrite = fFile->GetListOfFree()->First() != 0;
if (dowrite) {
TDirectory *dirsav = gDirectory;
if (dirsav != this) cd();
WriteKeys();
WriteDirHeader();
if (dirsav && dirsav != this) dirsav->cd();
}
}
}
void TDirectory::SetBufferSize(Int_t bufsize)
{
fBufferSize = bufsize;
}
void TDirectory::SetName(const char* newname)
{
TNamed::SetName(newname);
}
void TDirectory::SetWritable(Bool_t writable)
{
TDirectory::TContext ctxt(this);
fWritable = writable;
if (fList) {
TObject *idcur;
TIter next(fList);
while ((idcur = next())) {
if (idcur->InheritsFrom(TDirectory::Class())) {
TDirectory *dir = (TDirectory*)idcur;
dir->SetWritable(writable);
}
}
}
}
Int_t TDirectory::Sizeof() const
{
Int_t nbytes = 22;
nbytes += fDatimeC.Sizeof();
nbytes += fDatimeM.Sizeof();
nbytes += fUUID.Sizeof();
if (fFile && fFile->GetVersion() >= 40000) nbytes += 12;
return nbytes;
}
void TDirectory::Streamer(TBuffer &b)
{
Version_t v,version;
if (b.IsReading()) {
Build((TFile*)b.GetParent(), 0);
if (fFile && fFile->IsWritable()) fWritable = kTRUE;
if (fFile && !fFile->IsBinary()) {
Version_t R__v = b.ReadVersion(0, 0);
b.ClassBegin(TDirectory::Class(), R__v);
TString sbuf;
b.ClassMember("CreateTime","TString");
sbuf.Streamer(b);
TDatime timeC(sbuf.Data());
fDatimeC = timeC;
b.ClassMember("ModifyTime","TString");
sbuf.Streamer(b);
TDatime timeM(sbuf.Data());
fDatimeM = timeM;
b.ClassMember("UUID","TString");
sbuf.Streamer(b);
TUUID id(sbuf.Data());
fUUID = id;
b.ClassEnd(TDirectory::Class());
fSeekKeys = 0;
} else {
b >> version;
fDatimeC.Streamer(b);
fDatimeM.Streamer(b);
b >> fNbytesKeys;
b >> fNbytesName;
if (version > 1000) {
SetBit(kIsBigFile);
b >> fSeekDir;
b >> fSeekParent;
b >> fSeekKeys;
} else {
Int_t sdir,sparent,skeys;
b >> sdir; fSeekDir = (Long64_t)sdir;
b >> sparent; fSeekParent = (Long64_t)sparent;
b >> skeys; fSeekKeys = (Long64_t)skeys;
}
v = version%1000;
if (v == 2) {
fUUID.StreamerV1(b);
} else if (v > 2) {
fUUID.Streamer(b);
}
}
R__LOCKGUARD2(gROOTMutex);
gROOT->GetUUIDs()->AddUUID(fUUID,this);
if (fSeekKeys) ReadKeys();
} else {
if (fFile && !fFile->IsBinary()) {
b.WriteVersion(TDirectory::Class());
TString sbuf;
b.ClassBegin(TDirectory::Class());
b.ClassMember("CreateTime","TString");
sbuf = fDatimeC.AsSQLString();
sbuf.Streamer(b);
b.ClassMember("ModifyTime","TString");
fDatimeM.Set();
sbuf = fDatimeM.AsSQLString();
sbuf.Streamer(b);
b.ClassMember("UUID","TString");
sbuf = fUUID.AsString();
sbuf.Streamer(b);
b.ClassEnd(TDirectory::Class());
} else {
version = TDirectory::Class_Version();
if (fFile && fFile->GetEND() > TFile::kStartBigFile) version += 1000;
b << version;
fDatimeC.Streamer(b);
fDatimeM.Streamer(b);
b << fNbytesKeys;
b << fNbytesName;
if (version > 1000) {
b << fSeekDir;
b << fSeekParent;
b << fSeekKeys;
} else {
b << (Int_t)fSeekDir;
b << (Int_t)fSeekParent;
b << (Int_t)fSeekKeys;
}
fUUID.Streamer(b);
if (version <=1000) for (Int_t i=0;i<3;i++) b << Int_t(0);
}
}
}
Int_t TDirectory::Write(const char *, Int_t opt, Int_t bufsiz)
{
if (!IsWritable()) return 0;
TDirectory::TContext ctxt(this);
TIter next(fList);
TObject *obj;
Int_t nbytes = 0;
while ((obj=next())) {
nbytes += obj->Write(0,opt,bufsiz);
}
SaveSelf(kTRUE);
return nbytes;
}
Int_t TDirectory::Write(const char *n, Int_t opt, Int_t bufsize) const
{
Error("Write const","A const TDirectory object should not be saved. We try to proceed anyway.");
return const_cast<TDirectory*>(this)->Write(n, opt, bufsize);
}
Int_t TDirectory::WriteTObject(const TObject *obj, const char *name, Option_t *option)
{
TDirectory::TContext ctxt(this);
if (fFile==0) return 0;
if (!fFile->IsWritable()) {
if (!fFile->TestBit(TFile::kWriteError)) {
Error("WriteTObject","Directory %s is not writable", fFile->GetName());
}
return 0;
}
if (!obj) return 0;
TString opt = option;
opt.ToLower();
TKey *key=0, *oldkey=0;
Int_t bsize = GetBufferSize();
const char *oname;
if (name && *name)
oname = name;
else
oname = obj->GetName();
Int_t nch = strlen(oname);
char *newName = 0;
if (oname[nch-1] == ' ') {
newName = new char[nch+1];
strcpy(newName,oname);
for (Int_t i=0;i<nch;i++) {
if (newName[nch-i-1] != ' ') break;
newName[nch-i-1] = 0;
}
oname = newName;
}
if (opt.Contains("overwrite")) {
key = GetKey(oname);
if (key) {
key->Delete();
delete key;
}
}
if (opt.Contains("writedelete")) {
oldkey = GetKey(oname);
}
key = fFile->CreateKey(this, obj, oname, bsize);
if (newName) delete [] newName;
if (!key->GetSeekKey()) {
fKeys->Remove(key);
delete key;
return 0;
}
fFile->SumBuffer(key->GetObjlen());
Int_t nbytes = key->WriteFile(0);
if (fFile->TestBit(TFile::kWriteError)) return 0;
if (oldkey) {
oldkey->Delete();
delete oldkey;
}
return nbytes;
}
Int_t TDirectory::WriteObjectAny(const void *obj, const char *classname, const char *name, Option_t *option)
{
TClass *cl = ROOT::GetROOT()->GetClass(classname);
if (!cl) {
Error("WriteObjectAny","Unknown class: %s",classname);
return 0;
}
return WriteObjectAny(obj,cl,name,option);
}
Int_t TDirectory::WriteObjectAny(const void *obj, const TClass *cl, const char *name, Option_t *option)
{
TDirectory::TContext ctxt(this);
if (fFile==0) return 0;
if (!fFile->IsWritable()) {
if (!fFile->TestBit(TFile::kWriteError)) {
Error("WriteObject","File %s is not writable", fFile->GetName());
}
return 0;
}
if (!obj || !cl) return 0;
TKey *key, *oldkey=0;
Int_t bsize = GetBufferSize();
TString opt = option;
opt.ToLower();
const char *oname;
if (name && *name)
oname = name;
else
oname = cl->GetName();
Int_t nch = strlen(oname);
char *newName = 0;
if (oname[nch-1] == ' ') {
newName = new char[nch+1];
strcpy(newName,oname);
for (Int_t i=0;i<nch;i++) {
if (newName[nch-i-1] != ' ') break;
newName[nch-i-1] = 0;
}
oname = newName;
}
if (opt.Contains("overwrite")) {
key = GetKey(oname);
if (key) {
key->Delete();
delete key;
}
}
if (opt.Contains("writedelete")) {
oldkey = GetKey(oname);
}
key = fFile->CreateKey(this, obj, cl, oname, bsize);
if (newName) delete [] newName;
if (!key->GetSeekKey()) {
fKeys->Remove(key);
delete key;
return 0;
}
fFile->SumBuffer(key->GetObjlen());
Int_t nbytes = key->WriteFile(0);
if (fFile->TestBit(TFile::kWriteError)) return 0;
if (oldkey) {
oldkey->Delete();
delete oldkey;
}
return nbytes;
}
void TDirectory::WriteDirHeader()
{
TFile* f = GetFile();
if (f==0) return;
if (!f->IsBinary()) {
fDatimeM.Set();
f->DirWriteHeader(this);
return;
}
Int_t nbytes = TDirectory::Sizeof();
char * header = new char[nbytes];
char * buffer = header;
fDatimeM.Set();
TDirectory::FillBuffer(buffer);
Long64_t pointer = fSeekDir + fNbytesName;
fModified = kFALSE;
f->Seek(pointer);
f->WriteBuffer(header, nbytes);
if (f->MustFlush()) f->Flush();
delete [] header;
}
void TDirectory::WriteKeys()
{
TFile* f = GetFile();
if (f==0) return;
if (!f->IsBinary()) {
f->DirWriteKeys(this);
return;
}
if (fSeekKeys != 0) {
f->MakeFree(fSeekKeys, fSeekKeys + fNbytesKeys -1);
}
TIter next(fKeys);
TKey *key;
Int_t nkeys = fKeys->GetSize();
Int_t nbytes = sizeof nkeys;
if (f->GetEND() > TFile::kStartBigFile) nbytes += 8;
while ((key = (TKey*)next())) {
nbytes += key->Sizeof();
}
TKey *headerkey = new TKey(fName,fTitle,IsA(),nbytes,this);
if (headerkey->GetSeekKey() == 0) {
delete headerkey;
return;
}
char *buffer = headerkey->GetBuffer();
next.Reset();
tobuf(buffer, nkeys);
while ((key = (TKey*)next())) {
key->FillBuffer(buffer);
}
fSeekKeys = headerkey->GetSeekKey();
fNbytesKeys = headerkey->GetNbytes();
headerkey->WriteFile();
delete headerkey;
}
void TDirectory::EncodeNameCycle(char *buffer, const char *name, Short_t cycle)
{
if (cycle == 9999)
strcpy(buffer, name);
else
sprintf(buffer, "%s;%d", name, cycle);
}
void TDirectory::DecodeNameCycle(const char *buffer, char *name, Short_t &cycle)
{
cycle = 9999;
Int_t nch = buffer ? strlen(buffer) : 0;
for (Int_t i = 0; i < nch; i++) {
if (buffer[i] != ';')
name[i] = buffer[i];
else {
name[i] = 0;
if (i < nch-1 )
if (buffer[i+1] == '*') {
cycle = 10000;
return;
}
sscanf(buffer+i+1, "%hd", &cycle);
return;
}
}
name[nch] = 0;
}
void TDirectory::TContext::CdNull()
{
gDirectory = 0;
}
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.